1 // -*- C++ -*- 2 //===--------------------------- filesystem -------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 #ifndef _LIBCPP_EXPERIMENTAL_FILESYSTEM 11 #define _LIBCPP_EXPERIMENTAL_FILESYSTEM 12 /* 13 filesystem synopsis 14 15 namespace std { namespace experimental { namespace filesystem { inline namespace v1 { 16 17 class path; 18 19 void swap(path& lhs, path& rhs) _NOEXCEPT; 20 size_t hash_value(const path& p) _NOEXCEPT; 21 22 bool operator==(const path& lhs, const path& rhs) _NOEXCEPT; 23 bool operator!=(const path& lhs, const path& rhs) _NOEXCEPT; 24 bool operator< (const path& lhs, const path& rhs) _NOEXCEPT; 25 bool operator<=(const path& lhs, const path& rhs) _NOEXCEPT; 26 bool operator> (const path& lhs, const path& rhs) _NOEXCEPT; 27 bool operator>=(const path& lhs, const path& rhs) _NOEXCEPT; 28 29 path operator/ (const path& lhs, const path& rhs); 30 31 template <class charT, class traits> 32 basic_ostream<charT, traits>& 33 operator<<(basic_ostream<charT, traits>& os, const path& p); 34 35 template <class charT, class traits> 36 basic_istream<charT, traits>& 37 operator>>(basic_istream<charT, traits>& is, path& p); 38 39 template <class Source> 40 path u8path(const Source& source); 41 template <class InputIterator> 42 path u8path(InputIterator first, InputIterator last); 43 44 class filesystem_error; 45 class directory_entry; 46 47 class directory_iterator; 48 49 // enable directory_iterator range-based for statements 50 directory_iterator begin(directory_iterator iter) noexcept; 51 directory_iterator end(const directory_iterator&) noexcept; 52 53 class recursive_directory_iterator; 54 55 // enable recursive_directory_iterator range-based for statements 56 recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept; 57 recursive_directory_iterator end(const recursive_directory_iterator&) noexcept; 58 59 class file_status; 60 61 struct space_info 62 { 63 uintmax_t capacity; 64 uintmax_t free; 65 uintmax_t available; 66 }; 67 68 enum class file_type; 69 enum class perms; 70 enum class copy_options; 71 enum class directory_options; 72 73 typedef chrono::time_point<trivial-clock> file_time_type; 74 75 // operational functions 76 77 path absolute(const path& p, const path& base=current_path()); 78 79 path canonical(const path& p, const path& base = current_path()); 80 path canonical(const path& p, error_code& ec); 81 path canonical(const path& p, const path& base, error_code& ec); 82 83 void copy(const path& from, const path& to); 84 void copy(const path& from, const path& to, error_code& ec) _NOEXCEPT; 85 void copy(const path& from, const path& to, copy_options options); 86 void copy(const path& from, const path& to, copy_options options, 87 error_code& ec) _NOEXCEPT; 88 89 bool copy_file(const path& from, const path& to); 90 bool copy_file(const path& from, const path& to, error_code& ec) _NOEXCEPT; 91 bool copy_file(const path& from, const path& to, copy_options option); 92 bool copy_file(const path& from, const path& to, copy_options option, 93 error_code& ec) _NOEXCEPT; 94 95 void copy_symlink(const path& existing_symlink, const path& new_symlink); 96 void copy_symlink(const path& existing_symlink, const path& new_symlink, 97 error_code& ec) _NOEXCEPT; 98 99 bool create_directories(const path& p); 100 bool create_directories(const path& p, error_code& ec) _NOEXCEPT; 101 102 bool create_directory(const path& p); 103 bool create_directory(const path& p, error_code& ec) _NOEXCEPT; 104 105 bool create_directory(const path& p, const path& attributes); 106 bool create_directory(const path& p, const path& attributes, 107 error_code& ec) _NOEXCEPT; 108 109 void create_directory_symlink(const path& to, const path& new_symlink); 110 void create_directory_symlink(const path& to, const path& new_symlink, 111 error_code& ec) _NOEXCEPT; 112 113 void create_hard_link(const path& to, const path& new_hard_link); 114 void create_hard_link(const path& to, const path& new_hard_link, 115 error_code& ec) _NOEXCEPT; 116 117 void create_symlink(const path& to, const path& new_symlink); 118 void create_symlink(const path& to, const path& new_symlink, 119 error_code& ec) _NOEXCEPT; 120 121 path current_path(); 122 path current_path(error_code& ec); 123 void current_path(const path& p); 124 void current_path(const path& p, error_code& ec) _NOEXCEPT; 125 126 bool exists(file_status s) _NOEXCEPT; 127 bool exists(const path& p); 128 bool exists(const path& p, error_code& ec) _NOEXCEPT; 129 130 bool equivalent(const path& p1, const path& p2); 131 bool equivalent(const path& p1, const path& p2, error_code& ec) _NOEXCEPT; 132 133 uintmax_t file_size(const path& p); 134 uintmax_t file_size(const path& p, error_code& ec) _NOEXCEPT; 135 136 uintmax_t hard_link_count(const path& p); 137 uintmax_t hard_link_count(const path& p, error_code& ec) _NOEXCEPT; 138 139 bool is_block_file(file_status s) _NOEXCEPT; 140 bool is_block_file(const path& p); 141 bool is_block_file(const path& p, error_code& ec) _NOEXCEPT; 142 143 bool is_character_file(file_status s) _NOEXCEPT; 144 bool is_character_file(const path& p); 145 bool is_character_file(const path& p, error_code& ec) _NOEXCEPT; 146 147 bool is_directory(file_status s) _NOEXCEPT; 148 bool is_directory(const path& p); 149 bool is_directory(const path& p, error_code& ec) _NOEXCEPT; 150 151 bool is_empty(const path& p); 152 bool is_empty(const path& p, error_code& ec) _NOEXCEPT; 153 154 bool is_fifo(file_status s) _NOEXCEPT; 155 bool is_fifo(const path& p); 156 bool is_fifo(const path& p, error_code& ec) _NOEXCEPT; 157 158 bool is_other(file_status s) _NOEXCEPT; 159 bool is_other(const path& p); 160 bool is_other(const path& p, error_code& ec) _NOEXCEPT; 161 162 bool is_regular_file(file_status s) _NOEXCEPT; 163 bool is_regular_file(const path& p); 164 bool is_regular_file(const path& p, error_code& ec) _NOEXCEPT; 165 166 bool is_socket(file_status s) _NOEXCEPT; 167 bool is_socket(const path& p); 168 bool is_socket(const path& p, error_code& ec) _NOEXCEPT; 169 170 bool is_symlink(file_status s) _NOEXCEPT; 171 bool is_symlink(const path& p); 172 bool is_symlink(const path& p, error_code& ec) _NOEXCEPT; 173 174 file_time_type last_write_time(const path& p); 175 file_time_type last_write_time(const path& p, error_code& ec) _NOEXCEPT; 176 void last_write_time(const path& p, file_time_type new_time); 177 void last_write_time(const path& p, file_time_type new_time, 178 error_code& ec) _NOEXCEPT; 179 180 void permissions(const path& p, perms prms); 181 void permissions(const path& p, perms prms, error_code& ec) _NOEXCEPT; 182 183 path read_symlink(const path& p); 184 path read_symlink(const path& p, error_code& ec); 185 186 bool remove(const path& p); 187 bool remove(const path& p, error_code& ec) _NOEXCEPT; 188 189 uintmax_t remove_all(const path& p); 190 uintmax_t remove_all(const path& p, error_code& ec) _NOEXCEPT; 191 192 void rename(const path& from, const path& to); 193 void rename(const path& from, const path& to, error_code& ec) _NOEXCEPT; 194 195 void resize_file(const path& p, uintmax_t size); 196 void resize_file(const path& p, uintmax_t size, error_code& ec) _NOEXCEPT; 197 198 space_info space(const path& p); 199 space_info space(const path& p, error_code& ec) _NOEXCEPT; 200 201 file_status status(const path& p); 202 file_status status(const path& p, error_code& ec) _NOEXCEPT; 203 204 bool status_known(file_status s) _NOEXCEPT; 205 206 file_status symlink_status(const path& p); 207 file_status symlink_status(const path& p, error_code& ec) _NOEXCEPT; 208 209 path system_complete(const path& p); 210 path system_complete(const path& p, error_code& ec); 211 212 path temp_directory_path(); 213 path temp_directory_path(error_code& ec); 214 215 } } } } // namespaces std::experimental::filesystem::v1 216 217 */ 218 219 #include <experimental/__config> 220 #include <cstddef> 221 #include <chrono> 222 #include <iterator> 223 #include <iosfwd> 224 #include <locale> 225 #include <memory> 226 #include <stack> 227 #include <string> 228 #include <system_error> 229 #include <utility> 230 #include <iomanip> // for quoted 231 #include <string_view> 232 233 #include <__debug> 234 235 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 236 #pragma GCC system_header 237 #endif 238 239 #define __cpp_lib_experimental_filesystem 201406 240 241 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM 242 243 typedef chrono::time_point<std::chrono::system_clock> file_time_type; 244 245 struct _LIBCPP_TYPE_VIS space_info 246 { 247 uintmax_t capacity; 248 uintmax_t free; 249 uintmax_t available; 250 }; 251 252 enum class _LIBCPP_ENUM_VIS file_type : signed char 253 { 254 none = 0, 255 not_found = -1, 256 regular = 1, 257 directory = 2, 258 symlink = 3, 259 block = 4, 260 character = 5, 261 fifo = 6, 262 socket = 7, 263 unknown = 8 264 }; 265 266 enum class _LIBCPP_ENUM_VIS perms : unsigned 267 { 268 none = 0, 269 270 owner_read = 0400, 271 owner_write = 0200, 272 owner_exec = 0100, 273 owner_all = 0700, 274 275 group_read = 040, 276 group_write = 020, 277 group_exec = 010, 278 group_all = 070, 279 280 others_read = 04, 281 others_write = 02, 282 others_exec = 01, 283 others_all = 07, 284 285 all = 0777, 286 287 set_uid = 04000, 288 set_gid = 02000, 289 sticky_bit = 01000, 290 mask = 07777, 291 unknown = 0xFFFF, 292 293 add_perms = 0x10000, 294 remove_perms = 0x20000, 295 symlink_nofollow = 0x40000 296 }; 297 298 _LIBCPP_INLINE_VISIBILITY 299 inline _LIBCPP_CONSTEXPR perms operator&(perms _LHS, perms _RHS) 300 { return static_cast<perms>(static_cast<unsigned>(_LHS) & static_cast<unsigned>(_RHS)); } 301 302 _LIBCPP_INLINE_VISIBILITY 303 inline _LIBCPP_CONSTEXPR perms operator|(perms _LHS, perms _RHS) 304 { return static_cast<perms>(static_cast<unsigned>(_LHS) | static_cast<unsigned>(_RHS)); } 305 306 _LIBCPP_INLINE_VISIBILITY 307 inline _LIBCPP_CONSTEXPR perms operator^(perms _LHS, perms _RHS) 308 { return static_cast<perms>(static_cast<unsigned>(_LHS) ^ static_cast<unsigned>(_RHS)); } 309 310 _LIBCPP_INLINE_VISIBILITY 311 inline _LIBCPP_CONSTEXPR perms operator~(perms _LHS) 312 { return static_cast<perms>(~static_cast<unsigned>(_LHS)); } 313 314 _LIBCPP_INLINE_VISIBILITY 315 inline perms& operator&=(perms& _LHS, perms _RHS) 316 { return _LHS = _LHS & _RHS; } 317 318 _LIBCPP_INLINE_VISIBILITY 319 inline perms& operator|=(perms& _LHS, perms _RHS) 320 { return _LHS = _LHS | _RHS; } 321 322 _LIBCPP_INLINE_VISIBILITY 323 inline perms& operator^=(perms& _LHS, perms _RHS) 324 { return _LHS = _LHS ^ _RHS; } 325 326 enum class _LIBCPP_ENUM_VIS copy_options : unsigned short 327 { 328 none = 0, 329 skip_existing = 1, 330 overwrite_existing = 2, 331 update_existing = 4, 332 recursive = 8, 333 copy_symlinks = 16, 334 skip_symlinks = 32, 335 directories_only = 64, 336 create_symlinks = 128, 337 create_hard_links = 256, 338 __in_recursive_copy = 512, 339 }; 340 341 _LIBCPP_INLINE_VISIBILITY 342 inline _LIBCPP_CONSTEXPR copy_options operator&(copy_options _LHS, copy_options _RHS) 343 { return static_cast<copy_options>(static_cast<unsigned short>(_LHS) & static_cast<unsigned short>(_RHS)); } 344 345 _LIBCPP_INLINE_VISIBILITY 346 inline _LIBCPP_CONSTEXPR copy_options operator|(copy_options _LHS, copy_options _RHS) 347 { return static_cast<copy_options>(static_cast<unsigned short>(_LHS) | static_cast<unsigned short>(_RHS)); } 348 349 _LIBCPP_INLINE_VISIBILITY 350 inline _LIBCPP_CONSTEXPR copy_options operator^(copy_options _LHS, copy_options _RHS) 351 { return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^ static_cast<unsigned short>(_RHS)); } 352 353 _LIBCPP_INLINE_VISIBILITY 354 inline _LIBCPP_CONSTEXPR copy_options operator~(copy_options _LHS) 355 { return static_cast<copy_options>(~static_cast<unsigned short>(_LHS)); } 356 357 _LIBCPP_INLINE_VISIBILITY 358 inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS) 359 { return _LHS = _LHS & _RHS; } 360 361 _LIBCPP_INLINE_VISIBILITY 362 inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS) 363 { return _LHS = _LHS | _RHS; } 364 365 _LIBCPP_INLINE_VISIBILITY 366 inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS) 367 { return _LHS = _LHS ^ _RHS; } 368 369 370 enum class _LIBCPP_ENUM_VIS directory_options : unsigned char 371 { 372 none = 0, 373 follow_directory_symlink = 1, 374 skip_permission_denied = 2 375 }; 376 377 _LIBCPP_INLINE_VISIBILITY 378 inline _LIBCPP_CONSTEXPR directory_options operator&(directory_options _LHS, directory_options _RHS) 379 { return static_cast<directory_options>(static_cast<unsigned char>(_LHS) & static_cast<unsigned char>(_RHS)); } 380 381 _LIBCPP_INLINE_VISIBILITY 382 inline _LIBCPP_CONSTEXPR directory_options operator|(directory_options _LHS, directory_options _RHS) 383 { return static_cast<directory_options>(static_cast<unsigned char>(_LHS) | static_cast<unsigned char>(_RHS)); } 384 385 _LIBCPP_INLINE_VISIBILITY 386 inline _LIBCPP_CONSTEXPR directory_options operator^(directory_options _LHS, directory_options _RHS) 387 { return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^ static_cast<unsigned char>(_RHS)); } 388 389 _LIBCPP_INLINE_VISIBILITY 390 inline _LIBCPP_CONSTEXPR directory_options operator~(directory_options _LHS) 391 { return static_cast<directory_options>(~static_cast<unsigned char>(_LHS)); } 392 393 _LIBCPP_INLINE_VISIBILITY 394 inline directory_options& operator&=(directory_options& _LHS, directory_options _RHS) 395 { return _LHS = _LHS & _RHS; } 396 397 _LIBCPP_INLINE_VISIBILITY 398 inline directory_options& operator|=(directory_options& _LHS, directory_options _RHS) 399 { return _LHS = _LHS | _RHS; } 400 401 _LIBCPP_INLINE_VISIBILITY 402 inline directory_options& operator^=(directory_options& _LHS, directory_options _RHS) 403 { return _LHS = _LHS ^ _RHS; } 404 405 406 class _LIBCPP_TYPE_VIS file_status 407 { 408 public: 409 // constructors 410 _LIBCPP_INLINE_VISIBILITY 411 file_status() _NOEXCEPT : file_status(file_type::none) {} 412 _LIBCPP_INLINE_VISIBILITY 413 explicit file_status(file_type __ft, 414 perms __prms = perms::unknown) _NOEXCEPT 415 : __ft_(__ft), __prms_(__prms) 416 {} 417 418 file_status(const file_status&) _NOEXCEPT = default; 419 file_status(file_status&&) _NOEXCEPT = default; 420 421 _LIBCPP_INLINE_VISIBILITY 422 ~file_status() {} 423 424 file_status& operator=(const file_status&) _NOEXCEPT = default; 425 file_status& operator=(file_status&&) _NOEXCEPT = default; 426 427 // observers 428 _LIBCPP_ALWAYS_INLINE 429 file_type type() const _NOEXCEPT { 430 return __ft_; 431 } 432 433 _LIBCPP_ALWAYS_INLINE 434 perms permissions() const _NOEXCEPT { 435 return __prms_; 436 } 437 438 // modifiers 439 _LIBCPP_ALWAYS_INLINE 440 void type(file_type __ft) _NOEXCEPT { 441 __ft_ = __ft; 442 } 443 444 _LIBCPP_ALWAYS_INLINE 445 void permissions(perms __p) _NOEXCEPT { 446 __prms_ = __p; 447 } 448 private: 449 file_type __ft_; 450 perms __prms_; 451 }; 452 453 class _LIBCPP_TYPE_VIS directory_entry; 454 455 template <class _Tp> struct __can_convert_char { 456 static const bool value = false; 457 }; 458 template <class _Tp> struct __can_convert_char<const _Tp> 459 : public __can_convert_char<_Tp> { 460 }; 461 template <> struct __can_convert_char<char> { 462 static const bool value = true; 463 using __char_type = char; 464 }; 465 template <> struct __can_convert_char<wchar_t> { 466 static const bool value = true; 467 using __char_type = wchar_t; 468 }; 469 template <> struct __can_convert_char<char16_t> { 470 static const bool value = true; 471 using __char_type = char16_t; 472 }; 473 template <> struct __can_convert_char<char32_t> { 474 static const bool value = true; 475 using __char_type = char32_t; 476 }; 477 478 template <class _ECharT> 479 typename enable_if<__can_convert_char<_ECharT>::value, bool>::type 480 __is_separator(_ECharT __e) { 481 return __e == _ECharT('/'); 482 }; 483 484 struct _NullSentinal {}; 485 486 template <class _Tp> 487 using _Void = void; 488 489 template <class _Tp, class = void> 490 struct __is_pathable_string : public false_type {}; 491 492 template <class _ECharT, class _Traits, class _Alloc> 493 struct __is_pathable_string<basic_string<_ECharT, _Traits, _Alloc>, 494 _Void<typename __can_convert_char<_ECharT>::__char_type>> 495 : public __can_convert_char<_ECharT> 496 { 497 using _Str = basic_string<_ECharT, _Traits, _Alloc>; 498 using _Base = __can_convert_char<_ECharT>; 499 static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); } 500 static _ECharT const* __range_end(_Str const& __s) { return __s.data() + __s.length(); } 501 static _ECharT __first_or_null(_Str const& __s) { 502 return __s.empty() ? _ECharT{} : __s[0]; 503 } 504 }; 505 506 507 template <class _ECharT, class _Traits> 508 struct __is_pathable_string<basic_string_view<_ECharT, _Traits>, 509 _Void<typename __can_convert_char<_ECharT>::__char_type>> 510 : public __can_convert_char<_ECharT> 511 { 512 using _Str = basic_string_view<_ECharT, _Traits>; 513 using _Base = __can_convert_char<_ECharT>; 514 static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); } 515 static _ECharT const* __range_end(_Str const& __s) { return __s.data() + __s.length(); } 516 static _ECharT __first_or_null(_Str const& __s) { 517 return __s.empty() ? _ECharT{} : __s[0]; 518 } 519 }; 520 521 template <class _Source, 522 class _DS = typename decay<_Source>::type, 523 class _UnqualPtrType = typename remove_const< 524 typename remove_pointer<_DS>::type>::type, 525 bool _IsCharPtr = is_pointer<_DS>::value && 526 __can_convert_char<_UnqualPtrType>::value 527 > 528 struct __is_pathable_char_array : false_type {}; 529 530 template <class _Source, class _ECharT, class _UPtr> 531 struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true> 532 : __can_convert_char<typename remove_const<_ECharT>::type> 533 { 534 using _Base = __can_convert_char<typename remove_const<_ECharT>::type>; 535 536 static _ECharT const* __range_begin(const _ECharT* __b) { return __b; } 537 static _ECharT const* __range_end(const _ECharT* __b) 538 { 539 using _Iter = const _ECharT*; 540 const _ECharT __sentinal = _ECharT{}; 541 _Iter __e = __b; 542 for (; *__e != __sentinal; ++__e) 543 ; 544 return __e; 545 } 546 547 static _ECharT __first_or_null(const _ECharT* __b) { return *__b; } 548 }; 549 550 template <class _Iter, bool _IsIt = __is_input_iterator<_Iter>::value, class = void> 551 struct __is_pathable_iter : false_type {}; 552 553 template <class _Iter> 554 struct __is_pathable_iter<_Iter, true, 555 _Void<typename __can_convert_char<typename iterator_traits<_Iter>::value_type>::__char_type>> 556 : __can_convert_char<typename iterator_traits<_Iter>::value_type> 557 { 558 using _ECharT = typename iterator_traits<_Iter>::value_type; 559 using _Base = __can_convert_char<_ECharT>; 560 561 static _Iter __range_begin(_Iter __b) { return __b; } 562 static _NullSentinal __range_end(_Iter) { return _NullSentinal{}; } 563 564 static _ECharT __first_or_null(_Iter __b) { return *__b; } 565 }; 566 567 template <class _Tp, bool _IsStringT = __is_pathable_string<_Tp>::value, 568 bool _IsCharIterT = __is_pathable_char_array<_Tp>::value, 569 bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value 570 > 571 struct __is_pathable : false_type { 572 static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false"); 573 }; 574 575 template <class _Tp> 576 struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {}; 577 578 579 template <class _Tp> 580 struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {}; 581 582 583 template <class _Tp> 584 struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {}; 585 586 587 template <class _ECharT> 588 struct _PathCVT { 589 static_assert(__can_convert_char<_ECharT>::value, "Char type not convertible"); 590 591 typedef __narrow_to_utf8<sizeof(_ECharT)*__CHAR_BIT__> _Narrower; 592 593 static void __append_range(string& __dest, _ECharT const* __b, _ECharT const* __e) { 594 _Narrower()(back_inserter(__dest), __b, __e); 595 } 596 597 template <class _Iter> 598 static void __append_range(string& __dest, _Iter __b, _Iter __e) { 599 static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload"); 600 if (__b == __e) return; 601 basic_string<_ECharT> __tmp(__b, __e); 602 _Narrower()(back_inserter(__dest), __tmp.data(), 603 __tmp.data() + __tmp.length()); 604 } 605 606 template <class _Iter> 607 static void __append_range(string& __dest, _Iter __b, _NullSentinal) { 608 static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload"); 609 const _ECharT __sentinal = _ECharT{}; 610 if (*__b == __sentinal) return; 611 basic_string<_ECharT> __tmp; 612 for (; *__b != __sentinal; ++__b) 613 __tmp.push_back(*__b); 614 _Narrower()(back_inserter(__dest), __tmp.data(), 615 __tmp.data() + __tmp.length()); 616 } 617 618 template <class _Source> 619 static void __append_source(string& __dest, _Source const& __s) 620 { 621 using _Traits = __is_pathable<_Source>; 622 __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s)); 623 } 624 }; 625 626 template <> 627 struct _PathCVT<char> { 628 629 template <class _Iter> 630 static typename enable_if< 631 __is_exactly_input_iterator<_Iter>::value 632 >::type __append_range(string& __dest, _Iter __b, _Iter __e) { 633 for (; __b != __e; ++__b) 634 __dest.push_back(*__b); 635 } 636 637 template <class _Iter> 638 static typename enable_if< 639 __is_forward_iterator<_Iter>::value 640 >::type __append_range(string& __dest, _Iter __b, _Iter __e) { 641 __dest.__append_forward_unsafe(__b, __e); 642 } 643 644 template <class _Iter> 645 static void __append_range(string& __dest, _Iter __b, _NullSentinal) { 646 const char __sentinal = char{}; 647 for (; *__b != __sentinal; ++__b) 648 __dest.push_back(*__b); 649 } 650 651 template <class _Source> 652 static void __append_source(string& __dest, _Source const& __s) 653 { 654 using _Traits = __is_pathable<_Source>; 655 __append_range(__dest, _Traits::__range_begin(__s), 656 _Traits::__range_end(__s)); 657 } 658 }; 659 660 661 class _LIBCPP_TYPE_VIS path 662 { 663 template <class _SourceOrIter, class _Tp = path&> 664 using _EnableIfPathable = typename 665 enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type; 666 667 template <class _Tp> 668 using _SourceChar = typename __is_pathable<_Tp>::__char_type; 669 670 template <class _Tp> 671 using _SourceCVT = _PathCVT<_SourceChar<_Tp>>; 672 673 public: 674 typedef char value_type; 675 typedef basic_string<value_type> string_type; 676 typedef _VSTD::string_view __string_view; 677 static _LIBCPP_CONSTEXPR value_type preferred_separator = '/'; 678 679 // constructors and destructor 680 _LIBCPP_INLINE_VISIBILITY path() _NOEXCEPT {} 681 _LIBCPP_INLINE_VISIBILITY path(const path& __p) : __pn_(__p.__pn_) {} 682 _LIBCPP_INLINE_VISIBILITY path(path&& __p) _NOEXCEPT : __pn_(_VSTD::move(__p.__pn_)) {} 683 684 _LIBCPP_INLINE_VISIBILITY 685 path(string_type&& __s) _NOEXCEPT : __pn_(_VSTD::move(__s)) {} 686 687 template < 688 class _Source, 689 class = _EnableIfPathable<_Source, void> 690 > 691 path(const _Source& __src) { 692 _SourceCVT<_Source>::__append_source(__pn_, __src); 693 } 694 695 template <class _InputIt> 696 path(_InputIt __first, _InputIt __last) { 697 typedef typename iterator_traits<_InputIt>::value_type _ItVal; 698 _PathCVT<_ItVal>::__append_range(__pn_, __first, __last); 699 } 700 701 // TODO Implement locale conversions. 702 template <class _Source, 703 class = _EnableIfPathable<_Source, void> 704 > 705 path(const _Source& __src, const locale& __loc); 706 template <class _InputIt> 707 path(_InputIt __first, _InputIt _last, const locale& __loc); 708 709 _LIBCPP_INLINE_VISIBILITY 710 ~path() = default; 711 712 // assignments 713 _LIBCPP_INLINE_VISIBILITY 714 path& operator=(const path& __p) { 715 __pn_ = __p.__pn_; 716 return *this; 717 } 718 719 _LIBCPP_INLINE_VISIBILITY 720 path& operator=(path&& __p) _NOEXCEPT { 721 __pn_ = _VSTD::move(__p.__pn_); 722 return *this; 723 } 724 725 template <class = void> 726 _LIBCPP_INLINE_VISIBILITY 727 path& operator=(string_type&& __s) _NOEXCEPT { 728 __pn_ = _VSTD::move(__s); 729 return *this; 730 } 731 732 _LIBCPP_INLINE_VISIBILITY 733 path& assign(string_type&& __s) _NOEXCEPT { 734 __pn_ = _VSTD::move(__s); 735 return *this; 736 } 737 738 template <class _Source> 739 _LIBCPP_INLINE_VISIBILITY 740 _EnableIfPathable<_Source> 741 operator=(const _Source& __src) 742 { return this->assign(__src); } 743 744 745 template <class _Source> 746 _EnableIfPathable<_Source> 747 assign(const _Source& __src) { 748 __pn_.clear(); 749 _SourceCVT<_Source>::__append_source(__pn_, __src); 750 return *this; 751 } 752 753 template <class _InputIt> 754 path& assign(_InputIt __first, _InputIt __last) { 755 typedef typename iterator_traits<_InputIt>::value_type _ItVal; 756 __pn_.clear(); 757 _PathCVT<_ItVal>::__append_range(__pn_, __first, __last); 758 return *this; 759 } 760 761 private: 762 template <class _ECharT> 763 void __append_sep_if_needed(_ECharT __first_or_null) { 764 const _ECharT __null_val = {}; 765 bool __append_sep = !empty() && 766 !__is_separator(__pn_.back()) && 767 __first_or_null != __null_val && // non-empty 768 !__is_separator(__first_or_null); 769 if (__append_sep) 770 __pn_ += preferred_separator; 771 } 772 773 public: 774 // appends 775 path& operator/=(const path& __p) { 776 _LIBCPP_ASSERT(!__p.has_root_name(), 777 "cannot append to a path with a root name"); 778 __append_sep_if_needed(__p.empty() ? char{} : __p.__pn_[0]); 779 __pn_ += __p.native(); 780 return *this; 781 } 782 783 template <class _Source> 784 _LIBCPP_INLINE_VISIBILITY 785 _EnableIfPathable<_Source> 786 operator/=(const _Source& __src) { 787 return this->append(__src); 788 } 789 790 template <class _Source> 791 _EnableIfPathable<_Source> 792 append(const _Source& __src) { 793 using _Traits = __is_pathable<_Source>; 794 using _CVT = _PathCVT<_SourceChar<_Source>>; 795 __append_sep_if_needed(_Traits::__first_or_null(__src)); 796 _CVT::__append_source(__pn_, __src); 797 return *this; 798 } 799 800 template <class _InputIt> 801 path& append(_InputIt __first, _InputIt __last) { 802 typedef typename iterator_traits<_InputIt>::value_type _ItVal; 803 static_assert(__can_convert_char<_ItVal>::value, "Must convertible"); 804 using _CVT = _PathCVT<_ItVal>; 805 if (__first != __last) { 806 __append_sep_if_needed(*__first); 807 _CVT::__append_range(__pn_, __first, __last); 808 } 809 return *this; 810 } 811 812 // concatenation 813 _LIBCPP_INLINE_VISIBILITY 814 path& operator+=(const path& __x) { 815 __pn_ += __x.__pn_; 816 return *this; 817 } 818 819 _LIBCPP_INLINE_VISIBILITY 820 path& operator+=(const string_type& __x) { 821 __pn_ += __x; 822 return *this; 823 } 824 825 _LIBCPP_INLINE_VISIBILITY 826 path& operator+=(__string_view __x) { 827 __pn_ += __x; 828 return *this; 829 } 830 831 _LIBCPP_INLINE_VISIBILITY 832 path& operator+=(const value_type* __x) { 833 __pn_ += __x; 834 return *this; 835 } 836 837 _LIBCPP_INLINE_VISIBILITY 838 path& operator+=(value_type __x) { 839 __pn_ += __x; 840 return *this; 841 } 842 843 template <class _ECharT> 844 typename enable_if<__can_convert_char<_ECharT>::value, path&>::type 845 operator+=(_ECharT __x) 846 { 847 basic_string<_ECharT> __tmp; 848 __tmp += __x; 849 _PathCVT<_ECharT>::__append_source(__pn_, __tmp); 850 return *this; 851 } 852 853 template <class _Source> 854 _EnableIfPathable<_Source> 855 operator+=(const _Source& __x) { 856 return this->concat(__x); 857 } 858 859 template <class _Source> 860 _EnableIfPathable<_Source> 861 concat(const _Source& __x) { 862 _SourceCVT<_Source>::__append_source(__pn_, __x); 863 return *this; 864 } 865 866 template <class _InputIt> 867 path& concat(_InputIt __first, _InputIt __last) { 868 typedef typename iterator_traits<_InputIt>::value_type _ItVal; 869 _PathCVT<_ItVal>::__append_range(__pn_, __first, __last); 870 return *this; 871 } 872 873 // modifiers 874 _LIBCPP_INLINE_VISIBILITY 875 void clear() _NOEXCEPT { 876 __pn_.clear(); 877 } 878 879 path& make_preferred() { return *this; } 880 881 _LIBCPP_INLINE_VISIBILITY 882 path& remove_filename() { 883 if (__pn_.size() == __root_path_raw().size()) 884 clear(); 885 else 886 __pn_ = __parent_path(); 887 return *this; 888 } 889 890 path& replace_filename(const path& __replacement) { 891 remove_filename(); 892 return (*this /= __replacement); 893 } 894 895 path& replace_extension(const path& __replacement = path()); 896 897 _LIBCPP_INLINE_VISIBILITY 898 void swap(path& __rhs) _NOEXCEPT { 899 __pn_.swap(__rhs.__pn_); 900 } 901 902 // native format observers 903 _LIBCPP_INLINE_VISIBILITY 904 const string_type& native() const _NOEXCEPT { 905 return __pn_; 906 } 907 908 _LIBCPP_INLINE_VISIBILITY 909 const value_type* c_str() const _NOEXCEPT { return __pn_.c_str(); } 910 911 _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_; } 912 913 template <class _ECharT, class _Traits = char_traits<_ECharT>, 914 class _Allocator = allocator<_ECharT> > 915 basic_string<_ECharT, _Traits, _Allocator> 916 string(const _Allocator& __a = _Allocator()) const { 917 using _CVT = __widen_from_utf8<sizeof(_ECharT)*__CHAR_BIT__>; 918 using _Str = basic_string<_ECharT, _Traits, _Allocator>; 919 _Str __s(__a); 920 __s.reserve(__pn_.size()); 921 _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size()); 922 return __s; 923 } 924 925 _LIBCPP_INLINE_VISIBILITY std::string string() const { return __pn_; } 926 _LIBCPP_INLINE_VISIBILITY std::wstring wstring() const { return string<wchar_t>(); } 927 _LIBCPP_INLINE_VISIBILITY std::string u8string() const { return __pn_; } 928 _LIBCPP_INLINE_VISIBILITY std::u16string u16string() const { return string<char16_t>(); } 929 _LIBCPP_INLINE_VISIBILITY std::u32string u32string() const { return string<char32_t>(); } 930 931 // generic format observers 932 template <class _ECharT, class _Traits = char_traits<_ECharT>, 933 class _Allocator = allocator<_ECharT> 934 > 935 basic_string<_ECharT, _Traits, _Allocator> 936 generic_string(const _Allocator& __a = _Allocator()) const { 937 return string<_ECharT, _Traits, _Allocator>(__a); 938 } 939 940 std::string generic_string() const { return __pn_; } 941 std::wstring generic_wstring() const { return string<wchar_t>(); } 942 std::string generic_u8string() const { return __pn_; } 943 std::u16string generic_u16string() const { return string<char16_t>(); } 944 std::u32string generic_u32string() const { return string<char32_t>(); } 945 946 private: 947 int __compare(__string_view) const; 948 __string_view __root_name() const; 949 __string_view __root_directory() const; 950 __string_view __root_path_raw() const; 951 __string_view __relative_path() const; 952 __string_view __parent_path() const; 953 __string_view __filename() const; 954 __string_view __stem() const; 955 __string_view __extension() const; 956 957 public: 958 // compare 959 _LIBCPP_INLINE_VISIBILITY int compare(const path& __p) const _NOEXCEPT { return __compare(__p.__pn_);} 960 _LIBCPP_INLINE_VISIBILITY int compare(const string_type& __s) const { return __compare(__s); } 961 _LIBCPP_INLINE_VISIBILITY int compare(__string_view __s) const { return __compare(__s); } 962 _LIBCPP_INLINE_VISIBILITY int compare(const value_type* __s) const { return __compare(__s); } 963 964 // decomposition 965 _LIBCPP_INLINE_VISIBILITY path root_name() const { return string_type(__root_name()); } 966 _LIBCPP_INLINE_VISIBILITY path root_directory() const { return string_type(__root_directory()); } 967 _LIBCPP_INLINE_VISIBILITY path root_path() const { return root_name().append(string_type(__root_directory())); } 968 _LIBCPP_INLINE_VISIBILITY path relative_path() const { return string_type(__relative_path()); } 969 _LIBCPP_INLINE_VISIBILITY path parent_path() const { return string_type(__parent_path()); } 970 _LIBCPP_INLINE_VISIBILITY path filename() const { return string_type(__filename()); } 971 _LIBCPP_INLINE_VISIBILITY path stem() const { return string_type(__stem());} 972 _LIBCPP_INLINE_VISIBILITY path extension() const { return string_type(__extension()); } 973 974 // query 975 _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT { return __pn_.empty(); } 976 977 _LIBCPP_INLINE_VISIBILITY bool has_root_name() const { return !__root_name().empty(); } 978 _LIBCPP_INLINE_VISIBILITY bool has_root_directory() const { return !__root_directory().empty(); } 979 _LIBCPP_INLINE_VISIBILITY bool has_root_path() const { return !__root_path_raw().empty(); } 980 _LIBCPP_INLINE_VISIBILITY bool has_relative_path() const { return !__relative_path().empty(); } 981 _LIBCPP_INLINE_VISIBILITY bool has_parent_path() const { return !__parent_path().empty(); } 982 _LIBCPP_INLINE_VISIBILITY bool has_filename() const { return !__filename().empty(); } 983 _LIBCPP_INLINE_VISIBILITY bool has_stem() const { return !__stem().empty(); } 984 _LIBCPP_INLINE_VISIBILITY bool has_extension() const { return !__extension().empty(); } 985 986 _LIBCPP_INLINE_VISIBILITY bool is_absolute() const { return has_root_directory(); } 987 _LIBCPP_INLINE_VISIBILITY bool is_relative() const { return !is_absolute(); } 988 989 // iterators 990 class _LIBCPP_TYPE_VIS iterator; 991 typedef iterator const_iterator; 992 993 iterator begin() const; 994 iterator end() const; 995 996 private: 997 inline _LIBCPP_INLINE_VISIBILITY 998 path& __assign_view(__string_view const& __s) noexcept { __pn_ = string_type(__s); return *this; } 999 string_type __pn_; 1000 }; 1001 1002 inline _LIBCPP_ALWAYS_INLINE 1003 void swap(path& __lhs, path& __rhs) _NOEXCEPT { 1004 __lhs.swap(__rhs); 1005 } 1006 1007 _LIBCPP_FUNC_VIS 1008 size_t hash_value(const path& __p) _NOEXCEPT; 1009 1010 inline _LIBCPP_INLINE_VISIBILITY 1011 bool operator==(const path& __lhs, const path& __rhs) _NOEXCEPT 1012 { return __lhs.compare(__rhs) == 0; } 1013 1014 inline _LIBCPP_INLINE_VISIBILITY 1015 bool operator!=(const path& __lhs, const path& __rhs) _NOEXCEPT 1016 { return __lhs.compare(__rhs) != 0; } 1017 1018 inline _LIBCPP_INLINE_VISIBILITY 1019 bool operator<(const path& __lhs, const path& __rhs) _NOEXCEPT 1020 { return __lhs.compare(__rhs) < 0; } 1021 1022 inline _LIBCPP_INLINE_VISIBILITY 1023 bool operator<=(const path& __lhs, const path& __rhs) _NOEXCEPT 1024 { return __lhs.compare(__rhs) <= 0; } 1025 1026 inline _LIBCPP_INLINE_VISIBILITY 1027 bool operator>(const path& __lhs, const path& __rhs) _NOEXCEPT 1028 { return __lhs.compare(__rhs) > 0; } 1029 1030 inline _LIBCPP_INLINE_VISIBILITY 1031 bool operator>=(const path& __lhs, const path& __rhs) _NOEXCEPT 1032 { return __lhs.compare(__rhs) >= 0; } 1033 1034 inline _LIBCPP_INLINE_VISIBILITY 1035 path operator/(const path& __lhs, const path& __rhs) { 1036 return path(__lhs) /= __rhs; 1037 } 1038 1039 template <class _CharT, class _Traits> 1040 _LIBCPP_INLINE_VISIBILITY 1041 typename enable_if<is_same<_CharT, char>::value && 1042 is_same<_Traits, char_traits<char>>::value, 1043 basic_ostream<_CharT, _Traits>& 1044 >::type 1045 operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) { 1046 __os << std::__quoted(__p.native()); 1047 return __os; 1048 } 1049 1050 template <class _CharT, class _Traits> 1051 _LIBCPP_INLINE_VISIBILITY 1052 typename enable_if<!is_same<_CharT, char>::value || 1053 !is_same<_Traits, char_traits<char>>::value, 1054 basic_ostream<_CharT, _Traits>& 1055 >::type 1056 operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) { 1057 __os << std::__quoted(__p.string<_CharT, _Traits>()); 1058 return __os; 1059 } 1060 1061 template <class _CharT, class _Traits> 1062 _LIBCPP_INLINE_VISIBILITY 1063 basic_istream<_CharT, _Traits>& 1064 operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) 1065 { 1066 basic_string<_CharT, _Traits> __tmp; 1067 __is >> __quoted(__tmp); 1068 __p = __tmp; 1069 return __is; 1070 } 1071 1072 template <class _Source> 1073 _LIBCPP_INLINE_VISIBILITY 1074 typename enable_if<__is_pathable<_Source>::value, path>::type 1075 u8path(const _Source& __s){ 1076 static_assert(is_same<typename __is_pathable<_Source>::__char_type, char>::value, 1077 "u8path(Source const&) requires Source have a character type of type 'char'"); 1078 return path(__s); 1079 } 1080 1081 template <class _InputIt> 1082 _LIBCPP_INLINE_VISIBILITY 1083 typename enable_if<__is_pathable<_InputIt>::value, path>::type 1084 u8path(_InputIt __f, _InputIt __l) { 1085 static_assert(is_same<typename __is_pathable<_InputIt>::__char_type, char>::value, 1086 "u8path(Iter, Iter) requires Iter have a value_type of type 'char'"); 1087 return path(__f, __l); 1088 } 1089 1090 class _LIBCPP_TYPE_VIS path::iterator 1091 { 1092 public: 1093 typedef bidirectional_iterator_tag iterator_category; 1094 1095 typedef path value_type; 1096 typedef std::ptrdiff_t difference_type; 1097 typedef const path* pointer; 1098 typedef const path& reference; 1099 1100 typedef void __stashing_iterator_tag; // See reverse_iterator and __is_stashing_iterator 1101 public: 1102 _LIBCPP_INLINE_VISIBILITY 1103 iterator() : __stashed_elem_(), __path_ptr_(nullptr), 1104 __entry_(), __state_(__singular) {} 1105 1106 iterator(const iterator&) = default; 1107 ~iterator() = default; 1108 1109 iterator& operator=(const iterator&) = default; 1110 1111 _LIBCPP_INLINE_VISIBILITY 1112 reference operator*() const { 1113 return __stashed_elem_; 1114 } 1115 1116 _LIBCPP_INLINE_VISIBILITY 1117 pointer operator->() const { 1118 return &__stashed_elem_; 1119 } 1120 1121 _LIBCPP_INLINE_VISIBILITY 1122 iterator& operator++() { 1123 _LIBCPP_ASSERT(__state_ != __singular, 1124 "attempting to increment a singular iterator"); 1125 _LIBCPP_ASSERT(__state_ != __at_end, 1126 "attempting to increment the end iterator"); 1127 return __increment(); 1128 } 1129 1130 _LIBCPP_INLINE_VISIBILITY 1131 iterator operator++(int) { 1132 iterator __it(*this); 1133 this->operator++(); 1134 return __it; 1135 } 1136 1137 _LIBCPP_INLINE_VISIBILITY 1138 iterator& operator--() { 1139 _LIBCPP_ASSERT(__state_ != __singular, 1140 "attempting to decrement a singular iterator"); 1141 _LIBCPP_ASSERT(__entry_.data() != __path_ptr_->native().data(), 1142 "attempting to decrement the begin iterator"); 1143 return __decrement(); 1144 } 1145 1146 _LIBCPP_INLINE_VISIBILITY 1147 iterator operator--(int) { 1148 iterator __it(*this); 1149 this->operator--(); 1150 return __it; 1151 } 1152 1153 private: 1154 friend class path; 1155 1156 static constexpr unsigned char __singular = 0; 1157 static constexpr unsigned char __at_end = 6; 1158 1159 inline _LIBCPP_INLINE_VISIBILITY 1160 friend bool operator==(const iterator&, const iterator&); 1161 1162 iterator& __increment(); 1163 iterator& __decrement(); 1164 1165 path __stashed_elem_; 1166 const path* __path_ptr_; 1167 path::__string_view __entry_; 1168 unsigned char __state_; 1169 }; 1170 1171 inline _LIBCPP_INLINE_VISIBILITY 1172 bool operator==(const path::iterator& __lhs, const path::iterator& __rhs) { 1173 return __lhs.__path_ptr_ == __rhs.__path_ptr_ && 1174 __lhs.__entry_.data() == __rhs.__entry_.data(); 1175 } 1176 1177 inline _LIBCPP_INLINE_VISIBILITY 1178 bool operator!=(const path::iterator& __lhs, const path::iterator& __rhs) { 1179 return !(__lhs == __rhs); 1180 } 1181 1182 class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error 1183 { 1184 public: 1185 _LIBCPP_INLINE_VISIBILITY 1186 filesystem_error(const string& __what, error_code __ec) 1187 : system_error(__ec, __what), 1188 __paths_(make_shared<_Storage>(path(), path())) 1189 {} 1190 1191 _LIBCPP_INLINE_VISIBILITY 1192 filesystem_error(const string& __what, const path& __p1, error_code __ec) 1193 : system_error(__ec, __what), 1194 __paths_(make_shared<_Storage>(__p1, path())) 1195 {} 1196 1197 _LIBCPP_INLINE_VISIBILITY 1198 filesystem_error(const string& __what, const path& __p1, const path& __p2, 1199 error_code __ec) 1200 : system_error(__ec, __what), 1201 __paths_(make_shared<_Storage>(__p1, __p2)) 1202 {} 1203 1204 _LIBCPP_INLINE_VISIBILITY 1205 const path& path1() const _NOEXCEPT { 1206 return __paths_->first; 1207 } 1208 1209 _LIBCPP_INLINE_VISIBILITY 1210 const path& path2() const _NOEXCEPT { 1211 return __paths_->second; 1212 } 1213 1214 ~filesystem_error() override; // key function 1215 1216 // TODO(ericwf): Create a custom error message. 1217 //const char* what() const _NOEXCEPT; 1218 1219 private: 1220 typedef pair<path, path> _Storage; 1221 shared_ptr<_Storage> __paths_; 1222 }; 1223 1224 template <class... _Args> 1225 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE 1226 #ifndef _LIBCPP_NO_EXCEPTIONS 1227 void __throw_filesystem_error(_Args && ...__args) 1228 { 1229 throw filesystem_error(std::forward<_Args>(__args)...); 1230 } 1231 #else 1232 void __throw_filesystem_error(_Args&&...) 1233 { 1234 _VSTD::abort(); 1235 } 1236 #endif 1237 1238 1239 // operational functions 1240 1241 _LIBCPP_FUNC_VIS 1242 path __canonical(const path&, const path&, error_code *__ec=nullptr); 1243 _LIBCPP_FUNC_VIS 1244 void __copy(const path& __from, const path& __to, copy_options __opt, 1245 error_code *__ec=nullptr); 1246 _LIBCPP_FUNC_VIS 1247 bool __copy_file(const path& __from, const path& __to, copy_options __opt, 1248 error_code *__ec=nullptr); 1249 _LIBCPP_FUNC_VIS 1250 void __copy_symlink(const path& __existing_symlink, const path& __new_symlink, 1251 error_code *__ec=nullptr); 1252 _LIBCPP_FUNC_VIS 1253 bool __create_directories(const path& p, error_code *ec=nullptr); 1254 _LIBCPP_FUNC_VIS 1255 bool __create_directory(const path& p, error_code *ec=nullptr); 1256 _LIBCPP_FUNC_VIS 1257 bool __create_directory(const path& p, const path & attributes, 1258 error_code *ec=nullptr); 1259 _LIBCPP_FUNC_VIS 1260 void __create_directory_symlink(const path& __to, const path& __new_symlink, 1261 error_code *__ec=nullptr); 1262 _LIBCPP_FUNC_VIS 1263 void __create_hard_link(const path& __to, const path& __new_hard_link, 1264 error_code *__ec=nullptr); 1265 _LIBCPP_FUNC_VIS 1266 void __create_symlink(const path& __to, const path& __new_symlink, 1267 error_code *__ec=nullptr); 1268 _LIBCPP_FUNC_VIS 1269 path __current_path(error_code *__ec=nullptr); 1270 _LIBCPP_FUNC_VIS 1271 void __current_path(const path&, error_code *__ec=nullptr); 1272 _LIBCPP_FUNC_VIS 1273 bool __equivalent(const path&, const path&, error_code *__ec=nullptr); 1274 _LIBCPP_FUNC_VIS 1275 uintmax_t __file_size(const path&, error_code *__ec=nullptr); 1276 _LIBCPP_FUNC_VIS 1277 uintmax_t __hard_link_count(const path&, error_code *__ec=nullptr); 1278 _LIBCPP_FUNC_VIS 1279 bool __fs_is_empty(const path& p, error_code *ec=nullptr); 1280 _LIBCPP_FUNC_VIS 1281 file_time_type __last_write_time(const path& p, error_code *ec=nullptr); 1282 _LIBCPP_FUNC_VIS 1283 void __last_write_time(const path& p, file_time_type new_time, 1284 error_code *ec=nullptr); 1285 _LIBCPP_FUNC_VIS 1286 void __permissions(const path& p, perms prms, error_code *ec=nullptr); 1287 _LIBCPP_FUNC_VIS 1288 path __read_symlink(const path& p, error_code *ec=nullptr); 1289 _LIBCPP_FUNC_VIS 1290 bool __remove(const path& p, error_code *ec=nullptr); 1291 _LIBCPP_FUNC_VIS 1292 uintmax_t __remove_all(const path& p, error_code *ec=nullptr); 1293 _LIBCPP_FUNC_VIS 1294 void __rename(const path& from, const path& to, error_code *ec=nullptr); 1295 _LIBCPP_FUNC_VIS 1296 void __resize_file(const path& p, uintmax_t size, error_code *ec=nullptr); 1297 _LIBCPP_FUNC_VIS 1298 space_info __space(const path&, error_code *__ec=nullptr); 1299 _LIBCPP_FUNC_VIS 1300 file_status __status(const path&, error_code *__ec=nullptr); 1301 _LIBCPP_FUNC_VIS 1302 file_status __symlink_status(const path&, error_code *__ec=nullptr); 1303 _LIBCPP_FUNC_VIS 1304 path __system_complete(const path&, error_code *__ec=nullptr); 1305 _LIBCPP_FUNC_VIS 1306 path __temp_directory_path(error_code *__ec=nullptr); 1307 1308 inline _LIBCPP_INLINE_VISIBILITY 1309 path current_path() { 1310 return __current_path(); 1311 } 1312 1313 inline _LIBCPP_INLINE_VISIBILITY 1314 path current_path(error_code& __ec) { 1315 return __current_path(&__ec); 1316 } 1317 1318 inline _LIBCPP_INLINE_VISIBILITY 1319 void current_path(const path& __p) { 1320 __current_path(__p); 1321 } 1322 1323 inline _LIBCPP_INLINE_VISIBILITY 1324 void current_path(const path& __p, error_code& __ec) _NOEXCEPT { 1325 __current_path(__p, &__ec); 1326 } 1327 1328 _LIBCPP_FUNC_VIS 1329 path absolute(const path&, const path& __p2 = current_path()); 1330 1331 inline _LIBCPP_INLINE_VISIBILITY 1332 path canonical(const path& __p, const path& __base = current_path()) { 1333 return __canonical(__p, __base); 1334 } 1335 1336 inline _LIBCPP_INLINE_VISIBILITY 1337 path canonical(const path& __p, error_code& __ec) { 1338 path __base = __current_path(&__ec); 1339 if (__ec) return {}; 1340 return __canonical(__p, __base, &__ec); 1341 } 1342 1343 inline _LIBCPP_INLINE_VISIBILITY 1344 path canonical(const path& __p, const path& __base, error_code& __ec) { 1345 return __canonical(__p, __base, &__ec); 1346 } 1347 1348 inline _LIBCPP_INLINE_VISIBILITY 1349 void copy(const path& __from, const path& __to) { 1350 __copy(__from, __to, copy_options::none); 1351 } 1352 1353 inline _LIBCPP_INLINE_VISIBILITY 1354 void copy(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT { 1355 __copy(__from, __to, copy_options::none, &__ec); 1356 } 1357 1358 inline _LIBCPP_INLINE_VISIBILITY 1359 void copy(const path& __from, const path& __to, copy_options __opt) { 1360 __copy(__from, __to, __opt); 1361 } 1362 1363 inline _LIBCPP_INLINE_VISIBILITY 1364 void copy(const path& __from, const path& __to, 1365 copy_options __opt, error_code& __ec) _NOEXCEPT { 1366 __copy(__from, __to, __opt, &__ec); 1367 } 1368 1369 inline _LIBCPP_INLINE_VISIBILITY 1370 bool copy_file(const path& __from, const path& __to) { 1371 return __copy_file(__from, __to, copy_options::none); 1372 } 1373 1374 inline _LIBCPP_INLINE_VISIBILITY 1375 bool copy_file(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT { 1376 return __copy_file(__from, __to, copy_options::none, &__ec); 1377 } 1378 1379 inline _LIBCPP_INLINE_VISIBILITY 1380 bool copy_file(const path& __from, const path& __to, copy_options __opt) { 1381 return __copy_file(__from, __to, __opt); 1382 } 1383 1384 inline _LIBCPP_INLINE_VISIBILITY 1385 bool copy_file(const path& __from, const path& __to, 1386 copy_options __opt, error_code& __ec) _NOEXCEPT { 1387 return __copy_file(__from, __to, __opt, &__ec); 1388 } 1389 1390 inline _LIBCPP_INLINE_VISIBILITY 1391 void copy_symlink(const path& __existing, const path& __new) { 1392 __copy_symlink(__existing, __new); 1393 } 1394 1395 inline _LIBCPP_INLINE_VISIBILITY 1396 void copy_symlink(const path& __ext, const path& __new, error_code& __ec) _NOEXCEPT { 1397 __copy_symlink(__ext, __new, &__ec); 1398 } 1399 1400 inline _LIBCPP_INLINE_VISIBILITY 1401 bool create_directories(const path& __p) { 1402 return __create_directories(__p); 1403 } 1404 1405 inline _LIBCPP_INLINE_VISIBILITY 1406 bool create_directories(const path& __p, error_code& __ec) _NOEXCEPT { 1407 return __create_directories(__p, &__ec); 1408 } 1409 1410 inline _LIBCPP_INLINE_VISIBILITY 1411 bool create_directory(const path& __p) { 1412 return __create_directory(__p); 1413 } 1414 1415 inline _LIBCPP_INLINE_VISIBILITY 1416 bool create_directory(const path& __p, error_code& __ec) _NOEXCEPT { 1417 return __create_directory(__p, &__ec); 1418 } 1419 1420 inline _LIBCPP_INLINE_VISIBILITY 1421 bool create_directory(const path& __p, const path& __attrs) { 1422 return __create_directory(__p, __attrs); 1423 } 1424 1425 inline _LIBCPP_INLINE_VISIBILITY 1426 bool create_directory(const path& __p, const path& __attrs, error_code& __ec) _NOEXCEPT { 1427 return __create_directory(__p, __attrs, &__ec); 1428 } 1429 1430 inline _LIBCPP_INLINE_VISIBILITY 1431 void create_directory_symlink(const path& __to, const path& __new) { 1432 __create_directory_symlink(__to, __new); 1433 } 1434 1435 inline _LIBCPP_INLINE_VISIBILITY 1436 void create_directory_symlink(const path& __to, const path& __new, 1437 error_code& __ec) _NOEXCEPT { 1438 __create_directory_symlink(__to, __new, &__ec); 1439 } 1440 1441 inline _LIBCPP_INLINE_VISIBILITY 1442 void create_hard_link(const path& __to, const path& __new) { 1443 __create_hard_link(__to, __new); 1444 } 1445 1446 inline _LIBCPP_INLINE_VISIBILITY 1447 void create_hard_link(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT { 1448 __create_hard_link(__to, __new, &__ec); 1449 } 1450 1451 inline _LIBCPP_INLINE_VISIBILITY 1452 void create_symlink(const path& __to, const path& __new) { 1453 __create_symlink(__to, __new); 1454 } 1455 1456 inline _LIBCPP_INLINE_VISIBILITY 1457 void create_symlink(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT { 1458 return __create_symlink(__to, __new, &__ec); 1459 } 1460 1461 inline _LIBCPP_INLINE_VISIBILITY 1462 bool status_known(file_status __s) _NOEXCEPT { 1463 return __s.type() != file_type::none; 1464 } 1465 1466 inline _LIBCPP_INLINE_VISIBILITY 1467 bool exists(file_status __s) _NOEXCEPT { 1468 return status_known(__s) && __s.type() != file_type::not_found; 1469 } 1470 1471 inline _LIBCPP_INLINE_VISIBILITY 1472 bool exists(const path& __p) { 1473 return exists(__status(__p)); 1474 } 1475 1476 inline _LIBCPP_INLINE_VISIBILITY 1477 bool exists(const path& __p, error_code& __ec) _NOEXCEPT { 1478 auto __s = __status(__p, &__ec); 1479 if (status_known(__s)) __ec.clear(); 1480 return exists(__s); 1481 } 1482 1483 inline _LIBCPP_INLINE_VISIBILITY 1484 bool equivalent(const path& __p1, const path& __p2) { 1485 return __equivalent(__p1, __p2); 1486 } 1487 1488 inline _LIBCPP_INLINE_VISIBILITY 1489 bool equivalent(const path& __p1, const path& __p2, error_code& __ec) _NOEXCEPT { 1490 return __equivalent(__p1, __p2, &__ec); 1491 } 1492 1493 inline _LIBCPP_INLINE_VISIBILITY 1494 uintmax_t file_size(const path& __p) { 1495 return __file_size(__p); 1496 } 1497 1498 inline _LIBCPP_INLINE_VISIBILITY 1499 uintmax_t file_size(const path& __p, error_code& __ec) _NOEXCEPT { 1500 return __file_size(__p, &__ec); 1501 } 1502 1503 inline _LIBCPP_INLINE_VISIBILITY 1504 uintmax_t hard_link_count(const path& __p) { 1505 return __hard_link_count(__p); 1506 } 1507 1508 inline _LIBCPP_INLINE_VISIBILITY 1509 uintmax_t hard_link_count(const path& __p, error_code& __ec) _NOEXCEPT { 1510 return __hard_link_count(__p, &__ec); 1511 } 1512 1513 inline _LIBCPP_INLINE_VISIBILITY 1514 bool is_block_file(file_status __s) _NOEXCEPT { 1515 return __s.type() == file_type::block; 1516 } 1517 1518 inline _LIBCPP_INLINE_VISIBILITY 1519 bool is_block_file(const path& __p) { 1520 return is_block_file(__status(__p)); 1521 } 1522 1523 inline _LIBCPP_INLINE_VISIBILITY 1524 bool is_block_file(const path& __p, error_code& __ec) _NOEXCEPT { 1525 return is_block_file(__status(__p, &__ec)); 1526 } 1527 1528 inline _LIBCPP_INLINE_VISIBILITY 1529 bool is_character_file(file_status __s) _NOEXCEPT { 1530 return __s.type() == file_type::character; 1531 } 1532 1533 inline _LIBCPP_INLINE_VISIBILITY 1534 bool is_character_file(const path& __p) { 1535 return is_character_file(__status(__p)); 1536 } 1537 1538 inline _LIBCPP_INLINE_VISIBILITY 1539 bool is_character_file(const path& __p, error_code& __ec) _NOEXCEPT { 1540 return is_character_file(__status(__p, &__ec)); 1541 } 1542 1543 inline _LIBCPP_INLINE_VISIBILITY 1544 bool is_directory(file_status __s) _NOEXCEPT { 1545 return __s.type() == file_type::directory; 1546 } 1547 1548 inline _LIBCPP_INLINE_VISIBILITY 1549 bool is_directory(const path& __p) { 1550 return is_directory(__status(__p)); 1551 } 1552 1553 inline _LIBCPP_INLINE_VISIBILITY 1554 bool is_directory(const path& __p, error_code& __ec) _NOEXCEPT { 1555 return is_directory(__status(__p, &__ec)); 1556 } 1557 1558 inline _LIBCPP_INLINE_VISIBILITY 1559 bool is_empty(const path& __p) { 1560 return __fs_is_empty(__p); 1561 } 1562 1563 inline _LIBCPP_INLINE_VISIBILITY 1564 bool is_empty(const path& __p, error_code& __ec) _NOEXCEPT { 1565 return __fs_is_empty(__p, &__ec); 1566 } 1567 1568 inline _LIBCPP_INLINE_VISIBILITY 1569 bool is_fifo(file_status __s) _NOEXCEPT { 1570 return __s.type() == file_type::fifo; 1571 } 1572 inline _LIBCPP_INLINE_VISIBILITY 1573 bool is_fifo(const path& __p) { 1574 return is_fifo(__status(__p)); 1575 } 1576 1577 inline _LIBCPP_INLINE_VISIBILITY 1578 bool is_fifo(const path& __p, error_code& __ec) _NOEXCEPT { 1579 return is_fifo(__status(__p, &__ec)); 1580 } 1581 1582 inline _LIBCPP_INLINE_VISIBILITY 1583 bool is_regular_file(file_status __s) _NOEXCEPT { 1584 return __s.type() == file_type::regular; 1585 } 1586 1587 inline _LIBCPP_INLINE_VISIBILITY 1588 bool is_regular_file(const path& __p) { 1589 return is_regular_file(__status(__p)); 1590 } 1591 1592 inline _LIBCPP_INLINE_VISIBILITY 1593 bool is_regular_file(const path& __p, error_code& __ec) _NOEXCEPT { 1594 return is_regular_file(__status(__p, &__ec)); 1595 } 1596 1597 inline _LIBCPP_INLINE_VISIBILITY 1598 bool is_socket(file_status __s) _NOEXCEPT { 1599 return __s.type() == file_type::socket; 1600 } 1601 1602 inline _LIBCPP_INLINE_VISIBILITY 1603 bool is_socket(const path& __p) { 1604 return is_socket(__status(__p)); 1605 } 1606 1607 inline _LIBCPP_INLINE_VISIBILITY 1608 bool is_socket(const path& __p, error_code& __ec) _NOEXCEPT { 1609 return is_socket(__status(__p, &__ec)); 1610 } 1611 1612 inline _LIBCPP_INLINE_VISIBILITY 1613 bool is_symlink(file_status __s) _NOEXCEPT { 1614 return __s.type() == file_type::symlink; 1615 } 1616 1617 inline _LIBCPP_INLINE_VISIBILITY 1618 bool is_symlink(const path& __p) { 1619 return is_symlink(__symlink_status(__p)); 1620 } 1621 1622 inline _LIBCPP_INLINE_VISIBILITY 1623 bool is_symlink(const path& __p, error_code& __ec) _NOEXCEPT { 1624 return is_symlink(__symlink_status(__p, &__ec)); 1625 } 1626 1627 inline _LIBCPP_INLINE_VISIBILITY 1628 bool is_other(file_status __s) _NOEXCEPT { 1629 return exists(__s) 1630 && !is_regular_file(__s) && !is_directory(__s) && !is_symlink(__s); 1631 } 1632 1633 inline _LIBCPP_INLINE_VISIBILITY 1634 bool is_other(const path& __p) { 1635 return is_other(__status(__p)); 1636 } 1637 1638 inline _LIBCPP_INLINE_VISIBILITY 1639 bool is_other(const path& __p, error_code& __ec) _NOEXCEPT { 1640 return is_other(__status(__p, &__ec)); 1641 } 1642 1643 inline _LIBCPP_INLINE_VISIBILITY 1644 file_time_type last_write_time(const path& __p) { 1645 return __last_write_time(__p); 1646 } 1647 1648 inline _LIBCPP_INLINE_VISIBILITY 1649 file_time_type last_write_time(const path& __p, error_code& __ec) _NOEXCEPT { 1650 return __last_write_time(__p, &__ec); 1651 } 1652 1653 inline _LIBCPP_INLINE_VISIBILITY 1654 void last_write_time(const path& __p, file_time_type __t) { 1655 __last_write_time(__p, __t); 1656 } 1657 1658 inline _LIBCPP_INLINE_VISIBILITY 1659 void last_write_time(const path& __p, file_time_type __t, error_code& __ec) _NOEXCEPT { 1660 __last_write_time(__p, __t, &__ec); 1661 } 1662 1663 inline _LIBCPP_INLINE_VISIBILITY 1664 void permissions(const path& __p, perms __prms) { 1665 __permissions(__p, __prms); 1666 } 1667 1668 inline _LIBCPP_INLINE_VISIBILITY 1669 void permissions(const path& __p, perms __prms, error_code& __ec) { 1670 __permissions(__p, __prms, &__ec); 1671 } 1672 1673 inline _LIBCPP_INLINE_VISIBILITY 1674 path read_symlink(const path& __p) { 1675 return __read_symlink(__p); 1676 } 1677 1678 inline _LIBCPP_INLINE_VISIBILITY 1679 path read_symlink(const path& __p, error_code& __ec) { 1680 return __read_symlink(__p, &__ec); 1681 } 1682 1683 inline _LIBCPP_INLINE_VISIBILITY 1684 bool remove(const path& __p) { 1685 return __remove(__p); 1686 } 1687 1688 inline _LIBCPP_INLINE_VISIBILITY 1689 bool remove(const path& __p, error_code& __ec) _NOEXCEPT { 1690 return __remove(__p, &__ec); 1691 } 1692 1693 inline _LIBCPP_INLINE_VISIBILITY 1694 uintmax_t remove_all(const path& __p) { 1695 return __remove_all(__p); 1696 } 1697 1698 inline _LIBCPP_INLINE_VISIBILITY 1699 uintmax_t remove_all(const path& __p, error_code& __ec) _NOEXCEPT { 1700 return __remove_all(__p, &__ec); 1701 } 1702 1703 inline _LIBCPP_INLINE_VISIBILITY 1704 void rename(const path& __from, const path& __to) { 1705 return __rename(__from, __to); 1706 } 1707 1708 inline _LIBCPP_INLINE_VISIBILITY 1709 void rename(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT { 1710 return __rename(__from, __to, &__ec); 1711 } 1712 1713 inline _LIBCPP_INLINE_VISIBILITY 1714 void resize_file(const path& __p, uintmax_t __ns) { 1715 return __resize_file(__p, __ns); 1716 } 1717 1718 inline _LIBCPP_INLINE_VISIBILITY 1719 void resize_file(const path& __p, uintmax_t __ns, error_code& __ec) _NOEXCEPT { 1720 return __resize_file(__p, __ns, &__ec); 1721 } 1722 1723 inline _LIBCPP_INLINE_VISIBILITY 1724 space_info space(const path& __p) { 1725 return __space(__p); 1726 } 1727 1728 inline _LIBCPP_INLINE_VISIBILITY 1729 space_info space(const path& __p, error_code& __ec) _NOEXCEPT { 1730 return __space(__p, &__ec); 1731 } 1732 1733 inline _LIBCPP_INLINE_VISIBILITY 1734 file_status status(const path& __p) { 1735 return __status(__p); 1736 } 1737 1738 inline _LIBCPP_INLINE_VISIBILITY 1739 file_status status(const path& __p, error_code& __ec) _NOEXCEPT { 1740 return __status(__p, &__ec); 1741 } 1742 1743 inline _LIBCPP_INLINE_VISIBILITY 1744 file_status symlink_status(const path& __p) { 1745 return __symlink_status(__p); 1746 } 1747 1748 inline _LIBCPP_INLINE_VISIBILITY 1749 file_status symlink_status(const path& __p, error_code& __ec) _NOEXCEPT { 1750 return __symlink_status(__p, &__ec); 1751 } 1752 1753 inline _LIBCPP_INLINE_VISIBILITY 1754 path system_complete(const path& __p) { 1755 return __system_complete(__p); 1756 } 1757 1758 inline _LIBCPP_INLINE_VISIBILITY 1759 path system_complete(const path& __p, error_code& __ec) { 1760 return __system_complete(__p, &__ec); 1761 } 1762 1763 inline _LIBCPP_INLINE_VISIBILITY 1764 path temp_directory_path() { 1765 return __temp_directory_path(); 1766 } 1767 1768 inline _LIBCPP_INLINE_VISIBILITY 1769 path temp_directory_path(error_code& __ec) { 1770 return __temp_directory_path(&__ec); 1771 } 1772 1773 1774 class directory_entry 1775 { 1776 typedef _VSTD_FS::path _Path; 1777 1778 public: 1779 // constructors and destructors 1780 directory_entry() _NOEXCEPT = default; 1781 directory_entry(directory_entry const&) = default; 1782 directory_entry(directory_entry&&) _NOEXCEPT = default; 1783 1784 _LIBCPP_INLINE_VISIBILITY 1785 explicit directory_entry(_Path const& __p) : __p_(__p) {} 1786 1787 ~directory_entry() {} 1788 1789 directory_entry& operator=(directory_entry const&) = default; 1790 directory_entry& operator=(directory_entry&&) _NOEXCEPT = default; 1791 1792 _LIBCPP_INLINE_VISIBILITY 1793 void assign(_Path const& __p) { 1794 __p_ = __p; 1795 } 1796 1797 _LIBCPP_INLINE_VISIBILITY 1798 void replace_filename(_Path const& __p) { 1799 __p_ = __p_.parent_path() / __p; 1800 } 1801 1802 _LIBCPP_INLINE_VISIBILITY 1803 _Path const& path() const _NOEXCEPT { 1804 return __p_; 1805 } 1806 1807 _LIBCPP_INLINE_VISIBILITY 1808 operator const _Path&() const _NOEXCEPT { 1809 return __p_; 1810 } 1811 1812 _LIBCPP_INLINE_VISIBILITY 1813 file_status status() const { 1814 return _VSTD_FS::status(__p_); 1815 } 1816 1817 _LIBCPP_INLINE_VISIBILITY 1818 file_status status(error_code& __ec) const _NOEXCEPT { 1819 return _VSTD_FS::status(__p_, __ec); 1820 } 1821 1822 _LIBCPP_INLINE_VISIBILITY 1823 file_status symlink_status() const { 1824 return _VSTD_FS::symlink_status(__p_); 1825 } 1826 1827 _LIBCPP_INLINE_VISIBILITY 1828 file_status symlink_status(error_code& __ec) const _NOEXCEPT { 1829 return _VSTD_FS::symlink_status(__p_, __ec); 1830 } 1831 1832 _LIBCPP_INLINE_VISIBILITY 1833 bool operator< (directory_entry const& __rhs) const _NOEXCEPT { 1834 return __p_ < __rhs.__p_; 1835 } 1836 1837 _LIBCPP_INLINE_VISIBILITY 1838 bool operator==(directory_entry const& __rhs) const _NOEXCEPT { 1839 return __p_ == __rhs.__p_; 1840 } 1841 1842 _LIBCPP_INLINE_VISIBILITY 1843 bool operator!=(directory_entry const& __rhs) const _NOEXCEPT { 1844 return __p_ != __rhs.__p_; 1845 } 1846 1847 _LIBCPP_INLINE_VISIBILITY 1848 bool operator<=(directory_entry const& __rhs) const _NOEXCEPT { 1849 return __p_ <= __rhs.__p_; 1850 } 1851 1852 _LIBCPP_INLINE_VISIBILITY 1853 bool operator> (directory_entry const& __rhs) const _NOEXCEPT { 1854 return __p_ > __rhs.__p_; 1855 } 1856 1857 _LIBCPP_INLINE_VISIBILITY 1858 bool operator>=(directory_entry const& __rhs) const _NOEXCEPT { 1859 return __p_ >= __rhs.__p_; 1860 } 1861 private: 1862 _Path __p_; 1863 }; 1864 1865 1866 class directory_iterator; 1867 class recursive_directory_iterator; 1868 class __dir_stream; 1869 1870 class __dir_element_proxy { 1871 public: 1872 1873 inline _LIBCPP_INLINE_VISIBILITY 1874 directory_entry operator*() { return _VSTD::move(__elem_); } 1875 1876 private: 1877 friend class directory_iterator; 1878 friend class recursive_directory_iterator; 1879 explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {} 1880 __dir_element_proxy(__dir_element_proxy&& __o) : __elem_(_VSTD::move(__o.__elem_)) {} 1881 directory_entry __elem_; 1882 }; 1883 1884 class directory_iterator 1885 { 1886 public: 1887 typedef directory_entry value_type; 1888 typedef ptrdiff_t difference_type; 1889 typedef value_type const* pointer; 1890 typedef value_type const& reference; 1891 typedef input_iterator_tag iterator_category; 1892 1893 public: 1894 //ctor & dtor 1895 directory_iterator() _NOEXCEPT 1896 { } 1897 1898 explicit directory_iterator(const path& __p) 1899 : directory_iterator(__p, nullptr) 1900 { } 1901 1902 directory_iterator(const path& __p, directory_options __opts) 1903 : directory_iterator(__p, nullptr, __opts) 1904 { } 1905 1906 directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT 1907 : directory_iterator(__p, &__ec) 1908 { } 1909 1910 directory_iterator(const path& __p, directory_options __opts, 1911 error_code& __ec) _NOEXCEPT 1912 : directory_iterator(__p, &__ec, __opts) 1913 { } 1914 1915 directory_iterator(const directory_iterator&) = default; 1916 directory_iterator(directory_iterator&&) = default; 1917 directory_iterator& operator=(const directory_iterator&) = default; 1918 1919 directory_iterator& operator=(directory_iterator&& __o) _NOEXCEPT { 1920 // non-default implementation provided to support self-move assign. 1921 if (this != &__o) { 1922 __imp_ = _VSTD::move(__o.__imp_); 1923 } 1924 return *this; 1925 } 1926 1927 ~directory_iterator() = default; 1928 1929 const directory_entry& operator*() const { 1930 _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced"); 1931 return __dereference(); 1932 } 1933 1934 const directory_entry* operator->() const 1935 { return &**this; } 1936 1937 directory_iterator& operator++() 1938 { return __increment(); } 1939 1940 __dir_element_proxy operator++(int) { 1941 __dir_element_proxy __p(**this); 1942 __increment(); 1943 return __p; 1944 } 1945 1946 directory_iterator& increment(error_code& __ec) _NOEXCEPT 1947 { return __increment(&__ec); } 1948 1949 private: 1950 inline _LIBCPP_INLINE_VISIBILITY 1951 friend bool operator==(const directory_iterator& __lhs, 1952 const directory_iterator& __rhs) _NOEXCEPT; 1953 1954 // construct the dir_stream 1955 _LIBCPP_FUNC_VIS 1956 directory_iterator(const path&, error_code *, 1957 directory_options = directory_options::none); 1958 1959 _LIBCPP_FUNC_VIS 1960 directory_iterator& __increment(error_code * __ec = nullptr); 1961 1962 _LIBCPP_FUNC_VIS 1963 const directory_entry& __dereference() const; 1964 1965 private: 1966 shared_ptr<__dir_stream> __imp_; 1967 }; 1968 1969 1970 inline _LIBCPP_INLINE_VISIBILITY 1971 bool operator==(const directory_iterator& __lhs, 1972 const directory_iterator& __rhs) _NOEXCEPT { 1973 return __lhs.__imp_ == __rhs.__imp_; 1974 } 1975 1976 inline _LIBCPP_INLINE_VISIBILITY 1977 bool operator!=(const directory_iterator& __lhs, 1978 const directory_iterator& __rhs) _NOEXCEPT { 1979 return !(__lhs == __rhs); 1980 } 1981 1982 // enable directory_iterator range-based for statements 1983 inline _LIBCPP_INLINE_VISIBILITY 1984 directory_iterator begin(directory_iterator __iter) _NOEXCEPT { 1985 return __iter; 1986 } 1987 1988 inline _LIBCPP_INLINE_VISIBILITY 1989 directory_iterator end(const directory_iterator&) _NOEXCEPT { 1990 return directory_iterator(); 1991 } 1992 1993 class recursive_directory_iterator { 1994 public: 1995 using value_type = directory_entry; 1996 using difference_type = std::ptrdiff_t; 1997 using pointer = directory_entry const *; 1998 using reference = directory_entry const &; 1999 using iterator_category = std::input_iterator_tag; 2000 2001 public: 2002 // constructors and destructor 2003 _LIBCPP_INLINE_VISIBILITY 2004 recursive_directory_iterator() _NOEXCEPT 2005 : __rec_(false) 2006 {} 2007 2008 _LIBCPP_INLINE_VISIBILITY 2009 explicit recursive_directory_iterator(const path& __p, 2010 directory_options __xoptions = directory_options::none) 2011 : recursive_directory_iterator(__p, __xoptions, nullptr) 2012 { } 2013 2014 _LIBCPP_INLINE_VISIBILITY 2015 recursive_directory_iterator(const path& __p, 2016 directory_options __xoptions, error_code& __ec) _NOEXCEPT 2017 : recursive_directory_iterator(__p, __xoptions, &__ec) 2018 { } 2019 2020 _LIBCPP_INLINE_VISIBILITY 2021 recursive_directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT 2022 : recursive_directory_iterator(__p, directory_options::none, &__ec) 2023 { } 2024 2025 recursive_directory_iterator(const recursive_directory_iterator&) = default; 2026 recursive_directory_iterator(recursive_directory_iterator&&) = default; 2027 2028 recursive_directory_iterator & 2029 operator=(const recursive_directory_iterator&) = default; 2030 2031 _LIBCPP_INLINE_VISIBILITY 2032 recursive_directory_iterator & 2033 operator=(recursive_directory_iterator&& __o) noexcept { 2034 // non-default implementation provided to support self-move assign. 2035 if (this != &__o) { 2036 __imp_ = _VSTD::move(__o.__imp_); 2037 __rec_ = __o.__rec_; 2038 } 2039 return *this; 2040 } 2041 2042 ~recursive_directory_iterator() = default; 2043 2044 _LIBCPP_INLINE_VISIBILITY 2045 const directory_entry& operator*() const 2046 { return __dereference(); } 2047 2048 _LIBCPP_INLINE_VISIBILITY 2049 const directory_entry* operator->() const 2050 { return &__dereference(); } 2051 2052 recursive_directory_iterator& operator++() 2053 { return __increment(); } 2054 2055 _LIBCPP_INLINE_VISIBILITY 2056 __dir_element_proxy operator++(int) { 2057 __dir_element_proxy __p(**this); 2058 __increment(); 2059 return __p; 2060 } 2061 2062 _LIBCPP_INLINE_VISIBILITY 2063 recursive_directory_iterator& increment(error_code& __ec) _NOEXCEPT 2064 { return __increment(&__ec); } 2065 2066 _LIBCPP_FUNC_VIS directory_options options() const; 2067 _LIBCPP_FUNC_VIS int depth() const; 2068 2069 _LIBCPP_INLINE_VISIBILITY 2070 void pop() { __pop(); } 2071 2072 _LIBCPP_INLINE_VISIBILITY 2073 void pop(error_code& __ec) 2074 { __pop(&__ec); } 2075 2076 _LIBCPP_INLINE_VISIBILITY 2077 bool recursion_pending() const 2078 { return __rec_; } 2079 2080 _LIBCPP_INLINE_VISIBILITY 2081 void disable_recursion_pending() 2082 { __rec_ = false; } 2083 2084 private: 2085 recursive_directory_iterator(const path& __p, directory_options __opt, 2086 error_code *__ec); 2087 2088 _LIBCPP_FUNC_VIS 2089 const directory_entry& __dereference() const; 2090 2091 _LIBCPP_FUNC_VIS 2092 bool __try_recursion(error_code* __ec); 2093 2094 _LIBCPP_FUNC_VIS 2095 void __advance(error_code* __ec=nullptr); 2096 2097 _LIBCPP_FUNC_VIS 2098 recursive_directory_iterator& __increment(error_code *__ec=nullptr); 2099 2100 _LIBCPP_FUNC_VIS 2101 void __pop(error_code* __ec=nullptr); 2102 2103 inline _LIBCPP_INLINE_VISIBILITY 2104 friend bool operator==(const recursive_directory_iterator&, 2105 const recursive_directory_iterator&) _NOEXCEPT; 2106 2107 struct __shared_imp; 2108 shared_ptr<__shared_imp> __imp_; 2109 bool __rec_; 2110 }; // class recursive_directory_iterator 2111 2112 2113 inline _LIBCPP_INLINE_VISIBILITY 2114 bool operator==(const recursive_directory_iterator& __lhs, 2115 const recursive_directory_iterator& __rhs) _NOEXCEPT 2116 { 2117 return __lhs.__imp_ == __rhs.__imp_; 2118 } 2119 2120 _LIBCPP_INLINE_VISIBILITY 2121 inline bool operator!=(const recursive_directory_iterator& __lhs, 2122 const recursive_directory_iterator& __rhs) _NOEXCEPT 2123 { 2124 return !(__lhs == __rhs); 2125 } 2126 // enable recursive_directory_iterator range-based for statements 2127 inline _LIBCPP_INLINE_VISIBILITY 2128 recursive_directory_iterator begin(recursive_directory_iterator __iter) _NOEXCEPT { 2129 return __iter; 2130 } 2131 2132 inline _LIBCPP_INLINE_VISIBILITY 2133 recursive_directory_iterator end(const recursive_directory_iterator&) _NOEXCEPT { 2134 return recursive_directory_iterator(); 2135 } 2136 2137 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM 2138 2139 #endif // _LIBCPP_EXPERIMENTAL_FILESYSTEM 2140
