582 lines · plain
1// -*- C++ -*-2//===----------------------------------------------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP_FILESYSTEM11#define _LIBCPP_FILESYSTEM12 13/*14 filesystem synopsis15 16 namespace std::filesystem {17 18 // `class path` from http://eel.is/c++draft/fs.class.path.general#619 class path {20 public:21 using value_type = see below;22 using string_type = basic_string<value_type>;23 static constexpr value_type preferred_separator = see below;24 25 enum format;26 27 path() noexcept;28 path(const path& p);29 path(path&& p) noexcept;30 path(string_type&& source, format fmt = auto_format);31 template<class Source>32 path(const Source& source, format fmt = auto_format);33 template<class InputIterator>34 path(InputIterator first, InputIterator last, format fmt = auto_format);35 template<class Source>36 path(const Source& source, const locale& loc, format fmt = auto_format);37 template<class InputIterator>38 path(InputIterator first, InputIterator last, const locale& loc, format fmt = auto_format);39 ~path();40 41 path& operator=(const path& p);42 path& operator=(path&& p) noexcept;43 path& operator=(string_type&& source);44 path& assign(string_type&& source);45 template<class Source>46 path& operator=(const Source& source);47 template<class Source>48 path& assign(const Source& source);49 template<class InputIterator>50 path& assign(InputIterator first, InputIterator last);51 52 path& operator/=(const path& p);53 template<class Source>54 path& operator/=(const Source& source);55 template<class Source>56 path& append(const Source& source);57 template<class InputIterator>58 path& append(InputIterator first, InputIterator last);59 60 path& operator+=(const path& x);61 path& operator+=(const string_type& x);62 path& operator+=(basic_string_view<value_type> x);63 path& operator+=(const value_type* x);64 path& operator+=(value_type x);65 template<class Source>66 path& operator+=(const Source& x);67 template<class EcharT>68 path& operator+=(EcharT x);69 template<class Source>70 path& concat(const Source& x);71 template<class InputIterator>72 path& concat(InputIterator first, InputIterator last);73 74 void clear() noexcept;75 path& make_preferred();76 path& remove_filename();77 path& replace_filename(const path& replacement);78 path& replace_extension(const path& replacement = path());79 void swap(path& rhs) noexcept;80 81 friend bool operator==(const path& lhs, const path& rhs) noexcept;82 friend bool operator!=(const path& lhs, const path& rhs) noexcept; // removed in C++2083 friend bool operator< (const path& lhs, const path& rhs) noexcept; // removed in C++2084 friend bool operator<=(const path& lhs, const path& rhs) noexcept; // removed in C++2085 friend bool operator> (const path& lhs, const path& rhs) noexcept; // removed in C++2086 friend bool operator>=(const path& lhs, const path& rhs) noexcept; // removed in C++2087 friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept; // C++2088 89 friend path operator/(const path& lhs, const path& rhs);90 91 const string_type& native() const noexcept;92 const value_type* c_str() const noexcept;93 operator string_type() const;94 95 template<class EcharT, class traits = char_traits<EcharT>,96 class Allocator = allocator<EcharT>>97 basic_string<EcharT, traits, Allocator>98 string(const Allocator& a = Allocator()) const;99 std::string string() const;100 std::wstring wstring() const;101 std::u8string u8string() const;102 std::u16string u16string() const;103 std::u32string u32string() const;104 105 template<class EcharT, class traits = char_traits<EcharT>,106 class Allocator = allocator<EcharT>>107 basic_string<EcharT, traits, Allocator>108 generic_string(const Allocator& a = Allocator()) const;109 std::string generic_string() const;110 std::wstring generic_wstring() const;111 std::u8string generic_u8string() const;112 std::u16string generic_u16string() const;113 std::u32string generic_u32string() const;114 115 int compare(const path& p) const noexcept;116 int compare(const string_type& s) const;117 int compare(basic_string_view<value_type> s) const;118 int compare(const value_type* s) const;119 120 path root_name() const;121 path root_directory() const;122 path root_path() const;123 path relative_path() const;124 path parent_path() const;125 path filename() const;126 path stem() const;127 path extension() const;128 129 [[nodiscard]] bool empty() const noexcept;130 bool has_root_name() const;131 bool has_root_directory() const;132 bool has_root_path() const;133 bool has_relative_path() const;134 bool has_parent_path() const;135 bool has_filename() const;136 bool has_stem() const;137 bool has_extension() const;138 bool is_absolute() const;139 bool is_relative() const;140 141 path lexically_normal() const;142 path lexically_relative(const path& base) const;143 path lexically_proximate(const path& base) const;144 145 class iterator;146 using const_iterator = iterator;147 148 iterator begin() const;149 iterator end() const;150 151 template<class charT, class traits>152 friend basic_ostream<charT, traits>&153 operator<<(basic_ostream<charT, traits>& os, const path& p);154 template<class charT, class traits>155 friend basic_istream<charT, traits>&156 operator>>(basic_istream<charT, traits>& is, path& p);157 };158 159 void swap(path& lhs, path& rhs) noexcept;160 size_t hash_value(const path& p) noexcept;161 162 // [fs.path.hash], hash support163 template<> struct hash<filesystem::path>;164 165 template <class Source>166 path u8path(const Source& source);167 template <class InputIterator>168 path u8path(InputIterator first, InputIterator last);169 170 class filesystem_error;171 172 class directory_entry {173 public:174 directory_entry() noexcept = default;175 directory_entry(const directory_entry&) = default;176 directory_entry(directory_entry&&) noexcept = default;177 explicit directory_entry(const filesystem::path& p);178 directory_entry(const filesystem::path& p, error_code& ec);179 ~directory_entry();180 181 directory_entry& operator=(const directory_entry&) = default;182 directory_entry& operator=(directory_entry&&) noexcept = default;183 184 void assign(const filesystem::path& p);185 void assign(const filesystem::path& p, error_code& ec);186 void replace_filename(const filesystem::path& p);187 void replace_filename(const filesystem::path& p, error_code& ec);188 void refresh();189 void refresh(error_code& ec) noexcept;190 191 const filesystem::path& path() const noexcept;192 operator const filesystem::path&() const noexcept;193 bool exists() const;194 bool exists(error_code& ec) const noexcept;195 bool is_block_file() const;196 bool is_block_file(error_code& ec) const noexcept;197 bool is_character_file() const;198 bool is_character_file(error_code& ec) const noexcept;199 bool is_directory() const;200 bool is_directory(error_code& ec) const noexcept;201 bool is_fifo() const;202 bool is_fifo(error_code& ec) const noexcept;203 bool is_other() const;204 bool is_other(error_code& ec) const noexcept;205 bool is_regular_file() const;206 bool is_regular_file(error_code& ec) const noexcept;207 bool is_socket() const;208 bool is_socket(error_code& ec) const noexcept;209 bool is_symlink() const;210 bool is_symlink(error_code& ec) const noexcept;211 uintmax_t file_size() const;212 uintmax_t file_size(error_code& ec) const noexcept;213 uintmax_t hard_link_count() const;214 uintmax_t hard_link_count(error_code& ec) const noexcept;215 file_time_type last_write_time() const;216 file_time_type last_write_time(error_code& ec) const noexcept;217 file_status status() const;218 file_status status(error_code& ec) const noexcept;219 file_status symlink_status() const;220 file_status symlink_status(error_code& ec) const noexcept;221 222 bool operator==(const directory_entry& rhs) const noexcept;223 bool operator!=(const directory_entry& rhs) const noexcept; // removed in C++20224 bool operator< (const directory_entry& rhs) const noexcept; // removed in C++20225 bool operator<=(const directory_entry& rhs) const noexcept; // removed in C++20226 bool operator> (const directory_entry& rhs) const noexcept; // removed in C++20227 bool operator>=(const directory_entry& rhs) const noexcept; // removed in C++20228 strong_ordering operator<=>(const directory_entry& rhs) const noexcept; // since C++20229 230 template<class charT, class traits>231 friend basic_ostream<charT, traits>&232 operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);233 234 private:235 filesystem::path pathobject; // exposition only236 friend class directory_iterator; // exposition only237 };238 239 class directory_iterator {240 public:241 using iterator_category = input_iterator_tag;242 using value_type = directory_entry;243 using difference_type = ptrdiff_t;244 using pointer = const directory_entry*;245 using reference = const directory_entry&;246 247 // [fs.dir.itr.members], member functions248 directory_iterator() noexcept;249 explicit directory_iterator(const path& p);250 directory_iterator(const path& p, directory_options options);251 directory_iterator(const path& p, error_code& ec);252 directory_iterator(const path& p, directory_options options,253 error_code& ec);254 directory_iterator(const directory_iterator& rhs);255 directory_iterator(directory_iterator&& rhs) noexcept;256 ~directory_iterator();257 258 directory_iterator& operator=(const directory_iterator& rhs);259 directory_iterator& operator=(directory_iterator&& rhs) noexcept;260 261 const directory_entry& operator*() const;262 const directory_entry* operator->() const;263 directory_iterator& operator++();264 directory_iterator& increment(error_code& ec);265 266 bool operator==(default_sentinel_t) const noexcept { // since C++20267 return *this == directory_iterator();268 }269 270 // other members as required by [input.iterators], input iterators271 };272 273 // enable directory_iterator range-based for statements274 directory_iterator begin(directory_iterator iter) noexcept;275 directory_iterator end(directory_iterator) noexcept;276 277class recursive_directory_iterator {278 public:279 using iterator_category = input_iterator_tag;280 using value_type = directory_entry;281 using difference_type = ptrdiff_t;282 using pointer = const directory_entry*;283 using reference = const directory_entry&;284 285 // [fs.rec.dir.itr.members], constructors and destructor286 recursive_directory_iterator() noexcept;287 explicit recursive_directory_iterator(const path& p);288 recursive_directory_iterator(const path& p, directory_options options);289 recursive_directory_iterator(const path& p, directory_options options,290 error_code& ec);291 recursive_directory_iterator(const path& p, error_code& ec);292 recursive_directory_iterator(const recursive_directory_iterator& rhs);293 recursive_directory_iterator(recursive_directory_iterator&& rhs) noexcept;294 ~recursive_directory_iterator();295 296 // [fs.rec.dir.itr.members], observers297 directory_options options() const;298 int depth() const;299 bool recursion_pending() const;300 301 const directory_entry& operator*() const;302 const directory_entry* operator->() const;303 304 // [fs.rec.dir.itr.members], modifiers305 recursive_directory_iterator&306 operator=(const recursive_directory_iterator& rhs);307 recursive_directory_iterator&308 operator=(recursive_directory_iterator&& rhs) noexcept;309 310 recursive_directory_iterator& operator++();311 recursive_directory_iterator& increment(error_code& ec);312 313 void pop();314 void pop(error_code& ec);315 void disable_recursion_pending();316 317 bool operator==(default_sentinel_t) const noexcept { // since C++20318 return *this == recursive_directory_iterator();319 }320 321 // other members as required by [input.iterators], input iterators322 };323 324 // enable recursive_directory_iterator range-based for statements325 recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;326 recursive_directory_iterator end(recursive_directory_iterator) noexcept;327 328 class file_status {329 public:330 // [fs.file.status.cons], constructors and destructor331 file_status() noexcept : file_status(file_type::none) {}332 explicit file_status(file_type ft,333 perms prms = perms::unknown) noexcept;334 file_status(const file_status&) noexcept = default;335 file_status(file_status&&) noexcept = default;336 ~file_status();337 338 // assignments339 file_status& operator=(const file_status&) noexcept = default;340 file_status& operator=(file_status&&) noexcept = default;341 342 // [fs.file.status.mods], modifiers343 void type(file_type ft) noexcept;344 void permissions(perms prms) noexcept;345 346 // [fs.file.status.obs], observers347 file_type type() const noexcept;348 perms permissions() const noexcept;349 350 friend bool operator==(const file_status& lhs, const file_status& rhs) noexcept351 { return lhs.type() == rhs.type() && lhs.permissions() == rhs.permissions(); } // C++20352 };353 354 struct space_info355 {356 uintmax_t capacity;357 uintmax_t free;358 uintmax_t available;359 360 friend bool operator==(const space_info&, const space_info&) = default; // C++20361 };362 363 enum class file_type;364 enum class perms;365 enum class perm_options;366 enum class copy_options;367 enum class directory_options;368 369 typedef chrono::time_point<trivial-clock> file_time_type;370 371 // operational functions372 373 path absolute(const path& p);374 path absolute(const path& p, error_code &ec);375 376 path canonical(const path& p);377 path canonical(const path& p, error_code& ec);378 379 void copy(const path& from, const path& to);380 void copy(const path& from, const path& to, error_code& ec);381 void copy(const path& from, const path& to, copy_options options);382 void copy(const path& from, const path& to, copy_options options,383 error_code& ec);384 385 bool copy_file(const path& from, const path& to);386 bool copy_file(const path& from, const path& to, error_code& ec);387 bool copy_file(const path& from, const path& to, copy_options option);388 bool copy_file(const path& from, const path& to, copy_options option,389 error_code& ec);390 391 void copy_symlink(const path& existing_symlink, const path& new_symlink);392 void copy_symlink(const path& existing_symlink, const path& new_symlink,393 error_code& ec) noexcept;394 395 bool create_directories(const path& p);396 bool create_directories(const path& p, error_code& ec);397 398 bool create_directory(const path& p);399 bool create_directory(const path& p, error_code& ec) noexcept;400 401 bool create_directory(const path& p, const path& attributes);402 bool create_directory(const path& p, const path& attributes,403 error_code& ec) noexcept;404 405 void create_directory_symlink(const path& to, const path& new_symlink);406 void create_directory_symlink(const path& to, const path& new_symlink,407 error_code& ec) noexcept;408 409 void create_hard_link(const path& to, const path& new_hard_link);410 void create_hard_link(const path& to, const path& new_hard_link,411 error_code& ec) noexcept;412 413 void create_symlink(const path& to, const path& new_symlink);414 void create_symlink(const path& to, const path& new_symlink,415 error_code& ec) noexcept;416 417 path current_path();418 path current_path(error_code& ec);419 void current_path(const path& p);420 void current_path(const path& p, error_code& ec) noexcept;421 422 bool exists(file_status s) noexcept;423 bool exists(const path& p);424 bool exists(const path& p, error_code& ec) noexcept;425 426 bool equivalent(const path& p1, const path& p2);427 bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;428 429 uintmax_t file_size(const path& p);430 uintmax_t file_size(const path& p, error_code& ec) noexcept;431 432 uintmax_t hard_link_count(const path& p);433 uintmax_t hard_link_count(const path& p, error_code& ec) noexcept;434 435 bool is_block_file(file_status s) noexcept;436 bool is_block_file(const path& p);437 bool is_block_file(const path& p, error_code& ec) noexcept;438 439 bool is_character_file(file_status s) noexcept;440 bool is_character_file(const path& p);441 bool is_character_file(const path& p, error_code& ec) noexcept;442 443 bool is_directory(file_status s) noexcept;444 bool is_directory(const path& p);445 bool is_directory(const path& p, error_code& ec) noexcept;446 447 bool is_empty(const path& p);448 bool is_empty(const path& p, error_code& ec) noexcept;449 450 bool is_fifo(file_status s) noexcept;451 bool is_fifo(const path& p);452 bool is_fifo(const path& p, error_code& ec) noexcept;453 454 bool is_other(file_status s) noexcept;455 bool is_other(const path& p);456 bool is_other(const path& p, error_code& ec) noexcept;457 458 bool is_regular_file(file_status s) noexcept;459 bool is_regular_file(const path& p);460 bool is_regular_file(const path& p, error_code& ec) noexcept;461 462 bool is_socket(file_status s) noexcept;463 bool is_socket(const path& p);464 bool is_socket(const path& p, error_code& ec) noexcept;465 466 bool is_symlink(file_status s) noexcept;467 bool is_symlink(const path& p);468 bool is_symlink(const path& p, error_code& ec) noexcept;469 470 file_time_type last_write_time(const path& p);471 file_time_type last_write_time(const path& p, error_code& ec) noexcept;472 void last_write_time(const path& p, file_time_type new_time);473 void last_write_time(const path& p, file_time_type new_time,474 error_code& ec) noexcept;475 476 void permissions(const path& p, perms prms,477 perm_options opts=perm_options::replace);478 void permissions(const path& p, perms prms, error_code& ec) noexcept;479 void permissions(const path& p, perms prms, perm_options opts,480 error_code& ec);481 482 path proximate(const path& p, error_code& ec);483 path proximate(const path& p, const path& base = current_path());484 path proximate(const path& p, const path& base, error_code &ec);485 486 path read_symlink(const path& p);487 path read_symlink(const path& p, error_code& ec);488 489 path relative(const path& p, error_code& ec);490 path relative(const path& p, const path& base=current_path());491 path relative(const path& p, const path& base, error_code& ec);492 493 bool remove(const path& p);494 bool remove(const path& p, error_code& ec) noexcept;495 496 uintmax_t remove_all(const path& p);497 uintmax_t remove_all(const path& p, error_code& ec);498 499 void rename(const path& from, const path& to);500 void rename(const path& from, const path& to, error_code& ec) noexcept;501 502 void resize_file(const path& p, uintmax_t size);503 void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;504 505 space_info space(const path& p);506 space_info space(const path& p, error_code& ec) noexcept;507 508 file_status status(const path& p);509 file_status status(const path& p, error_code& ec) noexcept;510 511 bool status_known(file_status s) noexcept;512 513 file_status symlink_status(const path& p);514 file_status symlink_status(const path& p, error_code& ec) noexcept;515 516 path temp_directory_path();517 path temp_directory_path(error_code& ec);518 519 path weakly_canonical(path const& p);520 path weakly_canonical(path const& p, error_code& ec);521 522} // namespace std::filesystem523 524template <>525inline constexpr bool std::ranges::enable_borrowed_range<std::filesystem::directory_iterator> = true;526template <>527inline constexpr bool std::ranges::enable_borrowed_range<std::filesystem::recursive_directory_iterator> = true;528 529template <>530inline constexpr bool std::ranges::enable_view<std::filesystem::directory_iterator> = true;531template <>532inline constexpr bool std::ranges::enable_view<std::filesystem::recursive_directory_iterator> = true;533 534*/535 536#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)537# include <__cxx03/__config>538#else539# include <__config>540 541# if _LIBCPP_STD_VER >= 17542# include <__filesystem/copy_options.h>543# include <__filesystem/directory_entry.h>544# include <__filesystem/directory_iterator.h>545# include <__filesystem/directory_options.h>546# include <__filesystem/file_status.h>547# include <__filesystem/file_time_type.h>548# include <__filesystem/file_type.h>549# include <__filesystem/filesystem_error.h>550# include <__filesystem/operations.h>551# include <__filesystem/path.h>552# include <__filesystem/path_iterator.h>553# include <__filesystem/perm_options.h>554# include <__filesystem/perms.h>555# include <__filesystem/recursive_directory_iterator.h>556# include <__filesystem/space_info.h>557# include <__filesystem/u8path.h>558# endif559 560# include <version>561 562// standard-mandated includes563 564// [fs.filesystem.syn]565# include <compare>566 567# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)568# pragma GCC system_header569# endif570 571# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20572# include <concepts>573# include <cstdlib>574# include <cstring>575# include <iosfwd>576# include <new>577# include <system_error>578# endif579#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)580 581#endif // _LIBCPP_FILESYSTEM582