Warning, /include/c++/v1/__cxx03/filesystem is written in an unsupported language. File is not indexed.
0001 // -*- C++ -*-
0002 //===----------------------------------------------------------------------===//
0003 //
0004 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0005 // See https://llvm.org/LICENSE.txt for license information.
0006 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0007 //
0008 //===----------------------------------------------------------------------===//
0009
0010 #ifndef _LIBCPP___CXX03_FILESYSTEM
0011 #define _LIBCPP___CXX03_FILESYSTEM
0012
0013 /*
0014 filesystem synopsis
0015
0016 namespace std::filesystem {
0017
0018 // `class path` from http://eel.is/c++draft/fs.class.path.general#6
0019 class path {
0020 public:
0021 using value_type = see below;
0022 using string_type = basic_string<value_type>;
0023 static constexpr value_type preferred_separator = see below;
0024
0025 enum format;
0026
0027 path() noexcept;
0028 path(const path& p);
0029 path(path&& p) noexcept;
0030 path(string_type&& source, format fmt = auto_format);
0031 template<class Source>
0032 path(const Source& source, format fmt = auto_format);
0033 template<class InputIterator>
0034 path(InputIterator first, InputIterator last, format fmt = auto_format);
0035 template<class Source>
0036 path(const Source& source, const locale& loc, format fmt = auto_format);
0037 template<class InputIterator>
0038 path(InputIterator first, InputIterator last, const locale& loc, format fmt = auto_format);
0039 ~path();
0040
0041 path& operator=(const path& p);
0042 path& operator=(path&& p) noexcept;
0043 path& operator=(string_type&& source);
0044 path& assign(string_type&& source);
0045 template<class Source>
0046 path& operator=(const Source& source);
0047 template<class Source>
0048 path& assign(const Source& source);
0049 template<class InputIterator>
0050 path& assign(InputIterator first, InputIterator last);
0051
0052 path& operator/=(const path& p);
0053 template<class Source>
0054 path& operator/=(const Source& source);
0055 template<class Source>
0056 path& append(const Source& source);
0057 template<class InputIterator>
0058 path& append(InputIterator first, InputIterator last);
0059
0060 path& operator+=(const path& x);
0061 path& operator+=(const string_type& x);
0062 path& operator+=(basic_string_view<value_type> x);
0063 path& operator+=(const value_type* x);
0064 path& operator+=(value_type x);
0065 template<class Source>
0066 path& operator+=(const Source& x);
0067 template<class EcharT>
0068 path& operator+=(EcharT x);
0069 template<class Source>
0070 path& concat(const Source& x);
0071 template<class InputIterator>
0072 path& concat(InputIterator first, InputIterator last);
0073
0074 void clear() noexcept;
0075 path& make_preferred();
0076 path& remove_filename();
0077 path& replace_filename(const path& replacement);
0078 path& replace_extension(const path& replacement = path());
0079 void swap(path& rhs) noexcept;
0080
0081 friend bool operator==(const path& lhs, const path& rhs) noexcept;
0082 friend bool operator!=(const path& lhs, const path& rhs) noexcept; // removed in C++20
0083 friend bool operator< (const path& lhs, const path& rhs) noexcept; // removed in C++20
0084 friend bool operator<=(const path& lhs, const path& rhs) noexcept; // removed in C++20
0085 friend bool operator> (const path& lhs, const path& rhs) noexcept; // removed in C++20
0086 friend bool operator>=(const path& lhs, const path& rhs) noexcept; // removed in C++20
0087 friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept; // C++20
0088
0089 friend path operator/(const path& lhs, const path& rhs);
0090
0091 const string_type& native() const noexcept;
0092 const value_type* c_str() const noexcept;
0093 operator string_type() const;
0094
0095 template<class EcharT, class traits = char_traits<EcharT>,
0096 class Allocator = allocator<EcharT>>
0097 basic_string<EcharT, traits, Allocator>
0098 string(const Allocator& a = Allocator()) const;
0099 std::string string() const;
0100 std::wstring wstring() const;
0101 std::u8string u8string() const;
0102 std::u16string u16string() const;
0103 std::u32string u32string() const;
0104
0105 template<class EcharT, class traits = char_traits<EcharT>,
0106 class Allocator = allocator<EcharT>>
0107 basic_string<EcharT, traits, Allocator>
0108 generic_string(const Allocator& a = Allocator()) const;
0109 std::string generic_string() const;
0110 std::wstring generic_wstring() const;
0111 std::u8string generic_u8string() const;
0112 std::u16string generic_u16string() const;
0113 std::u32string generic_u32string() const;
0114
0115 int compare(const path& p) const noexcept;
0116 int compare(const string_type& s) const;
0117 int compare(basic_string_view<value_type> s) const;
0118 int compare(const value_type* s) const;
0119
0120 path root_name() const;
0121 path root_directory() const;
0122 path root_path() const;
0123 path relative_path() const;
0124 path parent_path() const;
0125 path filename() const;
0126 path stem() const;
0127 path extension() const;
0128
0129 [[nodiscard]] bool empty() const noexcept;
0130 bool has_root_name() const;
0131 bool has_root_directory() const;
0132 bool has_root_path() const;
0133 bool has_relative_path() const;
0134 bool has_parent_path() const;
0135 bool has_filename() const;
0136 bool has_stem() const;
0137 bool has_extension() const;
0138 bool is_absolute() const;
0139 bool is_relative() const;
0140
0141 path lexically_normal() const;
0142 path lexically_relative(const path& base) const;
0143 path lexically_proximate(const path& base) const;
0144
0145 class iterator;
0146 using const_iterator = iterator;
0147
0148 iterator begin() const;
0149 iterator end() const;
0150
0151 template<class charT, class traits>
0152 friend basic_ostream<charT, traits>&
0153 operator<<(basic_ostream<charT, traits>& os, const path& p);
0154 template<class charT, class traits>
0155 friend basic_istream<charT, traits>&
0156 operator>>(basic_istream<charT, traits>& is, path& p);
0157 };
0158
0159 void swap(path& lhs, path& rhs) noexcept;
0160 size_t hash_value(const path& p) noexcept;
0161
0162 // [fs.path.hash], hash support
0163 template<> struct hash<filesystem::path>;
0164
0165 template <class Source>
0166 path u8path(const Source& source);
0167 template <class InputIterator>
0168 path u8path(InputIterator first, InputIterator last);
0169
0170 class filesystem_error;
0171
0172 class directory_entry {
0173 public:
0174 directory_entry() noexcept = default;
0175 directory_entry(const directory_entry&) = default;
0176 directory_entry(directory_entry&&) noexcept = default;
0177 explicit directory_entry(const filesystem::path& p);
0178 directory_entry(const filesystem::path& p, error_code& ec);
0179 ~directory_entry();
0180
0181 directory_entry& operator=(const directory_entry&) = default;
0182 directory_entry& operator=(directory_entry&&) noexcept = default;
0183
0184 void assign(const filesystem::path& p);
0185 void assign(const filesystem::path& p, error_code& ec);
0186 void replace_filename(const filesystem::path& p);
0187 void replace_filename(const filesystem::path& p, error_code& ec);
0188 void refresh();
0189 void refresh(error_code& ec) noexcept;
0190
0191 const filesystem::path& path() const noexcept;
0192 operator const filesystem::path&() const noexcept;
0193 bool exists() const;
0194 bool exists(error_code& ec) const noexcept;
0195 bool is_block_file() const;
0196 bool is_block_file(error_code& ec) const noexcept;
0197 bool is_character_file() const;
0198 bool is_character_file(error_code& ec) const noexcept;
0199 bool is_directory() const;
0200 bool is_directory(error_code& ec) const noexcept;
0201 bool is_fifo() const;
0202 bool is_fifo(error_code& ec) const noexcept;
0203 bool is_other() const;
0204 bool is_other(error_code& ec) const noexcept;
0205 bool is_regular_file() const;
0206 bool is_regular_file(error_code& ec) const noexcept;
0207 bool is_socket() const;
0208 bool is_socket(error_code& ec) const noexcept;
0209 bool is_symlink() const;
0210 bool is_symlink(error_code& ec) const noexcept;
0211 uintmax_t file_size() const;
0212 uintmax_t file_size(error_code& ec) const noexcept;
0213 uintmax_t hard_link_count() const;
0214 uintmax_t hard_link_count(error_code& ec) const noexcept;
0215 file_time_type last_write_time() const;
0216 file_time_type last_write_time(error_code& ec) const noexcept;
0217 file_status status() const;
0218 file_status status(error_code& ec) const noexcept;
0219 file_status symlink_status() const;
0220 file_status symlink_status(error_code& ec) const noexcept;
0221
0222 bool operator==(const directory_entry& rhs) const noexcept;
0223 bool operator!=(const directory_entry& rhs) const noexcept; // removed in C++20
0224 bool operator< (const directory_entry& rhs) const noexcept; // removed in C++20
0225 bool operator<=(const directory_entry& rhs) const noexcept; // removed in C++20
0226 bool operator> (const directory_entry& rhs) const noexcept; // removed in C++20
0227 bool operator>=(const directory_entry& rhs) const noexcept; // removed in C++20
0228 strong_ordering operator<=>(const directory_entry& rhs) const noexcept; // since C++20
0229
0230 template<class charT, class traits>
0231 friend basic_ostream<charT, traits>&
0232 operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);
0233
0234 private:
0235 filesystem::path pathobject; // exposition only
0236 friend class directory_iterator; // exposition only
0237 };
0238
0239 class directory_iterator {
0240 public:
0241 using iterator_category = input_iterator_tag;
0242 using value_type = directory_entry;
0243 using difference_type = ptrdiff_t;
0244 using pointer = const directory_entry*;
0245 using reference = const directory_entry&;
0246
0247 // [fs.dir.itr.members], member functions
0248 directory_iterator() noexcept;
0249 explicit directory_iterator(const path& p);
0250 directory_iterator(const path& p, directory_options options);
0251 directory_iterator(const path& p, error_code& ec);
0252 directory_iterator(const path& p, directory_options options,
0253 error_code& ec);
0254 directory_iterator(const directory_iterator& rhs);
0255 directory_iterator(directory_iterator&& rhs) noexcept;
0256 ~directory_iterator();
0257
0258 directory_iterator& operator=(const directory_iterator& rhs);
0259 directory_iterator& operator=(directory_iterator&& rhs) noexcept;
0260
0261 const directory_entry& operator*() const;
0262 const directory_entry* operator->() const;
0263 directory_iterator& operator++();
0264 directory_iterator& increment(error_code& ec);
0265
0266 bool operator==(default_sentinel_t) const noexcept { // since C++20
0267 return *this == directory_iterator();
0268 }
0269
0270 // other members as required by [input.iterators], input iterators
0271 };
0272
0273 // enable directory_iterator range-based for statements
0274 directory_iterator begin(directory_iterator iter) noexcept;
0275 directory_iterator end(directory_iterator) noexcept;
0276
0277 class recursive_directory_iterator {
0278 public:
0279 using iterator_category = input_iterator_tag;
0280 using value_type = directory_entry;
0281 using difference_type = ptrdiff_t;
0282 using pointer = const directory_entry*;
0283 using reference = const directory_entry&;
0284
0285 // [fs.rec.dir.itr.members], constructors and destructor
0286 recursive_directory_iterator() noexcept;
0287 explicit recursive_directory_iterator(const path& p);
0288 recursive_directory_iterator(const path& p, directory_options options);
0289 recursive_directory_iterator(const path& p, directory_options options,
0290 error_code& ec);
0291 recursive_directory_iterator(const path& p, error_code& ec);
0292 recursive_directory_iterator(const recursive_directory_iterator& rhs);
0293 recursive_directory_iterator(recursive_directory_iterator&& rhs) noexcept;
0294 ~recursive_directory_iterator();
0295
0296 // [fs.rec.dir.itr.members], observers
0297 directory_options options() const;
0298 int depth() const;
0299 bool recursion_pending() const;
0300
0301 const directory_entry& operator*() const;
0302 const directory_entry* operator->() const;
0303
0304 // [fs.rec.dir.itr.members], modifiers
0305 recursive_directory_iterator&
0306 operator=(const recursive_directory_iterator& rhs);
0307 recursive_directory_iterator&
0308 operator=(recursive_directory_iterator&& rhs) noexcept;
0309
0310 recursive_directory_iterator& operator++();
0311 recursive_directory_iterator& increment(error_code& ec);
0312
0313 void pop();
0314 void pop(error_code& ec);
0315 void disable_recursion_pending();
0316
0317 bool operator==(default_sentinel_t) const noexcept { // since C++20
0318 return *this == recursive_directory_iterator();
0319 }
0320
0321 // other members as required by [input.iterators], input iterators
0322 };
0323
0324 // enable recursive_directory_iterator range-based for statements
0325 recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
0326 recursive_directory_iterator end(recursive_directory_iterator) noexcept;
0327
0328 class file_status {
0329 public:
0330 // [fs.file.status.cons], constructors and destructor
0331 file_status() noexcept : file_status(file_type::none) {}
0332 explicit file_status(file_type ft,
0333 perms prms = perms::unknown) noexcept;
0334 file_status(const file_status&) noexcept = default;
0335 file_status(file_status&&) noexcept = default;
0336 ~file_status();
0337
0338 // assignments
0339 file_status& operator=(const file_status&) noexcept = default;
0340 file_status& operator=(file_status&&) noexcept = default;
0341
0342 // [fs.file.status.mods], modifiers
0343 void type(file_type ft) noexcept;
0344 void permissions(perms prms) noexcept;
0345
0346 // [fs.file.status.obs], observers
0347 file_type type() const noexcept;
0348 perms permissions() const noexcept;
0349
0350 friend bool operator==(const file_status& lhs, const file_status& rhs) noexcept
0351 { return lhs.type() == rhs.type() && lhs.permissions() == rhs.permissions(); } // C++20
0352 };
0353
0354 struct space_info
0355 {
0356 uintmax_t capacity;
0357 uintmax_t free;
0358 uintmax_t available;
0359
0360 friend bool operator==(const space_info&, const space_info&) = default; // C++20
0361 };
0362
0363 enum class file_type;
0364 enum class perms;
0365 enum class perm_options;
0366 enum class copy_options;
0367 enum class directory_options;
0368
0369 typedef chrono::time_point<trivial-clock> file_time_type;
0370
0371 // operational functions
0372
0373 path absolute(const path& p);
0374 path absolute(const path& p, error_code &ec);
0375
0376 path canonical(const path& p);
0377 path canonical(const path& p, error_code& ec);
0378
0379 void copy(const path& from, const path& to);
0380 void copy(const path& from, const path& to, error_code& ec);
0381 void copy(const path& from, const path& to, copy_options options);
0382 void copy(const path& from, const path& to, copy_options options,
0383 error_code& ec);
0384
0385 bool copy_file(const path& from, const path& to);
0386 bool copy_file(const path& from, const path& to, error_code& ec);
0387 bool copy_file(const path& from, const path& to, copy_options option);
0388 bool copy_file(const path& from, const path& to, copy_options option,
0389 error_code& ec);
0390
0391 void copy_symlink(const path& existing_symlink, const path& new_symlink);
0392 void copy_symlink(const path& existing_symlink, const path& new_symlink,
0393 error_code& ec) noexcept;
0394
0395 bool create_directories(const path& p);
0396 bool create_directories(const path& p, error_code& ec);
0397
0398 bool create_directory(const path& p);
0399 bool create_directory(const path& p, error_code& ec) noexcept;
0400
0401 bool create_directory(const path& p, const path& attributes);
0402 bool create_directory(const path& p, const path& attributes,
0403 error_code& ec) noexcept;
0404
0405 void create_directory_symlink(const path& to, const path& new_symlink);
0406 void create_directory_symlink(const path& to, const path& new_symlink,
0407 error_code& ec) noexcept;
0408
0409 void create_hard_link(const path& to, const path& new_hard_link);
0410 void create_hard_link(const path& to, const path& new_hard_link,
0411 error_code& ec) noexcept;
0412
0413 void create_symlink(const path& to, const path& new_symlink);
0414 void create_symlink(const path& to, const path& new_symlink,
0415 error_code& ec) noexcept;
0416
0417 path current_path();
0418 path current_path(error_code& ec);
0419 void current_path(const path& p);
0420 void current_path(const path& p, error_code& ec) noexcept;
0421
0422 bool exists(file_status s) noexcept;
0423 bool exists(const path& p);
0424 bool exists(const path& p, error_code& ec) noexcept;
0425
0426 bool equivalent(const path& p1, const path& p2);
0427 bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
0428
0429 uintmax_t file_size(const path& p);
0430 uintmax_t file_size(const path& p, error_code& ec) noexcept;
0431
0432 uintmax_t hard_link_count(const path& p);
0433 uintmax_t hard_link_count(const path& p, error_code& ec) noexcept;
0434
0435 bool is_block_file(file_status s) noexcept;
0436 bool is_block_file(const path& p);
0437 bool is_block_file(const path& p, error_code& ec) noexcept;
0438
0439 bool is_character_file(file_status s) noexcept;
0440 bool is_character_file(const path& p);
0441 bool is_character_file(const path& p, error_code& ec) noexcept;
0442
0443 bool is_directory(file_status s) noexcept;
0444 bool is_directory(const path& p);
0445 bool is_directory(const path& p, error_code& ec) noexcept;
0446
0447 bool is_empty(const path& p);
0448 bool is_empty(const path& p, error_code& ec) noexcept;
0449
0450 bool is_fifo(file_status s) noexcept;
0451 bool is_fifo(const path& p);
0452 bool is_fifo(const path& p, error_code& ec) noexcept;
0453
0454 bool is_other(file_status s) noexcept;
0455 bool is_other(const path& p);
0456 bool is_other(const path& p, error_code& ec) noexcept;
0457
0458 bool is_regular_file(file_status s) noexcept;
0459 bool is_regular_file(const path& p);
0460 bool is_regular_file(const path& p, error_code& ec) noexcept;
0461
0462 bool is_socket(file_status s) noexcept;
0463 bool is_socket(const path& p);
0464 bool is_socket(const path& p, error_code& ec) noexcept;
0465
0466 bool is_symlink(file_status s) noexcept;
0467 bool is_symlink(const path& p);
0468 bool is_symlink(const path& p, error_code& ec) noexcept;
0469
0470 file_time_type last_write_time(const path& p);
0471 file_time_type last_write_time(const path& p, error_code& ec) noexcept;
0472 void last_write_time(const path& p, file_time_type new_time);
0473 void last_write_time(const path& p, file_time_type new_time,
0474 error_code& ec) noexcept;
0475
0476 void permissions(const path& p, perms prms,
0477 perm_options opts=perm_options::replace);
0478 void permissions(const path& p, perms prms, error_code& ec) noexcept;
0479 void permissions(const path& p, perms prms, perm_options opts,
0480 error_code& ec);
0481
0482 path proximate(const path& p, error_code& ec);
0483 path proximate(const path& p, const path& base = current_path());
0484 path proximate(const path& p, const path& base, error_code &ec);
0485
0486 path read_symlink(const path& p);
0487 path read_symlink(const path& p, error_code& ec);
0488
0489 path relative(const path& p, error_code& ec);
0490 path relative(const path& p, const path& base=current_path());
0491 path relative(const path& p, const path& base, error_code& ec);
0492
0493 bool remove(const path& p);
0494 bool remove(const path& p, error_code& ec) noexcept;
0495
0496 uintmax_t remove_all(const path& p);
0497 uintmax_t remove_all(const path& p, error_code& ec);
0498
0499 void rename(const path& from, const path& to);
0500 void rename(const path& from, const path& to, error_code& ec) noexcept;
0501
0502 void resize_file(const path& p, uintmax_t size);
0503 void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;
0504
0505 space_info space(const path& p);
0506 space_info space(const path& p, error_code& ec) noexcept;
0507
0508 file_status status(const path& p);
0509 file_status status(const path& p, error_code& ec) noexcept;
0510
0511 bool status_known(file_status s) noexcept;
0512
0513 file_status symlink_status(const path& p);
0514 file_status symlink_status(const path& p, error_code& ec) noexcept;
0515
0516 path temp_directory_path();
0517 path temp_directory_path(error_code& ec);
0518
0519 path weakly_canonical(path const& p);
0520 path weakly_canonical(path const& p, error_code& ec);
0521
0522 } // namespace std::filesystem
0523
0524 template <>
0525 inline constexpr bool std::ranges::enable_borrowed_range<std::filesystem::directory_iterator> = true;
0526 template <>
0527 inline constexpr bool std::ranges::enable_borrowed_range<std::filesystem::recursive_directory_iterator> = true;
0528
0529 template <>
0530 inline constexpr bool std::ranges::enable_view<std::filesystem::directory_iterator> = true;
0531 template <>
0532 inline constexpr bool std::ranges::enable_view<std::filesystem::recursive_directory_iterator> = true;
0533
0534 */
0535
0536 #include <__cxx03/__config>
0537
0538 #if _LIBCPP_STD_VER >= 17
0539 # include <__cxx03/__filesystem/copy_options.h>
0540 # include <__cxx03/__filesystem/directory_entry.h>
0541 # include <__cxx03/__filesystem/directory_iterator.h>
0542 # include <__cxx03/__filesystem/directory_options.h>
0543 # include <__cxx03/__filesystem/file_status.h>
0544 # include <__cxx03/__filesystem/file_time_type.h>
0545 # include <__cxx03/__filesystem/file_type.h>
0546 # include <__cxx03/__filesystem/filesystem_error.h>
0547 # include <__cxx03/__filesystem/operations.h>
0548 # include <__cxx03/__filesystem/path.h>
0549 # include <__cxx03/__filesystem/path_iterator.h>
0550 # include <__cxx03/__filesystem/perm_options.h>
0551 # include <__cxx03/__filesystem/perms.h>
0552 # include <__cxx03/__filesystem/recursive_directory_iterator.h>
0553 # include <__cxx03/__filesystem/space_info.h>
0554 # include <__cxx03/__filesystem/u8path.h>
0555 #endif
0556
0557 #include <__cxx03/version>
0558
0559 // standard-mandated includes
0560
0561 // [fs.filesystem.syn]
0562 #include <__cxx03/compare>
0563
0564 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
0565 # pragma GCC system_header
0566 #endif
0567
0568 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
0569 # include <__cxx03/concepts>
0570 # include <__cxx03/cstdlib>
0571 # include <__cxx03/cstring>
0572 # include <__cxx03/iosfwd>
0573 # include <__cxx03/new>
0574 # include <__cxx03/system_error>
0575 #endif
0576
0577 #endif // _LIBCPP___CXX03_FILESYSTEM
