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_FILESYSTEM 11 #define _LIBCPP_FILESYSTEM 12 /* 13 filesystem synopsis 14 15 namespace std { namespace filesystem { 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 // fs.path.io operators are friends of path. 32 template <class charT, class traits> 33 friend basic_ostream<charT, traits>& 34 operator<<(basic_ostream<charT, traits>& os, const path& p); 35 36 template <class charT, class traits> 37 friend basic_istream<charT, traits>& 38 operator>>(basic_istream<charT, traits>& is, path& p); 39 40 template <class Source> 41 path u8path(const Source& source); 42 template <class InputIterator> 43 path u8path(InputIterator first, InputIterator last); 44 45 class filesystem_error; 46 class directory_entry; 47 48 class directory_iterator; 49 50 // enable directory_iterator range-based for statements 51 directory_iterator begin(directory_iterator iter) noexcept; 52 directory_iterator end(const directory_iterator&) noexcept; 53 54 class recursive_directory_iterator; 55 56 // enable recursive_directory_iterator range-based for statements 57 recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept; 58 recursive_directory_iterator end(const recursive_directory_iterator&) noexcept; 59 60 class file_status; 61 62 struct space_info 63 { 64 uintmax_t capacity; 65 uintmax_t free; 66 uintmax_t available; 67 }; 68 69 enum class file_type; 70 enum class perms; 71 enum class perm_options; 72 enum class copy_options; 73 enum class directory_options; 74 75 typedef chrono::time_point<trivial-clock> file_time_type; 76 77 // operational functions 78 79 path absolute(const path& p); 80 path absolute(const path& p, error_code &ec); 81 82 path canonical(const path& p); 83 path canonical(const path& p, error_code& ec); 84 85 void copy(const path& from, const path& to); 86 void copy(const path& from, const path& to, error_code& ec); 87 void copy(const path& from, const path& to, copy_options options); 88 void copy(const path& from, const path& to, copy_options options, 89 error_code& ec); 90 91 bool copy_file(const path& from, const path& to); 92 bool copy_file(const path& from, const path& to, error_code& ec); 93 bool copy_file(const path& from, const path& to, copy_options option); 94 bool copy_file(const path& from, const path& to, copy_options option, 95 error_code& ec); 96 97 void copy_symlink(const path& existing_symlink, const path& new_symlink); 98 void copy_symlink(const path& existing_symlink, const path& new_symlink, 99 error_code& ec) noexcept; 100 101 bool create_directories(const path& p); 102 bool create_directories(const path& p, error_code& ec); 103 104 bool create_directory(const path& p); 105 bool create_directory(const path& p, error_code& ec) noexcept; 106 107 bool create_directory(const path& p, const path& attributes); 108 bool create_directory(const path& p, const path& attributes, 109 error_code& ec) noexcept; 110 111 void create_directory_symlink(const path& to, const path& new_symlink); 112 void create_directory_symlink(const path& to, const path& new_symlink, 113 error_code& ec) noexcept; 114 115 void create_hard_link(const path& to, const path& new_hard_link); 116 void create_hard_link(const path& to, const path& new_hard_link, 117 error_code& ec) noexcept; 118 119 void create_symlink(const path& to, const path& new_symlink); 120 void create_symlink(const path& to, const path& new_symlink, 121 error_code& ec) noexcept; 122 123 path current_path(); 124 path current_path(error_code& ec); 125 void current_path(const path& p); 126 void current_path(const path& p, error_code& ec) noexcept; 127 128 bool exists(file_status s) noexcept; 129 bool exists(const path& p); 130 bool exists(const path& p, error_code& ec) noexcept; 131 132 bool equivalent(const path& p1, const path& p2); 133 bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept; 134 135 uintmax_t file_size(const path& p); 136 uintmax_t file_size(const path& p, error_code& ec) noexcept; 137 138 uintmax_t hard_link_count(const path& p); 139 uintmax_t hard_link_count(const path& p, error_code& ec) noexcept; 140 141 bool is_block_file(file_status s) noexcept; 142 bool is_block_file(const path& p); 143 bool is_block_file(const path& p, error_code& ec) noexcept; 144 145 bool is_character_file(file_status s) noexcept; 146 bool is_character_file(const path& p); 147 bool is_character_file(const path& p, error_code& ec) noexcept; 148 149 bool is_directory(file_status s) noexcept; 150 bool is_directory(const path& p); 151 bool is_directory(const path& p, error_code& ec) noexcept; 152 153 bool is_empty(const path& p); 154 bool is_empty(const path& p, error_code& ec) noexcept; 155 156 bool is_fifo(file_status s) noexcept; 157 bool is_fifo(const path& p); 158 bool is_fifo(const path& p, error_code& ec) noexcept; 159 160 bool is_other(file_status s) noexcept; 161 bool is_other(const path& p); 162 bool is_other(const path& p, error_code& ec) noexcept; 163 164 bool is_regular_file(file_status s) noexcept; 165 bool is_regular_file(const path& p); 166 bool is_regular_file(const path& p, error_code& ec) noexcept; 167 168 bool is_socket(file_status s) noexcept; 169 bool is_socket(const path& p); 170 bool is_socket(const path& p, error_code& ec) noexcept; 171 172 bool is_symlink(file_status s) noexcept; 173 bool is_symlink(const path& p); 174 bool is_symlink(const path& p, error_code& ec) noexcept; 175 176 file_time_type last_write_time(const path& p); 177 file_time_type last_write_time(const path& p, error_code& ec) noexcept; 178 void last_write_time(const path& p, file_time_type new_time); 179 void last_write_time(const path& p, file_time_type new_time, 180 error_code& ec) noexcept; 181 182 void permissions(const path& p, perms prms, 183 perm_options opts=perm_options::replace); 184 void permissions(const path& p, perms prms, error_code& ec) noexcept; 185 void permissions(const path& p, perms prms, perm_options opts, 186 error_code& ec); 187 188 path proximate(const path& p, error_code& ec); 189 path proximate(const path& p, const path& base = current_path()); 190 path proximate(const path& p, const path& base, error_code &ec); 191 192 path read_symlink(const path& p); 193 path read_symlink(const path& p, error_code& ec); 194 195 path relative(const path& p, error_code& ec); 196 path relative(const path& p, const path& base=current_path()); 197 path relative(const path& p, const path& base, error_code& ec); 198 199 bool remove(const path& p); 200 bool remove(const path& p, error_code& ec) noexcept; 201 202 uintmax_t remove_all(const path& p); 203 uintmax_t remove_all(const path& p, error_code& ec); 204 205 void rename(const path& from, const path& to); 206 void rename(const path& from, const path& to, error_code& ec) noexcept; 207 208 void resize_file(const path& p, uintmax_t size); 209 void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept; 210 211 space_info space(const path& p); 212 space_info space(const path& p, error_code& ec) noexcept; 213 214 file_status status(const path& p); 215 file_status status(const path& p, error_code& ec) noexcept; 216 217 bool status_known(file_status s) noexcept; 218 219 file_status symlink_status(const path& p); 220 file_status symlink_status(const path& p, error_code& ec) noexcept; 221 222 path temp_directory_path(); 223 path temp_directory_path(error_code& ec); 224 225 path weakly_canonical(path const& p); 226 path weakly_canonical(path const& p, error_code& ec); 227 228 229 } } // namespaces std::filesystem 230 231 */ 232 233 #include <__config> 234 #include <cstddef> 235 #include <cstdlib> 236 #include <chrono> 237 #include <iterator> 238 #include <iosfwd> 239 #include <locale> 240 #include <memory> 241 #include <stack> 242 #include <string> 243 #include <system_error> 244 #include <utility> 245 #include <iomanip> // for quoted 246 #include <string_view> 247 #include <version> 248 249 #include <__debug> 250 251 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 252 #pragma GCC system_header 253 #endif 254 255 _LIBCPP_PUSH_MACROS 256 #include <__undef_macros> 257 258 #ifndef _LIBCPP_CXX03_LANG 259 260 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM 261 262 typedef chrono::time_point<_FilesystemClock> file_time_type; 263 264 struct _LIBCPP_TYPE_VIS space_info { 265 uintmax_t capacity; 266 uintmax_t free; 267 uintmax_t available; 268 }; 269 270 enum class _LIBCPP_ENUM_VIS file_type : signed char { 271 none = 0, 272 not_found = -1, 273 regular = 1, 274 directory = 2, 275 symlink = 3, 276 block = 4, 277 character = 5, 278 fifo = 6, 279 socket = 7, 280 unknown = 8 281 }; 282 283 enum class _LIBCPP_ENUM_VIS perms : unsigned { 284 none = 0, 285 286 owner_read = 0400, 287 owner_write = 0200, 288 owner_exec = 0100, 289 owner_all = 0700, 290 291 group_read = 040, 292 group_write = 020, 293 group_exec = 010, 294 group_all = 070, 295 296 others_read = 04, 297 others_write = 02, 298 others_exec = 01, 299 others_all = 07, 300 301 all = 0777, 302 303 set_uid = 04000, 304 set_gid = 02000, 305 sticky_bit = 01000, 306 mask = 07777, 307 unknown = 0xFFFF, 308 }; 309 310 _LIBCPP_INLINE_VISIBILITY 311 inline constexpr perms operator&(perms _LHS, perms _RHS) { 312 return static_cast<perms>(static_cast<unsigned>(_LHS) & 313 static_cast<unsigned>(_RHS)); 314 } 315 316 _LIBCPP_INLINE_VISIBILITY 317 inline constexpr perms operator|(perms _LHS, perms _RHS) { 318 return static_cast<perms>(static_cast<unsigned>(_LHS) | 319 static_cast<unsigned>(_RHS)); 320 } 321 322 _LIBCPP_INLINE_VISIBILITY 323 inline constexpr perms operator^(perms _LHS, perms _RHS) { 324 return static_cast<perms>(static_cast<unsigned>(_LHS) ^ 325 static_cast<unsigned>(_RHS)); 326 } 327 328 _LIBCPP_INLINE_VISIBILITY 329 inline constexpr perms operator~(perms _LHS) { 330 return static_cast<perms>(~static_cast<unsigned>(_LHS)); 331 } 332 333 _LIBCPP_INLINE_VISIBILITY 334 inline perms& operator&=(perms& _LHS, perms _RHS) { return _LHS = _LHS & _RHS; } 335 336 _LIBCPP_INLINE_VISIBILITY 337 inline perms& operator|=(perms& _LHS, perms _RHS) { return _LHS = _LHS | _RHS; } 338 339 _LIBCPP_INLINE_VISIBILITY 340 inline perms& operator^=(perms& _LHS, perms _RHS) { return _LHS = _LHS ^ _RHS; } 341 342 enum class _LIBCPP_ENUM_VIS perm_options : unsigned char { 343 replace = 1, 344 add = 2, 345 remove = 4, 346 nofollow = 8 347 }; 348 349 _LIBCPP_INLINE_VISIBILITY 350 inline constexpr perm_options operator&(perm_options _LHS, perm_options _RHS) { 351 return static_cast<perm_options>(static_cast<unsigned>(_LHS) & 352 static_cast<unsigned>(_RHS)); 353 } 354 355 _LIBCPP_INLINE_VISIBILITY 356 inline constexpr perm_options operator|(perm_options _LHS, perm_options _RHS) { 357 return static_cast<perm_options>(static_cast<unsigned>(_LHS) | 358 static_cast<unsigned>(_RHS)); 359 } 360 361 _LIBCPP_INLINE_VISIBILITY 362 inline constexpr perm_options operator^(perm_options _LHS, perm_options _RHS) { 363 return static_cast<perm_options>(static_cast<unsigned>(_LHS) ^ 364 static_cast<unsigned>(_RHS)); 365 } 366 367 _LIBCPP_INLINE_VISIBILITY 368 inline constexpr perm_options operator~(perm_options _LHS) { 369 return static_cast<perm_options>(~static_cast<unsigned>(_LHS)); 370 } 371 372 _LIBCPP_INLINE_VISIBILITY 373 inline perm_options& operator&=(perm_options& _LHS, perm_options _RHS) { 374 return _LHS = _LHS & _RHS; 375 } 376 377 _LIBCPP_INLINE_VISIBILITY 378 inline perm_options& operator|=(perm_options& _LHS, perm_options _RHS) { 379 return _LHS = _LHS | _RHS; 380 } 381 382 _LIBCPP_INLINE_VISIBILITY 383 inline perm_options& operator^=(perm_options& _LHS, perm_options _RHS) { 384 return _LHS = _LHS ^ _RHS; 385 } 386 387 enum class _LIBCPP_ENUM_VIS copy_options : unsigned short { 388 none = 0, 389 skip_existing = 1, 390 overwrite_existing = 2, 391 update_existing = 4, 392 recursive = 8, 393 copy_symlinks = 16, 394 skip_symlinks = 32, 395 directories_only = 64, 396 create_symlinks = 128, 397 create_hard_links = 256, 398 __in_recursive_copy = 512, 399 }; 400 401 _LIBCPP_INLINE_VISIBILITY 402 inline constexpr copy_options operator&(copy_options _LHS, copy_options _RHS) { 403 return static_cast<copy_options>(static_cast<unsigned short>(_LHS) & 404 static_cast<unsigned short>(_RHS)); 405 } 406 407 _LIBCPP_INLINE_VISIBILITY 408 inline constexpr copy_options operator|(copy_options _LHS, copy_options _RHS) { 409 return static_cast<copy_options>(static_cast<unsigned short>(_LHS) | 410 static_cast<unsigned short>(_RHS)); 411 } 412 413 _LIBCPP_INLINE_VISIBILITY 414 inline constexpr copy_options operator^(copy_options _LHS, copy_options _RHS) { 415 return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^ 416 static_cast<unsigned short>(_RHS)); 417 } 418 419 _LIBCPP_INLINE_VISIBILITY 420 inline constexpr copy_options operator~(copy_options _LHS) { 421 return static_cast<copy_options>(~static_cast<unsigned short>(_LHS)); 422 } 423 424 _LIBCPP_INLINE_VISIBILITY 425 inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS) { 426 return _LHS = _LHS & _RHS; 427 } 428 429 _LIBCPP_INLINE_VISIBILITY 430 inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS) { 431 return _LHS = _LHS | _RHS; 432 } 433 434 _LIBCPP_INLINE_VISIBILITY 435 inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS) { 436 return _LHS = _LHS ^ _RHS; 437 } 438 439 enum class _LIBCPP_ENUM_VIS directory_options : unsigned char { 440 none = 0, 441 follow_directory_symlink = 1, 442 skip_permission_denied = 2 443 }; 444 445 _LIBCPP_INLINE_VISIBILITY 446 inline constexpr directory_options operator&(directory_options _LHS, 447 directory_options _RHS) { 448 return static_cast<directory_options>(static_cast<unsigned char>(_LHS) & 449 static_cast<unsigned char>(_RHS)); 450 } 451 452 _LIBCPP_INLINE_VISIBILITY 453 inline constexpr directory_options operator|(directory_options _LHS, 454 directory_options _RHS) { 455 return static_cast<directory_options>(static_cast<unsigned char>(_LHS) | 456 static_cast<unsigned char>(_RHS)); 457 } 458 459 _LIBCPP_INLINE_VISIBILITY 460 inline constexpr directory_options operator^(directory_options _LHS, 461 directory_options _RHS) { 462 return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^ 463 static_cast<unsigned char>(_RHS)); 464 } 465 466 _LIBCPP_INLINE_VISIBILITY 467 inline constexpr directory_options operator~(directory_options _LHS) { 468 return static_cast<directory_options>(~static_cast<unsigned char>(_LHS)); 469 } 470 471 _LIBCPP_INLINE_VISIBILITY 472 inline directory_options& operator&=(directory_options& _LHS, 473 directory_options _RHS) { 474 return _LHS = _LHS & _RHS; 475 } 476 477 _LIBCPP_INLINE_VISIBILITY 478 inline directory_options& operator|=(directory_options& _LHS, 479 directory_options _RHS) { 480 return _LHS = _LHS | _RHS; 481 } 482 483 _LIBCPP_INLINE_VISIBILITY 484 inline directory_options& operator^=(directory_options& _LHS, 485 directory_options _RHS) { 486 return _LHS = _LHS ^ _RHS; 487 } 488 489 class _LIBCPP_TYPE_VIS file_status { 490 public: 491 // constructors 492 _LIBCPP_INLINE_VISIBILITY 493 file_status() noexcept : file_status(file_type::none) {} 494 _LIBCPP_INLINE_VISIBILITY 495 explicit file_status(file_type __ft, perms __prms = perms::unknown) noexcept 496 : __ft_(__ft), 497 __prms_(__prms) {} 498 499 file_status(const file_status&) noexcept = default; 500 file_status(file_status&&) noexcept = default; 501 502 _LIBCPP_INLINE_VISIBILITY 503 ~file_status() {} 504 505 file_status& operator=(const file_status&) noexcept = default; 506 file_status& operator=(file_status&&) noexcept = default; 507 508 // observers 509 _LIBCPP_INLINE_VISIBILITY 510 file_type type() const noexcept { return __ft_; } 511 512 _LIBCPP_INLINE_VISIBILITY 513 perms permissions() const noexcept { return __prms_; } 514 515 // modifiers 516 _LIBCPP_INLINE_VISIBILITY 517 void type(file_type __ft) noexcept { __ft_ = __ft; } 518 519 _LIBCPP_INLINE_VISIBILITY 520 void permissions(perms __p) noexcept { __prms_ = __p; } 521 522 private: 523 file_type __ft_; 524 perms __prms_; 525 }; 526 527 class _LIBCPP_TYPE_VIS directory_entry; 528 529 template <class _Tp> 530 struct __can_convert_char { 531 static const bool value = false; 532 }; 533 template <class _Tp> 534 struct __can_convert_char<const _Tp> : public __can_convert_char<_Tp> {}; 535 template <> 536 struct __can_convert_char<char> { 537 static const bool value = true; 538 using __char_type = char; 539 }; 540 template <> 541 struct __can_convert_char<wchar_t> { 542 static const bool value = true; 543 using __char_type = wchar_t; 544 }; 545 template <> 546 struct __can_convert_char<char16_t> { 547 static const bool value = true; 548 using __char_type = char16_t; 549 }; 550 template <> 551 struct __can_convert_char<char32_t> { 552 static const bool value = true; 553 using __char_type = char32_t; 554 }; 555 556 template <class _ECharT> 557 typename enable_if<__can_convert_char<_ECharT>::value, bool>::type 558 __is_separator(_ECharT __e) { 559 return __e == _ECharT('/'); 560 } 561 562 struct _NullSentinal {}; 563 564 template <class _Tp> 565 using _Void = void; 566 567 template <class _Tp, class = void> 568 struct __is_pathable_string : public false_type {}; 569 570 template <class _ECharT, class _Traits, class _Alloc> 571 struct __is_pathable_string< 572 basic_string<_ECharT, _Traits, _Alloc>, 573 _Void<typename __can_convert_char<_ECharT>::__char_type> > 574 : public __can_convert_char<_ECharT> { 575 using _Str = basic_string<_ECharT, _Traits, _Alloc>; 576 using _Base = __can_convert_char<_ECharT>; 577 static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); } 578 static _ECharT const* __range_end(_Str const& __s) { 579 return __s.data() + __s.length(); 580 } 581 static _ECharT __first_or_null(_Str const& __s) { 582 return __s.empty() ? _ECharT{} : __s[0]; 583 } 584 }; 585 586 template <class _ECharT, class _Traits> 587 struct __is_pathable_string< 588 basic_string_view<_ECharT, _Traits>, 589 _Void<typename __can_convert_char<_ECharT>::__char_type> > 590 : public __can_convert_char<_ECharT> { 591 using _Str = basic_string_view<_ECharT, _Traits>; 592 using _Base = __can_convert_char<_ECharT>; 593 static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); } 594 static _ECharT const* __range_end(_Str const& __s) { 595 return __s.data() + __s.length(); 596 } 597 static _ECharT __first_or_null(_Str const& __s) { 598 return __s.empty() ? _ECharT{} : __s[0]; 599 } 600 }; 601 602 template <class _Source, class _DS = typename decay<_Source>::type, 603 class _UnqualPtrType = 604 typename remove_const<typename remove_pointer<_DS>::type>::type, 605 bool _IsCharPtr = is_pointer<_DS>::value&& 606 __can_convert_char<_UnqualPtrType>::value> 607 struct __is_pathable_char_array : false_type {}; 608 609 template <class _Source, class _ECharT, class _UPtr> 610 struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true> 611 : __can_convert_char<typename remove_const<_ECharT>::type> { 612 using _Base = __can_convert_char<typename remove_const<_ECharT>::type>; 613 614 static _ECharT const* __range_begin(const _ECharT* __b) { return __b; } 615 static _ECharT const* __range_end(const _ECharT* __b) { 616 using _Iter = const _ECharT*; 617 const _ECharT __sentinal = _ECharT{}; 618 _Iter __e = __b; 619 for (; *__e != __sentinal; ++__e) 620 ; 621 return __e; 622 } 623 624 static _ECharT __first_or_null(const _ECharT* __b) { return *__b; } 625 }; 626 627 template <class _Iter, bool _IsIt = __is_input_iterator<_Iter>::value, 628 class = void> 629 struct __is_pathable_iter : false_type {}; 630 631 template <class _Iter> 632 struct __is_pathable_iter< 633 _Iter, true, 634 _Void<typename __can_convert_char< 635 typename iterator_traits<_Iter>::value_type>::__char_type> > 636 : __can_convert_char<typename iterator_traits<_Iter>::value_type> { 637 using _ECharT = typename iterator_traits<_Iter>::value_type; 638 using _Base = __can_convert_char<_ECharT>; 639 640 static _Iter __range_begin(_Iter __b) { return __b; } 641 static _NullSentinal __range_end(_Iter) { return _NullSentinal{}; } 642 643 static _ECharT __first_or_null(_Iter __b) { return *__b; } 644 }; 645 646 template <class _Tp, bool _IsStringT = __is_pathable_string<_Tp>::value, 647 bool _IsCharIterT = __is_pathable_char_array<_Tp>::value, 648 bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value> 649 struct __is_pathable : false_type { 650 static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false"); 651 }; 652 653 template <class _Tp> 654 struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {}; 655 656 template <class _Tp> 657 struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> { 658 }; 659 660 template <class _Tp> 661 struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {}; 662 663 template <class _ECharT> 664 struct _PathCVT { 665 static_assert(__can_convert_char<_ECharT>::value, 666 "Char type not convertible"); 667 668 typedef __narrow_to_utf8<sizeof(_ECharT) * __CHAR_BIT__> _Narrower; 669 670 static void __append_range(string& __dest, _ECharT const* __b, 671 _ECharT const* __e) { 672 _Narrower()(back_inserter(__dest), __b, __e); 673 } 674 675 template <class _Iter> 676 static void __append_range(string& __dest, _Iter __b, _Iter __e) { 677 static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload"); 678 if (__b == __e) 679 return; 680 basic_string<_ECharT> __tmp(__b, __e); 681 _Narrower()(back_inserter(__dest), __tmp.data(), 682 __tmp.data() + __tmp.length()); 683 } 684 685 template <class _Iter> 686 static void __append_range(string& __dest, _Iter __b, _NullSentinal) { 687 static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload"); 688 const _ECharT __sentinal = _ECharT{}; 689 if (*__b == __sentinal) 690 return; 691 basic_string<_ECharT> __tmp; 692 for (; *__b != __sentinal; ++__b) 693 __tmp.push_back(*__b); 694 _Narrower()(back_inserter(__dest), __tmp.data(), 695 __tmp.data() + __tmp.length()); 696 } 697 698 template <class _Source> 699 static void __append_source(string& __dest, _Source const& __s) { 700 using _Traits = __is_pathable<_Source>; 701 __append_range(__dest, _Traits::__range_begin(__s), 702 _Traits::__range_end(__s)); 703 } 704 }; 705 706 template <> 707 struct _PathCVT<char> { 708 709 template <class _Iter> 710 static typename enable_if<__is_exactly_input_iterator<_Iter>::value>::type 711 __append_range(string& __dest, _Iter __b, _Iter __e) { 712 for (; __b != __e; ++__b) 713 __dest.push_back(*__b); 714 } 715 716 template <class _Iter> 717 static typename enable_if<__is_forward_iterator<_Iter>::value>::type 718 __append_range(string& __dest, _Iter __b, _Iter __e) { 719 __dest.__append_forward_unsafe(__b, __e); 720 } 721 722 template <class _Iter> 723 static void __append_range(string& __dest, _Iter __b, _NullSentinal) { 724 const char __sentinal = char{}; 725 for (; *__b != __sentinal; ++__b) 726 __dest.push_back(*__b); 727 } 728 729 template <class _Source> 730 static void __append_source(string& __dest, _Source const& __s) { 731 using _Traits = __is_pathable<_Source>; 732 __append_range(__dest, _Traits::__range_begin(__s), 733 _Traits::__range_end(__s)); 734 } 735 }; 736 737 class _LIBCPP_TYPE_VIS path { 738 template <class _SourceOrIter, class _Tp = path&> 739 using _EnableIfPathable = 740 typename enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type; 741 742 template <class _Tp> 743 using _SourceChar = typename __is_pathable<_Tp>::__char_type; 744 745 template <class _Tp> 746 using _SourceCVT = _PathCVT<_SourceChar<_Tp> >; 747 748 public: 749 typedef char value_type; 750 typedef basic_string<value_type> string_type; 751 typedef _VSTD::string_view __string_view; 752 static constexpr value_type preferred_separator = '/'; 753 754 enum class _LIBCPP_ENUM_VIS format : unsigned char { 755 auto_format, 756 native_format, 757 generic_format 758 }; 759 760 // constructors and destructor 761 _LIBCPP_INLINE_VISIBILITY path() noexcept {} 762 _LIBCPP_INLINE_VISIBILITY path(const path& __p) : __pn_(__p.__pn_) {} 763 _LIBCPP_INLINE_VISIBILITY path(path&& __p) noexcept 764 : __pn_(_VSTD::move(__p.__pn_)) {} 765 766 _LIBCPP_INLINE_VISIBILITY 767 path(string_type&& __s, format = format::auto_format) noexcept 768 : __pn_(_VSTD::move(__s)) {} 769 770 template <class _Source, class = _EnableIfPathable<_Source, void> > 771 path(const _Source& __src, format = format::auto_format) { 772 _SourceCVT<_Source>::__append_source(__pn_, __src); 773 } 774 775 template <class _InputIt> 776 path(_InputIt __first, _InputIt __last, format = format::auto_format) { 777 typedef typename iterator_traits<_InputIt>::value_type _ItVal; 778 _PathCVT<_ItVal>::__append_range(__pn_, __first, __last); 779 } 780 781 // TODO Implement locale conversions. 782 template <class _Source, class = _EnableIfPathable<_Source, void> > 783 path(const _Source& __src, const locale& __loc, format = format::auto_format); 784 template <class _InputIt> 785 path(_InputIt __first, _InputIt _last, const locale& __loc, 786 format = format::auto_format); 787 788 _LIBCPP_INLINE_VISIBILITY 789 ~path() = default; 790 791 // assignments 792 _LIBCPP_INLINE_VISIBILITY 793 path& operator=(const path& __p) { 794 __pn_ = __p.__pn_; 795 return *this; 796 } 797 798 _LIBCPP_INLINE_VISIBILITY 799 path& operator=(path&& __p) noexcept { 800 __pn_ = _VSTD::move(__p.__pn_); 801 return *this; 802 } 803 804 template <class = void> 805 _LIBCPP_INLINE_VISIBILITY path& operator=(string_type&& __s) noexcept { 806 __pn_ = _VSTD::move(__s); 807 return *this; 808 } 809 810 _LIBCPP_INLINE_VISIBILITY 811 path& assign(string_type&& __s) noexcept { 812 __pn_ = _VSTD::move(__s); 813 return *this; 814 } 815 816 template <class _Source> 817 _LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source> 818 operator=(const _Source& __src) { 819 return this->assign(__src); 820 } 821 822 template <class _Source> 823 _EnableIfPathable<_Source> assign(const _Source& __src) { 824 __pn_.clear(); 825 _SourceCVT<_Source>::__append_source(__pn_, __src); 826 return *this; 827 } 828 829 template <class _InputIt> 830 path& assign(_InputIt __first, _InputIt __last) { 831 typedef typename iterator_traits<_InputIt>::value_type _ItVal; 832 __pn_.clear(); 833 _PathCVT<_ItVal>::__append_range(__pn_, __first, __last); 834 return *this; 835 } 836 837 private: 838 template <class _ECharT> 839 static bool __source_is_absolute(_ECharT __first_or_null) { 840 return __is_separator(__first_or_null); 841 } 842 843 public: 844 // appends 845 path& operator/=(const path& __p) { 846 if (__p.is_absolute()) { 847 __pn_ = __p.__pn_; 848 return *this; 849 } 850 if (has_filename()) 851 __pn_ += preferred_separator; 852 __pn_ += __p.native(); 853 return *this; 854 } 855 856 // FIXME: Use _LIBCPP_DIAGNOSE_WARNING to produce a diagnostic when __src 857 // is known at compile time to be "/' since the user almost certainly intended 858 // to append a separator instead of overwriting the path with "/" 859 template <class _Source> 860 _LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source> 861 operator/=(const _Source& __src) { 862 return this->append(__src); 863 } 864 865 template <class _Source> 866 _EnableIfPathable<_Source> append(const _Source& __src) { 867 using _Traits = __is_pathable<_Source>; 868 using _CVT = _PathCVT<_SourceChar<_Source> >; 869 if (__source_is_absolute(_Traits::__first_or_null(__src))) 870 __pn_.clear(); 871 else if (has_filename()) 872 __pn_ += preferred_separator; 873 _CVT::__append_source(__pn_, __src); 874 return *this; 875 } 876 877 template <class _InputIt> 878 path& append(_InputIt __first, _InputIt __last) { 879 typedef typename iterator_traits<_InputIt>::value_type _ItVal; 880 static_assert(__can_convert_char<_ItVal>::value, "Must convertible"); 881 using _CVT = _PathCVT<_ItVal>; 882 if (__first != __last && __source_is_absolute(*__first)) 883 __pn_.clear(); 884 else if (has_filename()) 885 __pn_ += preferred_separator; 886 _CVT::__append_range(__pn_, __first, __last); 887 return *this; 888 } 889 890 // concatenation 891 _LIBCPP_INLINE_VISIBILITY 892 path& operator+=(const path& __x) { 893 __pn_ += __x.__pn_; 894 return *this; 895 } 896 897 _LIBCPP_INLINE_VISIBILITY 898 path& operator+=(const string_type& __x) { 899 __pn_ += __x; 900 return *this; 901 } 902 903 _LIBCPP_INLINE_VISIBILITY 904 path& operator+=(__string_view __x) { 905 __pn_ += __x; 906 return *this; 907 } 908 909 _LIBCPP_INLINE_VISIBILITY 910 path& operator+=(const value_type* __x) { 911 __pn_ += __x; 912 return *this; 913 } 914 915 _LIBCPP_INLINE_VISIBILITY 916 path& operator+=(value_type __x) { 917 __pn_ += __x; 918 return *this; 919 } 920 921 template <class _ECharT> 922 typename enable_if<__can_convert_char<_ECharT>::value, path&>::type 923 operator+=(_ECharT __x) { 924 basic_string<_ECharT> __tmp; 925 __tmp += __x; 926 _PathCVT<_ECharT>::__append_source(__pn_, __tmp); 927 return *this; 928 } 929 930 template <class _Source> 931 _EnableIfPathable<_Source> operator+=(const _Source& __x) { 932 return this->concat(__x); 933 } 934 935 template <class _Source> 936 _EnableIfPathable<_Source> concat(const _Source& __x) { 937 _SourceCVT<_Source>::__append_source(__pn_, __x); 938 return *this; 939 } 940 941 template <class _InputIt> 942 path& concat(_InputIt __first, _InputIt __last) { 943 typedef typename iterator_traits<_InputIt>::value_type _ItVal; 944 _PathCVT<_ItVal>::__append_range(__pn_, __first, __last); 945 return *this; 946 } 947 948 // modifiers 949 _LIBCPP_INLINE_VISIBILITY 950 void clear() noexcept { __pn_.clear(); } 951 952 path& make_preferred() { return *this; } 953 954 _LIBCPP_INLINE_VISIBILITY 955 path& remove_filename() { 956 auto __fname = __filename(); 957 if (!__fname.empty()) 958 __pn_.erase(__fname.data() - __pn_.data()); 959 return *this; 960 } 961 962 path& replace_filename(const path& __replacement) { 963 remove_filename(); 964 return (*this /= __replacement); 965 } 966 967 path& replace_extension(const path& __replacement = path()); 968 969 _LIBCPP_INLINE_VISIBILITY 970 void swap(path& __rhs) noexcept { __pn_.swap(__rhs.__pn_); } 971 972 // private helper to allow reserving memory in the path 973 _LIBCPP_INLINE_VISIBILITY 974 void __reserve(size_t __s) { __pn_.reserve(__s); } 975 976 // native format observers 977 _LIBCPP_INLINE_VISIBILITY 978 const string_type& native() const noexcept { return __pn_; } 979 980 _LIBCPP_INLINE_VISIBILITY 981 const value_type* c_str() const noexcept { return __pn_.c_str(); } 982 983 _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_; } 984 985 template <class _ECharT, class _Traits = char_traits<_ECharT>, 986 class _Allocator = allocator<_ECharT> > 987 basic_string<_ECharT, _Traits, _Allocator> 988 string(const _Allocator& __a = _Allocator()) const { 989 using _CVT = __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__>; 990 using _Str = basic_string<_ECharT, _Traits, _Allocator>; 991 _Str __s(__a); 992 __s.reserve(__pn_.size()); 993 _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size()); 994 return __s; 995 } 996 997 _LIBCPP_INLINE_VISIBILITY std::string string() const { return __pn_; } 998 _LIBCPP_INLINE_VISIBILITY std::wstring wstring() const { 999 return string<wchar_t>(); 1000 } 1001 _LIBCPP_INLINE_VISIBILITY std::string u8string() const { return __pn_; } 1002 _LIBCPP_INLINE_VISIBILITY std::u16string u16string() const { 1003 return string<char16_t>(); 1004 } 1005 _LIBCPP_INLINE_VISIBILITY std::u32string u32string() const { 1006 return string<char32_t>(); 1007 } 1008 1009 // generic format observers 1010 template <class _ECharT, class _Traits = char_traits<_ECharT>, 1011 class _Allocator = allocator<_ECharT> > 1012 basic_string<_ECharT, _Traits, _Allocator> 1013 generic_string(const _Allocator& __a = _Allocator()) const { 1014 return string<_ECharT, _Traits, _Allocator>(__a); 1015 } 1016 1017 std::string generic_string() const { return __pn_; } 1018 std::wstring generic_wstring() const { return string<wchar_t>(); } 1019 std::string generic_u8string() const { return __pn_; } 1020 std::u16string generic_u16string() const { return string<char16_t>(); } 1021 std::u32string generic_u32string() const { return string<char32_t>(); } 1022 1023 private: 1024 int __compare(__string_view) const; 1025 __string_view __root_name() const; 1026 __string_view __root_directory() const; 1027 __string_view __root_path_raw() const; 1028 __string_view __relative_path() const; 1029 __string_view __parent_path() const; 1030 __string_view __filename() const; 1031 __string_view __stem() const; 1032 __string_view __extension() const; 1033 1034 public: 1035 // compare 1036 _LIBCPP_INLINE_VISIBILITY int compare(const path& __p) const noexcept { 1037 return __compare(__p.__pn_); 1038 } 1039 _LIBCPP_INLINE_VISIBILITY int compare(const string_type& __s) const { 1040 return __compare(__s); 1041 } 1042 _LIBCPP_INLINE_VISIBILITY int compare(__string_view __s) const { 1043 return __compare(__s); 1044 } 1045 _LIBCPP_INLINE_VISIBILITY int compare(const value_type* __s) const { 1046 return __compare(__s); 1047 } 1048 1049 // decomposition 1050 _LIBCPP_INLINE_VISIBILITY path root_name() const { 1051 return string_type(__root_name()); 1052 } 1053 _LIBCPP_INLINE_VISIBILITY path root_directory() const { 1054 return string_type(__root_directory()); 1055 } 1056 _LIBCPP_INLINE_VISIBILITY path root_path() const { 1057 return root_name().append(string_type(__root_directory())); 1058 } 1059 _LIBCPP_INLINE_VISIBILITY path relative_path() const { 1060 return string_type(__relative_path()); 1061 } 1062 _LIBCPP_INLINE_VISIBILITY path parent_path() const { 1063 return string_type(__parent_path()); 1064 } 1065 _LIBCPP_INLINE_VISIBILITY path filename() const { 1066 return string_type(__filename()); 1067 } 1068 _LIBCPP_INLINE_VISIBILITY path stem() const { return string_type(__stem()); } 1069 _LIBCPP_INLINE_VISIBILITY path extension() const { 1070 return string_type(__extension()); 1071 } 1072 1073 // query 1074 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY bool 1075 empty() const noexcept { 1076 return __pn_.empty(); 1077 } 1078 1079 _LIBCPP_INLINE_VISIBILITY bool has_root_name() const { 1080 return !__root_name().empty(); 1081 } 1082 _LIBCPP_INLINE_VISIBILITY bool has_root_directory() const { 1083 return !__root_directory().empty(); 1084 } 1085 _LIBCPP_INLINE_VISIBILITY bool has_root_path() const { 1086 return !__root_path_raw().empty(); 1087 } 1088 _LIBCPP_INLINE_VISIBILITY bool has_relative_path() const { 1089 return !__relative_path().empty(); 1090 } 1091 _LIBCPP_INLINE_VISIBILITY bool has_parent_path() const { 1092 return !__parent_path().empty(); 1093 } 1094 _LIBCPP_INLINE_VISIBILITY bool has_filename() const { 1095 return !__filename().empty(); 1096 } 1097 _LIBCPP_INLINE_VISIBILITY bool has_stem() const { return !__stem().empty(); } 1098 _LIBCPP_INLINE_VISIBILITY bool has_extension() const { 1099 return !__extension().empty(); 1100 } 1101 1102 _LIBCPP_INLINE_VISIBILITY bool is_absolute() const { 1103 return has_root_directory(); 1104 } 1105 _LIBCPP_INLINE_VISIBILITY bool is_relative() const { return !is_absolute(); } 1106 1107 // relative paths 1108 path lexically_normal() const; 1109 path lexically_relative(const path& __base) const; 1110 1111 _LIBCPP_INLINE_VISIBILITY path lexically_proximate(const path& __base) const { 1112 path __result = this->lexically_relative(__base); 1113 if (__result.native().empty()) 1114 return *this; 1115 return __result; 1116 } 1117 1118 // iterators 1119 class _LIBCPP_TYPE_VIS iterator; 1120 typedef iterator const_iterator; 1121 1122 iterator begin() const; 1123 iterator end() const; 1124 1125 template <class _CharT, class _Traits> 1126 _LIBCPP_INLINE_VISIBILITY friend 1127 typename enable_if<is_same<_CharT, char>::value && 1128 is_same<_Traits, char_traits<char> >::value, 1129 basic_ostream<_CharT, _Traits>&>::type 1130 operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) { 1131 __os << std::__quoted(__p.native()); 1132 return __os; 1133 } 1134 1135 template <class _CharT, class _Traits> 1136 _LIBCPP_INLINE_VISIBILITY friend 1137 typename enable_if<!is_same<_CharT, char>::value || 1138 !is_same<_Traits, char_traits<char> >::value, 1139 basic_ostream<_CharT, _Traits>&>::type 1140 operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) { 1141 __os << std::__quoted(__p.string<_CharT, _Traits>()); 1142 return __os; 1143 } 1144 1145 template <class _CharT, class _Traits> 1146 _LIBCPP_INLINE_VISIBILITY friend basic_istream<_CharT, _Traits>& 1147 operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) { 1148 basic_string<_CharT, _Traits> __tmp; 1149 __is >> __quoted(__tmp); 1150 __p = __tmp; 1151 return __is; 1152 } 1153 1154 friend _LIBCPP_INLINE_VISIBILITY bool operator==(const path& __lhs, const path& __rhs) noexcept { 1155 return __lhs.compare(__rhs) == 0; 1156 } 1157 friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const path& __lhs, const path& __rhs) noexcept { 1158 return __lhs.compare(__rhs) != 0; 1159 } 1160 friend _LIBCPP_INLINE_VISIBILITY bool operator<(const path& __lhs, const path& __rhs) noexcept { 1161 return __lhs.compare(__rhs) < 0; 1162 } 1163 friend _LIBCPP_INLINE_VISIBILITY bool operator<=(const path& __lhs, const path& __rhs) noexcept { 1164 return __lhs.compare(__rhs) <= 0; 1165 } 1166 friend _LIBCPP_INLINE_VISIBILITY bool operator>(const path& __lhs, const path& __rhs) noexcept { 1167 return __lhs.compare(__rhs) > 0; 1168 } 1169 friend _LIBCPP_INLINE_VISIBILITY bool operator>=(const path& __lhs, const path& __rhs) noexcept { 1170 return __lhs.compare(__rhs) >= 0; 1171 } 1172 1173 friend _LIBCPP_INLINE_VISIBILITY path operator/(const path& __lhs, 1174 const path& __rhs) { 1175 path __result(__lhs); 1176 __result /= __rhs; 1177 return __result; 1178 } 1179 private: 1180 inline _LIBCPP_INLINE_VISIBILITY path& 1181 __assign_view(__string_view const& __s) noexcept { 1182 __pn_ = string_type(__s); 1183 return *this; 1184 } 1185 string_type __pn_; 1186 }; 1187 1188 inline _LIBCPP_INLINE_VISIBILITY void swap(path& __lhs, path& __rhs) noexcept { 1189 __lhs.swap(__rhs); 1190 } 1191 1192 _LIBCPP_FUNC_VIS 1193 size_t hash_value(const path& __p) noexcept; 1194 1195 template <class _Source> 1196 _LIBCPP_INLINE_VISIBILITY 1197 typename enable_if<__is_pathable<_Source>::value, path>::type 1198 u8path(const _Source& __s) { 1199 static_assert( 1200 is_same<typename __is_pathable<_Source>::__char_type, char>::value, 1201 "u8path(Source const&) requires Source have a character type of type " 1202 "'char'"); 1203 return path(__s); 1204 } 1205 1206 template <class _InputIt> 1207 _LIBCPP_INLINE_VISIBILITY 1208 typename enable_if<__is_pathable<_InputIt>::value, path>::type 1209 u8path(_InputIt __f, _InputIt __l) { 1210 static_assert( 1211 is_same<typename __is_pathable<_InputIt>::__char_type, char>::value, 1212 "u8path(Iter, Iter) requires Iter have a value_type of type 'char'"); 1213 return path(__f, __l); 1214 } 1215 1216 class _LIBCPP_TYPE_VIS path::iterator { 1217 public: 1218 enum _ParserState : unsigned char { 1219 _Singular, 1220 _BeforeBegin, 1221 _InRootName, 1222 _InRootDir, 1223 _InFilenames, 1224 _InTrailingSep, 1225 _AtEnd 1226 }; 1227 1228 public: 1229 typedef bidirectional_iterator_tag iterator_category; 1230 1231 typedef path value_type; 1232 typedef std::ptrdiff_t difference_type; 1233 typedef const path* pointer; 1234 typedef const path& reference; 1235 1236 typedef void 1237 __stashing_iterator_tag; // See reverse_iterator and __is_stashing_iterator 1238 1239 public: 1240 _LIBCPP_INLINE_VISIBILITY 1241 iterator() 1242 : __stashed_elem_(), __path_ptr_(nullptr), __entry_(), 1243 __state_(_Singular) {} 1244 1245 iterator(const iterator&) = default; 1246 ~iterator() = default; 1247 1248 iterator& operator=(const iterator&) = default; 1249 1250 _LIBCPP_INLINE_VISIBILITY 1251 reference operator*() const { return __stashed_elem_; } 1252 1253 _LIBCPP_INLINE_VISIBILITY 1254 pointer operator->() const { return &__stashed_elem_; } 1255 1256 _LIBCPP_INLINE_VISIBILITY 1257 iterator& operator++() { 1258 _LIBCPP_ASSERT(__state_ != _Singular, 1259 "attempting to increment a singular iterator"); 1260 _LIBCPP_ASSERT(__state_ != _AtEnd, 1261 "attempting to increment the end iterator"); 1262 return __increment(); 1263 } 1264 1265 _LIBCPP_INLINE_VISIBILITY 1266 iterator operator++(int) { 1267 iterator __it(*this); 1268 this->operator++(); 1269 return __it; 1270 } 1271 1272 _LIBCPP_INLINE_VISIBILITY 1273 iterator& operator--() { 1274 _LIBCPP_ASSERT(__state_ != _Singular, 1275 "attempting to decrement a singular iterator"); 1276 _LIBCPP_ASSERT(__entry_.data() != __path_ptr_->native().data(), 1277 "attempting to decrement the begin iterator"); 1278 return __decrement(); 1279 } 1280 1281 _LIBCPP_INLINE_VISIBILITY 1282 iterator operator--(int) { 1283 iterator __it(*this); 1284 this->operator--(); 1285 return __it; 1286 } 1287 1288 private: 1289 friend class path; 1290 1291 inline _LIBCPP_INLINE_VISIBILITY friend bool operator==(const iterator&, 1292 const iterator&); 1293 1294 iterator& __increment(); 1295 iterator& __decrement(); 1296 1297 path __stashed_elem_; 1298 const path* __path_ptr_; 1299 path::__string_view __entry_; 1300 _ParserState __state_; 1301 }; 1302 1303 inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path::iterator& __lhs, 1304 const path::iterator& __rhs) { 1305 return __lhs.__path_ptr_ == __rhs.__path_ptr_ && 1306 __lhs.__entry_.data() == __rhs.__entry_.data(); 1307 } 1308 1309 inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs, 1310 const path::iterator& __rhs) { 1311 return !(__lhs == __rhs); 1312 } 1313 1314 class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error { 1315 public: 1316 _LIBCPP_INLINE_VISIBILITY 1317 filesystem_error(const string& __what, error_code __ec) 1318 : system_error(__ec, __what), 1319 __storage_(make_shared<_Storage>(path(), path())) { 1320 __create_what(0); 1321 } 1322 1323 _LIBCPP_INLINE_VISIBILITY 1324 filesystem_error(const string& __what, const path& __p1, error_code __ec) 1325 : system_error(__ec, __what), 1326 __storage_(make_shared<_Storage>(__p1, path())) { 1327 __create_what(1); 1328 } 1329 1330 _LIBCPP_INLINE_VISIBILITY 1331 filesystem_error(const string& __what, const path& __p1, const path& __p2, 1332 error_code __ec) 1333 : system_error(__ec, __what), 1334 __storage_(make_shared<_Storage>(__p1, __p2)) { 1335 __create_what(2); 1336 } 1337 1338 _LIBCPP_INLINE_VISIBILITY 1339 const path& path1() const noexcept { return __storage_->__p1_; } 1340 1341 _LIBCPP_INLINE_VISIBILITY 1342 const path& path2() const noexcept { return __storage_->__p2_; } 1343 1344 ~filesystem_error() override; // key function 1345 1346 _LIBCPP_INLINE_VISIBILITY 1347 const char* what() const noexcept override { 1348 return __storage_->__what_.c_str(); 1349 } 1350 1351 _LIBCPP_FUNC_VIS 1352 void __create_what(int __num_paths); 1353 1354 private: 1355 struct _Storage { 1356 _LIBCPP_INLINE_VISIBILITY 1357 _Storage(const path& __p1, const path& __p2) : __p1_(__p1), __p2_(__p2) {} 1358 1359 path __p1_; 1360 path __p2_; 1361 string __what_; 1362 }; 1363 shared_ptr<_Storage> __storage_; 1364 }; 1365 1366 template <class... _Args> 1367 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY 1368 #ifndef _LIBCPP_NO_EXCEPTIONS 1369 void 1370 __throw_filesystem_error(_Args&&... __args) { 1371 throw filesystem_error(std::forward<_Args>(__args)...); 1372 } 1373 #else 1374 void 1375 __throw_filesystem_error(_Args&&...) { 1376 _VSTD::abort(); 1377 } 1378 #endif 1379 1380 // operational functions 1381 1382 _LIBCPP_FUNC_VIS 1383 path __absolute(const path&, error_code* __ec = nullptr); 1384 _LIBCPP_FUNC_VIS 1385 path __canonical(const path&, error_code* __ec = nullptr); 1386 _LIBCPP_FUNC_VIS 1387 void __copy(const path& __from, const path& __to, copy_options __opt, 1388 error_code* __ec = nullptr); 1389 _LIBCPP_FUNC_VIS 1390 bool __copy_file(const path& __from, const path& __to, copy_options __opt, 1391 error_code* __ec = nullptr); 1392 _LIBCPP_FUNC_VIS 1393 void __copy_symlink(const path& __existing_symlink, const path& __new_symlink, 1394 error_code* __ec = nullptr); 1395 _LIBCPP_FUNC_VIS 1396 bool __create_directories(const path& p, error_code* ec = nullptr); 1397 _LIBCPP_FUNC_VIS 1398 bool __create_directory(const path& p, error_code* ec = nullptr); 1399 _LIBCPP_FUNC_VIS 1400 bool __create_directory(const path& p, const path& attributes, 1401 error_code* ec = nullptr); 1402 _LIBCPP_FUNC_VIS 1403 void __create_directory_symlink(const path& __to, const path& __new_symlink, 1404 error_code* __ec = nullptr); 1405 _LIBCPP_FUNC_VIS 1406 void __create_hard_link(const path& __to, const path& __new_hard_link, 1407 error_code* __ec = nullptr); 1408 _LIBCPP_FUNC_VIS 1409 void __create_symlink(const path& __to, const path& __new_symlink, 1410 error_code* __ec = nullptr); 1411 _LIBCPP_FUNC_VIS 1412 path __current_path(error_code* __ec = nullptr); 1413 _LIBCPP_FUNC_VIS 1414 void __current_path(const path&, error_code* __ec = nullptr); 1415 _LIBCPP_FUNC_VIS 1416 bool __equivalent(const path&, const path&, error_code* __ec = nullptr); 1417 _LIBCPP_FUNC_VIS 1418 uintmax_t __file_size(const path&, error_code* __ec = nullptr); 1419 _LIBCPP_FUNC_VIS 1420 uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr); 1421 _LIBCPP_FUNC_VIS 1422 bool __fs_is_empty(const path& p, error_code* ec = nullptr); 1423 _LIBCPP_FUNC_VIS 1424 file_time_type __last_write_time(const path& p, error_code* ec = nullptr); 1425 _LIBCPP_FUNC_VIS 1426 void __last_write_time(const path& p, file_time_type new_time, 1427 error_code* ec = nullptr); 1428 _LIBCPP_FUNC_VIS 1429 void __permissions(const path&, perms, perm_options, error_code* = nullptr); 1430 _LIBCPP_FUNC_VIS 1431 path __read_symlink(const path& p, error_code* ec = nullptr); 1432 _LIBCPP_FUNC_VIS 1433 bool __remove(const path& p, error_code* ec = nullptr); 1434 _LIBCPP_FUNC_VIS 1435 uintmax_t __remove_all(const path& p, error_code* ec = nullptr); 1436 _LIBCPP_FUNC_VIS 1437 void __rename(const path& from, const path& to, error_code* ec = nullptr); 1438 _LIBCPP_FUNC_VIS 1439 void __resize_file(const path& p, uintmax_t size, error_code* ec = nullptr); 1440 _LIBCPP_FUNC_VIS 1441 space_info __space(const path&, error_code* __ec = nullptr); 1442 _LIBCPP_FUNC_VIS 1443 file_status __status(const path&, error_code* __ec = nullptr); 1444 _LIBCPP_FUNC_VIS 1445 file_status __symlink_status(const path&, error_code* __ec = nullptr); 1446 _LIBCPP_FUNC_VIS 1447 path __system_complete(const path&, error_code* __ec = nullptr); 1448 _LIBCPP_FUNC_VIS 1449 path __temp_directory_path(error_code* __ec = nullptr); 1450 _LIBCPP_FUNC_VIS 1451 path __weakly_canonical(path const& __p, error_code* __ec = nullptr); 1452 1453 inline _LIBCPP_INLINE_VISIBILITY path current_path() { 1454 return __current_path(); 1455 } 1456 1457 inline _LIBCPP_INLINE_VISIBILITY path current_path(error_code& __ec) { 1458 return __current_path(&__ec); 1459 } 1460 1461 inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p) { 1462 __current_path(__p); 1463 } 1464 1465 inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p, 1466 error_code& __ec) noexcept { 1467 __current_path(__p, &__ec); 1468 } 1469 1470 inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p) { 1471 return __absolute(__p); 1472 } 1473 1474 inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p, 1475 error_code& __ec) { 1476 return __absolute(__p, &__ec); 1477 } 1478 1479 inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p) { 1480 return __canonical(__p); 1481 } 1482 1483 inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p, 1484 error_code& __ec) { 1485 return __canonical(__p, &__ec); 1486 } 1487 1488 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, 1489 const path& __to) { 1490 __copy(__from, __to, copy_options::none); 1491 } 1492 1493 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to, 1494 error_code& __ec) { 1495 __copy(__from, __to, copy_options::none, &__ec); 1496 } 1497 1498 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to, 1499 copy_options __opt) { 1500 __copy(__from, __to, __opt); 1501 } 1502 1503 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to, 1504 copy_options __opt, 1505 error_code& __ec) { 1506 __copy(__from, __to, __opt, &__ec); 1507 } 1508 1509 inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from, 1510 const path& __to) { 1511 return __copy_file(__from, __to, copy_options::none); 1512 } 1513 1514 inline _LIBCPP_INLINE_VISIBILITY bool 1515 copy_file(const path& __from, const path& __to, error_code& __ec) { 1516 return __copy_file(__from, __to, copy_options::none, &__ec); 1517 } 1518 1519 inline _LIBCPP_INLINE_VISIBILITY bool 1520 copy_file(const path& __from, const path& __to, copy_options __opt) { 1521 return __copy_file(__from, __to, __opt); 1522 } 1523 1524 inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from, 1525 const path& __to, 1526 copy_options __opt, 1527 error_code& __ec) { 1528 return __copy_file(__from, __to, __opt, &__ec); 1529 } 1530 1531 inline _LIBCPP_INLINE_VISIBILITY void copy_symlink(const path& __existing, 1532 const path& __new) { 1533 __copy_symlink(__existing, __new); 1534 } 1535 1536 inline _LIBCPP_INLINE_VISIBILITY void 1537 copy_symlink(const path& __ext, const path& __new, error_code& __ec) noexcept { 1538 __copy_symlink(__ext, __new, &__ec); 1539 } 1540 1541 inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p) { 1542 return __create_directories(__p); 1543 } 1544 1545 inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p, 1546 error_code& __ec) { 1547 return __create_directories(__p, &__ec); 1548 } 1549 1550 inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p) { 1551 return __create_directory(__p); 1552 } 1553 1554 inline _LIBCPP_INLINE_VISIBILITY bool 1555 create_directory(const path& __p, error_code& __ec) noexcept { 1556 return __create_directory(__p, &__ec); 1557 } 1558 1559 inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p, 1560 const path& __attrs) { 1561 return __create_directory(__p, __attrs); 1562 } 1563 1564 inline _LIBCPP_INLINE_VISIBILITY bool 1565 create_directory(const path& __p, const path& __attrs, 1566 error_code& __ec) noexcept { 1567 return __create_directory(__p, __attrs, &__ec); 1568 } 1569 1570 inline _LIBCPP_INLINE_VISIBILITY void 1571 create_directory_symlink(const path& __to, const path& __new) { 1572 __create_directory_symlink(__to, __new); 1573 } 1574 1575 inline _LIBCPP_INLINE_VISIBILITY void 1576 create_directory_symlink(const path& __to, const path& __new, 1577 error_code& __ec) noexcept { 1578 __create_directory_symlink(__to, __new, &__ec); 1579 } 1580 1581 inline _LIBCPP_INLINE_VISIBILITY void create_hard_link(const path& __to, 1582 const path& __new) { 1583 __create_hard_link(__to, __new); 1584 } 1585 1586 inline _LIBCPP_INLINE_VISIBILITY void 1587 create_hard_link(const path& __to, const path& __new, 1588 error_code& __ec) noexcept { 1589 __create_hard_link(__to, __new, &__ec); 1590 } 1591 1592 inline _LIBCPP_INLINE_VISIBILITY void create_symlink(const path& __to, 1593 const path& __new) { 1594 __create_symlink(__to, __new); 1595 } 1596 1597 inline _LIBCPP_INLINE_VISIBILITY void 1598 create_symlink(const path& __to, const path& __new, error_code& __ec) noexcept { 1599 return __create_symlink(__to, __new, &__ec); 1600 } 1601 1602 inline _LIBCPP_INLINE_VISIBILITY bool status_known(file_status __s) noexcept { 1603 return __s.type() != file_type::none; 1604 } 1605 1606 inline _LIBCPP_INLINE_VISIBILITY bool exists(file_status __s) noexcept { 1607 return status_known(__s) && __s.type() != file_type::not_found; 1608 } 1609 1610 inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p) { 1611 return exists(__status(__p)); 1612 } 1613 1614 inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p, 1615 error_code& __ec) noexcept { 1616 auto __s = __status(__p, &__ec); 1617 if (status_known(__s)) 1618 __ec.clear(); 1619 return exists(__s); 1620 } 1621 1622 inline _LIBCPP_INLINE_VISIBILITY bool equivalent(const path& __p1, 1623 const path& __p2) { 1624 return __equivalent(__p1, __p2); 1625 } 1626 1627 inline _LIBCPP_INLINE_VISIBILITY bool 1628 equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept { 1629 return __equivalent(__p1, __p2, &__ec); 1630 } 1631 1632 inline _LIBCPP_INLINE_VISIBILITY uintmax_t file_size(const path& __p) { 1633 return __file_size(__p); 1634 } 1635 1636 inline _LIBCPP_INLINE_VISIBILITY uintmax_t 1637 file_size(const path& __p, error_code& __ec) noexcept { 1638 return __file_size(__p, &__ec); 1639 } 1640 1641 inline _LIBCPP_INLINE_VISIBILITY uintmax_t hard_link_count(const path& __p) { 1642 return __hard_link_count(__p); 1643 } 1644 1645 inline _LIBCPP_INLINE_VISIBILITY uintmax_t 1646 hard_link_count(const path& __p, error_code& __ec) noexcept { 1647 return __hard_link_count(__p, &__ec); 1648 } 1649 1650 inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(file_status __s) noexcept { 1651 return __s.type() == file_type::block; 1652 } 1653 1654 inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p) { 1655 return is_block_file(__status(__p)); 1656 } 1657 1658 inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p, 1659 error_code& __ec) noexcept { 1660 return is_block_file(__status(__p, &__ec)); 1661 } 1662 1663 inline _LIBCPP_INLINE_VISIBILITY bool 1664 is_character_file(file_status __s) noexcept { 1665 return __s.type() == file_type::character; 1666 } 1667 1668 inline _LIBCPP_INLINE_VISIBILITY bool is_character_file(const path& __p) { 1669 return is_character_file(__status(__p)); 1670 } 1671 1672 inline _LIBCPP_INLINE_VISIBILITY bool 1673 is_character_file(const path& __p, error_code& __ec) noexcept { 1674 return is_character_file(__status(__p, &__ec)); 1675 } 1676 1677 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(file_status __s) noexcept { 1678 return __s.type() == file_type::directory; 1679 } 1680 1681 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p) { 1682 return is_directory(__status(__p)); 1683 } 1684 1685 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p, 1686 error_code& __ec) noexcept { 1687 return is_directory(__status(__p, &__ec)); 1688 } 1689 1690 inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p) { 1691 return __fs_is_empty(__p); 1692 } 1693 1694 inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p, 1695 error_code& __ec) { 1696 return __fs_is_empty(__p, &__ec); 1697 } 1698 1699 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(file_status __s) noexcept { 1700 return __s.type() == file_type::fifo; 1701 } 1702 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p) { 1703 return is_fifo(__status(__p)); 1704 } 1705 1706 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p, 1707 error_code& __ec) noexcept { 1708 return is_fifo(__status(__p, &__ec)); 1709 } 1710 1711 inline _LIBCPP_INLINE_VISIBILITY bool 1712 is_regular_file(file_status __s) noexcept { 1713 return __s.type() == file_type::regular; 1714 } 1715 1716 inline _LIBCPP_INLINE_VISIBILITY bool is_regular_file(const path& __p) { 1717 return is_regular_file(__status(__p)); 1718 } 1719 1720 inline _LIBCPP_INLINE_VISIBILITY bool 1721 is_regular_file(const path& __p, error_code& __ec) noexcept { 1722 return is_regular_file(__status(__p, &__ec)); 1723 } 1724 1725 inline _LIBCPP_INLINE_VISIBILITY bool is_socket(file_status __s) noexcept { 1726 return __s.type() == file_type::socket; 1727 } 1728 1729 inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p) { 1730 return is_socket(__status(__p)); 1731 } 1732 1733 inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p, 1734 error_code& __ec) noexcept { 1735 return is_socket(__status(__p, &__ec)); 1736 } 1737 1738 inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(file_status __s) noexcept { 1739 return __s.type() == file_type::symlink; 1740 } 1741 1742 inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p) { 1743 return is_symlink(__symlink_status(__p)); 1744 } 1745 1746 inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p, 1747 error_code& __ec) noexcept { 1748 return is_symlink(__symlink_status(__p, &__ec)); 1749 } 1750 1751 inline _LIBCPP_INLINE_VISIBILITY bool is_other(file_status __s) noexcept { 1752 return exists(__s) && !is_regular_file(__s) && !is_directory(__s) && 1753 !is_symlink(__s); 1754 } 1755 1756 inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p) { 1757 return is_other(__status(__p)); 1758 } 1759 1760 inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p, 1761 error_code& __ec) noexcept { 1762 return is_other(__status(__p, &__ec)); 1763 } 1764 1765 inline _LIBCPP_INLINE_VISIBILITY file_time_type 1766 last_write_time(const path& __p) { 1767 return __last_write_time(__p); 1768 } 1769 1770 inline _LIBCPP_INLINE_VISIBILITY file_time_type 1771 last_write_time(const path& __p, error_code& __ec) noexcept { 1772 return __last_write_time(__p, &__ec); 1773 } 1774 1775 inline _LIBCPP_INLINE_VISIBILITY void last_write_time(const path& __p, 1776 file_time_type __t) { 1777 __last_write_time(__p, __t); 1778 } 1779 1780 inline _LIBCPP_INLINE_VISIBILITY void 1781 last_write_time(const path& __p, file_time_type __t, 1782 error_code& __ec) noexcept { 1783 __last_write_time(__p, __t, &__ec); 1784 } 1785 1786 inline _LIBCPP_INLINE_VISIBILITY void 1787 permissions(const path& __p, perms __prms, 1788 perm_options __opts = perm_options::replace) { 1789 __permissions(__p, __prms, __opts); 1790 } 1791 1792 inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms, 1793 error_code& __ec) noexcept { 1794 __permissions(__p, __prms, perm_options::replace, &__ec); 1795 } 1796 1797 inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms, 1798 perm_options __opts, 1799 error_code& __ec) { 1800 __permissions(__p, __prms, __opts, &__ec); 1801 } 1802 1803 inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p, 1804 const path& __base, 1805 error_code& __ec) { 1806 path __tmp = __weakly_canonical(__p, &__ec); 1807 if (__ec) 1808 return {}; 1809 path __tmp_base = __weakly_canonical(__base, &__ec); 1810 if (__ec) 1811 return {}; 1812 return __tmp.lexically_proximate(__tmp_base); 1813 } 1814 1815 inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p, 1816 error_code& __ec) { 1817 return proximate(__p, current_path(), __ec); 1818 } 1819 1820 inline _LIBCPP_INLINE_VISIBILITY path 1821 proximate(const path& __p, const path& __base = current_path()) { 1822 return __weakly_canonical(__p).lexically_proximate( 1823 __weakly_canonical(__base)); 1824 } 1825 1826 inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p) { 1827 return __read_symlink(__p); 1828 } 1829 1830 inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p, 1831 error_code& __ec) { 1832 return __read_symlink(__p, &__ec); 1833 } 1834 1835 inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p, 1836 const path& __base, 1837 error_code& __ec) { 1838 path __tmp = __weakly_canonical(__p, &__ec); 1839 if (__ec) 1840 return path(); 1841 path __tmpbase = __weakly_canonical(__base, &__ec); 1842 if (__ec) 1843 return path(); 1844 return __tmp.lexically_relative(__tmpbase); 1845 } 1846 1847 inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p, 1848 error_code& __ec) { 1849 return relative(__p, current_path(), __ec); 1850 } 1851 1852 inline _LIBCPP_INLINE_VISIBILITY path 1853 relative(const path& __p, const path& __base = current_path()) { 1854 return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base)); 1855 } 1856 1857 inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p) { 1858 return __remove(__p); 1859 } 1860 1861 inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p, 1862 error_code& __ec) noexcept { 1863 return __remove(__p, &__ec); 1864 } 1865 1866 inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p) { 1867 return __remove_all(__p); 1868 } 1869 1870 inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p, 1871 error_code& __ec) { 1872 return __remove_all(__p, &__ec); 1873 } 1874 1875 inline _LIBCPP_INLINE_VISIBILITY void rename(const path& __from, 1876 const path& __to) { 1877 return __rename(__from, __to); 1878 } 1879 1880 inline _LIBCPP_INLINE_VISIBILITY void 1881 rename(const path& __from, const path& __to, error_code& __ec) noexcept { 1882 return __rename(__from, __to, &__ec); 1883 } 1884 1885 inline _LIBCPP_INLINE_VISIBILITY void resize_file(const path& __p, 1886 uintmax_t __ns) { 1887 return __resize_file(__p, __ns); 1888 } 1889 1890 inline _LIBCPP_INLINE_VISIBILITY void 1891 resize_file(const path& __p, uintmax_t __ns, error_code& __ec) noexcept { 1892 return __resize_file(__p, __ns, &__ec); 1893 } 1894 1895 inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p) { 1896 return __space(__p); 1897 } 1898 1899 inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p, 1900 error_code& __ec) noexcept { 1901 return __space(__p, &__ec); 1902 } 1903 1904 inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p) { 1905 return __status(__p); 1906 } 1907 1908 inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p, 1909 error_code& __ec) noexcept { 1910 return __status(__p, &__ec); 1911 } 1912 1913 inline _LIBCPP_INLINE_VISIBILITY file_status symlink_status(const path& __p) { 1914 return __symlink_status(__p); 1915 } 1916 1917 inline _LIBCPP_INLINE_VISIBILITY file_status 1918 symlink_status(const path& __p, error_code& __ec) noexcept { 1919 return __symlink_status(__p, &__ec); 1920 } 1921 1922 inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path() { 1923 return __temp_directory_path(); 1924 } 1925 1926 inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path(error_code& __ec) { 1927 return __temp_directory_path(&__ec); 1928 } 1929 1930 inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p) { 1931 return __weakly_canonical(__p); 1932 } 1933 1934 inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p, 1935 error_code& __ec) { 1936 return __weakly_canonical(__p, &__ec); 1937 } 1938 1939 class directory_iterator; 1940 class recursive_directory_iterator; 1941 class __dir_stream; 1942 1943 class directory_entry { 1944 typedef _VSTD_FS::path _Path; 1945 1946 public: 1947 // constructors and destructors 1948 directory_entry() noexcept = default; 1949 directory_entry(directory_entry const&) = default; 1950 directory_entry(directory_entry&&) noexcept = default; 1951 1952 _LIBCPP_INLINE_VISIBILITY 1953 explicit directory_entry(_Path const& __p) : __p_(__p) { 1954 error_code __ec; 1955 __refresh(&__ec); 1956 } 1957 1958 _LIBCPP_INLINE_VISIBILITY 1959 directory_entry(_Path const& __p, error_code& __ec) : __p_(__p) { 1960 __refresh(&__ec); 1961 } 1962 1963 ~directory_entry() {} 1964 1965 directory_entry& operator=(directory_entry const&) = default; 1966 directory_entry& operator=(directory_entry&&) noexcept = default; 1967 1968 _LIBCPP_INLINE_VISIBILITY 1969 void assign(_Path const& __p) { 1970 __p_ = __p; 1971 error_code __ec; 1972 __refresh(&__ec); 1973 } 1974 1975 _LIBCPP_INLINE_VISIBILITY 1976 void assign(_Path const& __p, error_code& __ec) { 1977 __p_ = __p; 1978 __refresh(&__ec); 1979 } 1980 1981 _LIBCPP_INLINE_VISIBILITY 1982 void replace_filename(_Path const& __p) { 1983 __p_.replace_filename(__p); 1984 error_code __ec; 1985 __refresh(&__ec); 1986 } 1987 1988 _LIBCPP_INLINE_VISIBILITY 1989 void replace_filename(_Path const& __p, error_code& __ec) { 1990 __p_ = __p_.parent_path() / __p; 1991 __refresh(&__ec); 1992 } 1993 1994 _LIBCPP_INLINE_VISIBILITY 1995 void refresh() { __refresh(); } 1996 1997 _LIBCPP_INLINE_VISIBILITY 1998 void refresh(error_code& __ec) noexcept { __refresh(&__ec); } 1999 2000 _LIBCPP_INLINE_VISIBILITY 2001 _Path const& path() const noexcept { return __p_; } 2002 2003 _LIBCPP_INLINE_VISIBILITY 2004 operator const _Path&() const noexcept { return __p_; } 2005 2006 _LIBCPP_INLINE_VISIBILITY 2007 bool exists() const { return _VSTD_FS::exists(file_status{__get_ft()}); } 2008 2009 _LIBCPP_INLINE_VISIBILITY 2010 bool exists(error_code& __ec) const noexcept { 2011 return _VSTD_FS::exists(file_status{__get_ft(&__ec)}); 2012 } 2013 2014 _LIBCPP_INLINE_VISIBILITY 2015 bool is_block_file() const { return __get_ft() == file_type::block; } 2016 2017 _LIBCPP_INLINE_VISIBILITY 2018 bool is_block_file(error_code& __ec) const noexcept { 2019 return __get_ft(&__ec) == file_type::block; 2020 } 2021 2022 _LIBCPP_INLINE_VISIBILITY 2023 bool is_character_file() const { return __get_ft() == file_type::character; } 2024 2025 _LIBCPP_INLINE_VISIBILITY 2026 bool is_character_file(error_code& __ec) const noexcept { 2027 return __get_ft(&__ec) == file_type::character; 2028 } 2029 2030 _LIBCPP_INLINE_VISIBILITY 2031 bool is_directory() const { return __get_ft() == file_type::directory; } 2032 2033 _LIBCPP_INLINE_VISIBILITY 2034 bool is_directory(error_code& __ec) const noexcept { 2035 return __get_ft(&__ec) == file_type::directory; 2036 } 2037 2038 _LIBCPP_INLINE_VISIBILITY 2039 bool is_fifo() const { return __get_ft() == file_type::fifo; } 2040 2041 _LIBCPP_INLINE_VISIBILITY 2042 bool is_fifo(error_code& __ec) const noexcept { 2043 return __get_ft(&__ec) == file_type::fifo; 2044 } 2045 2046 _LIBCPP_INLINE_VISIBILITY 2047 bool is_other() const { return _VSTD_FS::is_other(file_status{__get_ft()}); } 2048 2049 _LIBCPP_INLINE_VISIBILITY 2050 bool is_other(error_code& __ec) const noexcept { 2051 return _VSTD_FS::is_other(file_status{__get_ft(&__ec)}); 2052 } 2053 2054 _LIBCPP_INLINE_VISIBILITY 2055 bool is_regular_file() const { return __get_ft() == file_type::regular; } 2056 2057 _LIBCPP_INLINE_VISIBILITY 2058 bool is_regular_file(error_code& __ec) const noexcept { 2059 return __get_ft(&__ec) == file_type::regular; 2060 } 2061 2062 _LIBCPP_INLINE_VISIBILITY 2063 bool is_socket() const { return __get_ft() == file_type::socket; } 2064 2065 _LIBCPP_INLINE_VISIBILITY 2066 bool is_socket(error_code& __ec) const noexcept { 2067 return __get_ft(&__ec) == file_type::socket; 2068 } 2069 2070 _LIBCPP_INLINE_VISIBILITY 2071 bool is_symlink() const { return __get_sym_ft() == file_type::symlink; } 2072 2073 _LIBCPP_INLINE_VISIBILITY 2074 bool is_symlink(error_code& __ec) const noexcept { 2075 return __get_sym_ft(&__ec) == file_type::symlink; 2076 } 2077 _LIBCPP_INLINE_VISIBILITY 2078 uintmax_t file_size() const { return __get_size(); } 2079 2080 _LIBCPP_INLINE_VISIBILITY 2081 uintmax_t file_size(error_code& __ec) const noexcept { 2082 return __get_size(&__ec); 2083 } 2084 2085 _LIBCPP_INLINE_VISIBILITY 2086 uintmax_t hard_link_count() const { return __get_nlink(); } 2087 2088 _LIBCPP_INLINE_VISIBILITY 2089 uintmax_t hard_link_count(error_code& __ec) const noexcept { 2090 return __get_nlink(&__ec); 2091 } 2092 2093 _LIBCPP_INLINE_VISIBILITY 2094 file_time_type last_write_time() const { return __get_write_time(); } 2095 2096 _LIBCPP_INLINE_VISIBILITY 2097 file_time_type last_write_time(error_code& __ec) const noexcept { 2098 return __get_write_time(&__ec); 2099 } 2100 2101 _LIBCPP_INLINE_VISIBILITY 2102 file_status status() const { return __get_status(); } 2103 2104 _LIBCPP_INLINE_VISIBILITY 2105 file_status status(error_code& __ec) const noexcept { 2106 return __get_status(&__ec); 2107 } 2108 2109 _LIBCPP_INLINE_VISIBILITY 2110 file_status symlink_status() const { return __get_symlink_status(); } 2111 2112 _LIBCPP_INLINE_VISIBILITY 2113 file_status symlink_status(error_code& __ec) const noexcept { 2114 return __get_symlink_status(&__ec); 2115 } 2116 2117 _LIBCPP_INLINE_VISIBILITY 2118 bool operator<(directory_entry const& __rhs) const noexcept { 2119 return __p_ < __rhs.__p_; 2120 } 2121 2122 _LIBCPP_INLINE_VISIBILITY 2123 bool operator==(directory_entry const& __rhs) const noexcept { 2124 return __p_ == __rhs.__p_; 2125 } 2126 2127 _LIBCPP_INLINE_VISIBILITY 2128 bool operator!=(directory_entry const& __rhs) const noexcept { 2129 return __p_ != __rhs.__p_; 2130 } 2131 2132 _LIBCPP_INLINE_VISIBILITY 2133 bool operator<=(directory_entry const& __rhs) const noexcept { 2134 return __p_ <= __rhs.__p_; 2135 } 2136 2137 _LIBCPP_INLINE_VISIBILITY 2138 bool operator>(directory_entry const& __rhs) const noexcept { 2139 return __p_ > __rhs.__p_; 2140 } 2141 2142 _LIBCPP_INLINE_VISIBILITY 2143 bool operator>=(directory_entry const& __rhs) const noexcept { 2144 return __p_ >= __rhs.__p_; 2145 } 2146 2147 private: 2148 friend class directory_iterator; 2149 friend class recursive_directory_iterator; 2150 friend class __dir_stream; 2151 2152 enum _CacheType : unsigned char { 2153 _Empty, 2154 _IterSymlink, 2155 _IterNonSymlink, 2156 _RefreshSymlink, 2157 _RefreshSymlinkUnresolved, 2158 _RefreshNonSymlink 2159 }; 2160 2161 struct __cached_data { 2162 uintmax_t __size_; 2163 uintmax_t __nlink_; 2164 file_time_type __write_time_; 2165 perms __sym_perms_; 2166 perms __non_sym_perms_; 2167 file_type __type_; 2168 _CacheType __cache_type_; 2169 2170 _LIBCPP_INLINE_VISIBILITY 2171 __cached_data() noexcept { __reset(); } 2172 2173 _LIBCPP_INLINE_VISIBILITY 2174 void __reset() { 2175 __cache_type_ = _Empty; 2176 __type_ = file_type::none; 2177 __sym_perms_ = __non_sym_perms_ = perms::unknown; 2178 __size_ = __nlink_ = uintmax_t(-1); 2179 __write_time_ = file_time_type::min(); 2180 } 2181 }; 2182 2183 _LIBCPP_INLINE_VISIBILITY 2184 static __cached_data __create_iter_result(file_type __ft) { 2185 __cached_data __data; 2186 __data.__type_ = __ft; 2187 __data.__cache_type_ = [&]() { 2188 switch (__ft) { 2189 case file_type::none: 2190 return _Empty; 2191 case file_type::symlink: 2192 return _IterSymlink; 2193 default: 2194 return _IterNonSymlink; 2195 } 2196 }(); 2197 return __data; 2198 } 2199 2200 _LIBCPP_INLINE_VISIBILITY 2201 void __assign_iter_entry(_Path&& __p, __cached_data __dt) { 2202 __p_ = std::move(__p); 2203 __data_ = __dt; 2204 } 2205 2206 _LIBCPP_FUNC_VIS 2207 error_code __do_refresh() noexcept; 2208 2209 _LIBCPP_INLINE_VISIBILITY 2210 static bool __is_dne_error(error_code const& __ec) { 2211 if (!__ec) 2212 return true; 2213 switch (static_cast<errc>(__ec.value())) { 2214 case errc::no_such_file_or_directory: 2215 case errc::not_a_directory: 2216 return true; 2217 default: 2218 return false; 2219 } 2220 } 2221 2222 _LIBCPP_INLINE_VISIBILITY 2223 void __handle_error(const char* __msg, error_code* __dest_ec, 2224 error_code const& __ec, bool __allow_dne = false) const { 2225 if (__dest_ec) { 2226 *__dest_ec = __ec; 2227 return; 2228 } 2229 if (__ec && (!__allow_dne || !__is_dne_error(__ec))) 2230 __throw_filesystem_error(__msg, __p_, __ec); 2231 } 2232 2233 _LIBCPP_INLINE_VISIBILITY 2234 void __refresh(error_code* __ec = nullptr) { 2235 __handle_error("in directory_entry::refresh", __ec, __do_refresh(), 2236 /*allow_dne*/ true); 2237 } 2238 2239 _LIBCPP_INLINE_VISIBILITY 2240 file_type __get_sym_ft(error_code* __ec = nullptr) const { 2241 switch (__data_.__cache_type_) { 2242 case _Empty: 2243 return __symlink_status(__p_, __ec).type(); 2244 case _IterSymlink: 2245 case _RefreshSymlink: 2246 case _RefreshSymlinkUnresolved: 2247 if (__ec) 2248 __ec->clear(); 2249 return file_type::symlink; 2250 case _IterNonSymlink: 2251 case _RefreshNonSymlink: 2252 file_status __st(__data_.__type_); 2253 if (__ec && !_VSTD_FS::exists(__st)) 2254 *__ec = make_error_code(errc::no_such_file_or_directory); 2255 else if (__ec) 2256 __ec->clear(); 2257 return __data_.__type_; 2258 } 2259 _LIBCPP_UNREACHABLE(); 2260 } 2261 2262 _LIBCPP_INLINE_VISIBILITY 2263 file_type __get_ft(error_code* __ec = nullptr) const { 2264 switch (__data_.__cache_type_) { 2265 case _Empty: 2266 case _IterSymlink: 2267 case _RefreshSymlinkUnresolved: 2268 return __status(__p_, __ec).type(); 2269 case _IterNonSymlink: 2270 case _RefreshNonSymlink: 2271 case _RefreshSymlink: { 2272 file_status __st(__data_.__type_); 2273 if (__ec && !_VSTD_FS::exists(__st)) 2274 *__ec = make_error_code(errc::no_such_file_or_directory); 2275 else if (__ec) 2276 __ec->clear(); 2277 return __data_.__type_; 2278 } 2279 } 2280 _LIBCPP_UNREACHABLE(); 2281 } 2282 2283 _LIBCPP_INLINE_VISIBILITY 2284 file_status __get_status(error_code* __ec = nullptr) const { 2285 switch (__data_.__cache_type_) { 2286 case _Empty: 2287 case _IterNonSymlink: 2288 case _IterSymlink: 2289 case _RefreshSymlinkUnresolved: 2290 return __status(__p_, __ec); 2291 case _RefreshNonSymlink: 2292 case _RefreshSymlink: 2293 return file_status(__get_ft(__ec), __data_.__non_sym_perms_); 2294 } 2295 _LIBCPP_UNREACHABLE(); 2296 } 2297 2298 _LIBCPP_INLINE_VISIBILITY 2299 file_status __get_symlink_status(error_code* __ec = nullptr) const { 2300 switch (__data_.__cache_type_) { 2301 case _Empty: 2302 case _IterNonSymlink: 2303 case _IterSymlink: 2304 return __symlink_status(__p_, __ec); 2305 case _RefreshNonSymlink: 2306 return file_status(__get_sym_ft(__ec), __data_.__non_sym_perms_); 2307 case _RefreshSymlink: 2308 case _RefreshSymlinkUnresolved: 2309 return file_status(__get_sym_ft(__ec), __data_.__sym_perms_); 2310 } 2311 _LIBCPP_UNREACHABLE(); 2312 } 2313 2314 _LIBCPP_INLINE_VISIBILITY 2315 uintmax_t __get_size(error_code* __ec = nullptr) const { 2316 switch (__data_.__cache_type_) { 2317 case _Empty: 2318 case _IterNonSymlink: 2319 case _IterSymlink: 2320 case _RefreshSymlinkUnresolved: 2321 return _VSTD_FS::__file_size(__p_, __ec); 2322 case _RefreshSymlink: 2323 case _RefreshNonSymlink: { 2324 error_code __m_ec; 2325 file_status __st(__get_ft(&__m_ec)); 2326 __handle_error("in directory_entry::file_size", __ec, __m_ec); 2327 if (_VSTD_FS::exists(__st) && !_VSTD_FS::is_regular_file(__st)) { 2328 errc __err_kind = _VSTD_FS::is_directory(__st) ? errc::is_a_directory 2329 : errc::not_supported; 2330 __handle_error("in directory_entry::file_size", __ec, 2331 make_error_code(__err_kind)); 2332 } 2333 return __data_.__size_; 2334 } 2335 } 2336 _LIBCPP_UNREACHABLE(); 2337 } 2338 2339 _LIBCPP_INLINE_VISIBILITY 2340 uintmax_t __get_nlink(error_code* __ec = nullptr) const { 2341 switch (__data_.__cache_type_) { 2342 case _Empty: 2343 case _IterNonSymlink: 2344 case _IterSymlink: 2345 case _RefreshSymlinkUnresolved: 2346 return _VSTD_FS::__hard_link_count(__p_, __ec); 2347 case _RefreshSymlink: 2348 case _RefreshNonSymlink: { 2349 error_code __m_ec; 2350 (void)__get_ft(&__m_ec); 2351 __handle_error("in directory_entry::hard_link_count", __ec, __m_ec); 2352 return __data_.__nlink_; 2353 } 2354 } 2355 _LIBCPP_UNREACHABLE(); 2356 } 2357 2358 _LIBCPP_INLINE_VISIBILITY 2359 file_time_type __get_write_time(error_code* __ec = nullptr) const { 2360 switch (__data_.__cache_type_) { 2361 case _Empty: 2362 case _IterNonSymlink: 2363 case _IterSymlink: 2364 case _RefreshSymlinkUnresolved: 2365 return _VSTD_FS::__last_write_time(__p_, __ec); 2366 case _RefreshSymlink: 2367 case _RefreshNonSymlink: { 2368 error_code __m_ec; 2369 file_status __st(__get_ft(&__m_ec)); 2370 __handle_error("in directory_entry::last_write_time", __ec, __m_ec); 2371 if (_VSTD_FS::exists(__st) && 2372 __data_.__write_time_ == file_time_type::min()) 2373 __handle_error("in directory_entry::last_write_time", __ec, 2374 make_error_code(errc::value_too_large)); 2375 return __data_.__write_time_; 2376 } 2377 } 2378 _LIBCPP_UNREACHABLE(); 2379 } 2380 2381 private: 2382 _Path __p_; 2383 __cached_data __data_; 2384 }; 2385 2386 class __dir_element_proxy { 2387 public: 2388 inline _LIBCPP_INLINE_VISIBILITY directory_entry operator*() { 2389 return _VSTD::move(__elem_); 2390 } 2391 2392 private: 2393 friend class directory_iterator; 2394 friend class recursive_directory_iterator; 2395 explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {} 2396 __dir_element_proxy(__dir_element_proxy&& __o) 2397 : __elem_(_VSTD::move(__o.__elem_)) {} 2398 directory_entry __elem_; 2399 }; 2400 2401 class directory_iterator { 2402 public: 2403 typedef directory_entry value_type; 2404 typedef ptrdiff_t difference_type; 2405 typedef value_type const* pointer; 2406 typedef value_type const& reference; 2407 typedef input_iterator_tag iterator_category; 2408 2409 public: 2410 //ctor & dtor 2411 directory_iterator() noexcept {} 2412 2413 explicit directory_iterator(const path& __p) 2414 : directory_iterator(__p, nullptr) {} 2415 2416 directory_iterator(const path& __p, directory_options __opts) 2417 : directory_iterator(__p, nullptr, __opts) {} 2418 2419 directory_iterator(const path& __p, error_code& __ec) 2420 : directory_iterator(__p, &__ec) {} 2421 2422 directory_iterator(const path& __p, directory_options __opts, 2423 error_code& __ec) 2424 : directory_iterator(__p, &__ec, __opts) {} 2425 2426 directory_iterator(const directory_iterator&) = default; 2427 directory_iterator(directory_iterator&&) = default; 2428 directory_iterator& operator=(const directory_iterator&) = default; 2429 2430 directory_iterator& operator=(directory_iterator&& __o) noexcept { 2431 // non-default implementation provided to support self-move assign. 2432 if (this != &__o) { 2433 __imp_ = _VSTD::move(__o.__imp_); 2434 } 2435 return *this; 2436 } 2437 2438 ~directory_iterator() = default; 2439 2440 const directory_entry& operator*() const { 2441 _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced"); 2442 return __dereference(); 2443 } 2444 2445 const directory_entry* operator->() const { return &**this; } 2446 2447 directory_iterator& operator++() { return __increment(); } 2448 2449 __dir_element_proxy operator++(int) { 2450 __dir_element_proxy __p(**this); 2451 __increment(); 2452 return __p; 2453 } 2454 2455 directory_iterator& increment(error_code& __ec) { return __increment(&__ec); } 2456 2457 private: 2458 inline _LIBCPP_INLINE_VISIBILITY friend bool 2459 operator==(const directory_iterator& __lhs, 2460 const directory_iterator& __rhs) noexcept; 2461 2462 // construct the dir_stream 2463 _LIBCPP_FUNC_VIS 2464 directory_iterator(const path&, error_code*, 2465 directory_options = directory_options::none); 2466 2467 _LIBCPP_FUNC_VIS 2468 directory_iterator& __increment(error_code* __ec = nullptr); 2469 2470 _LIBCPP_FUNC_VIS 2471 const directory_entry& __dereference() const; 2472 2473 private: 2474 shared_ptr<__dir_stream> __imp_; 2475 }; 2476 2477 inline _LIBCPP_INLINE_VISIBILITY bool 2478 operator==(const directory_iterator& __lhs, 2479 const directory_iterator& __rhs) noexcept { 2480 return __lhs.__imp_ == __rhs.__imp_; 2481 } 2482 2483 inline _LIBCPP_INLINE_VISIBILITY bool 2484 operator!=(const directory_iterator& __lhs, 2485 const directory_iterator& __rhs) noexcept { 2486 return !(__lhs == __rhs); 2487 } 2488 2489 // enable directory_iterator range-based for statements 2490 inline _LIBCPP_INLINE_VISIBILITY directory_iterator 2491 begin(directory_iterator __iter) noexcept { 2492 return __iter; 2493 } 2494 2495 inline _LIBCPP_INLINE_VISIBILITY directory_iterator 2496 end(const directory_iterator&) noexcept { 2497 return directory_iterator(); 2498 } 2499 2500 class recursive_directory_iterator { 2501 public: 2502 using value_type = directory_entry; 2503 using difference_type = std::ptrdiff_t; 2504 using pointer = directory_entry const*; 2505 using reference = directory_entry const&; 2506 using iterator_category = std::input_iterator_tag; 2507 2508 public: 2509 // constructors and destructor 2510 _LIBCPP_INLINE_VISIBILITY 2511 recursive_directory_iterator() noexcept : __rec_(false) {} 2512 2513 _LIBCPP_INLINE_VISIBILITY 2514 explicit recursive_directory_iterator( 2515 const path& __p, directory_options __xoptions = directory_options::none) 2516 : recursive_directory_iterator(__p, __xoptions, nullptr) {} 2517 2518 _LIBCPP_INLINE_VISIBILITY 2519 recursive_directory_iterator(const path& __p, directory_options __xoptions, 2520 error_code& __ec) 2521 : recursive_directory_iterator(__p, __xoptions, &__ec) {} 2522 2523 _LIBCPP_INLINE_VISIBILITY 2524 recursive_directory_iterator(const path& __p, error_code& __ec) 2525 : recursive_directory_iterator(__p, directory_options::none, &__ec) {} 2526 2527 recursive_directory_iterator(const recursive_directory_iterator&) = default; 2528 recursive_directory_iterator(recursive_directory_iterator&&) = default; 2529 2530 recursive_directory_iterator& 2531 operator=(const recursive_directory_iterator&) = default; 2532 2533 _LIBCPP_INLINE_VISIBILITY 2534 recursive_directory_iterator& 2535 operator=(recursive_directory_iterator&& __o) noexcept { 2536 // non-default implementation provided to support self-move assign. 2537 if (this != &__o) { 2538 __imp_ = _VSTD::move(__o.__imp_); 2539 __rec_ = __o.__rec_; 2540 } 2541 return *this; 2542 } 2543 2544 ~recursive_directory_iterator() = default; 2545 2546 _LIBCPP_INLINE_VISIBILITY 2547 const directory_entry& operator*() const { return __dereference(); } 2548 2549 _LIBCPP_INLINE_VISIBILITY 2550 const directory_entry* operator->() const { return &__dereference(); } 2551 2552 recursive_directory_iterator& operator++() { return __increment(); } 2553 2554 _LIBCPP_INLINE_VISIBILITY 2555 __dir_element_proxy operator++(int) { 2556 __dir_element_proxy __p(**this); 2557 __increment(); 2558 return __p; 2559 } 2560 2561 _LIBCPP_INLINE_VISIBILITY 2562 recursive_directory_iterator& increment(error_code& __ec) { 2563 return __increment(&__ec); 2564 } 2565 2566 _LIBCPP_FUNC_VIS directory_options options() const; 2567 _LIBCPP_FUNC_VIS int depth() const; 2568 2569 _LIBCPP_INLINE_VISIBILITY 2570 void pop() { __pop(); } 2571 2572 _LIBCPP_INLINE_VISIBILITY 2573 void pop(error_code& __ec) { __pop(&__ec); } 2574 2575 _LIBCPP_INLINE_VISIBILITY 2576 bool recursion_pending() const { return __rec_; } 2577 2578 _LIBCPP_INLINE_VISIBILITY 2579 void disable_recursion_pending() { __rec_ = false; } 2580 2581 private: 2582 recursive_directory_iterator(const path& __p, directory_options __opt, 2583 error_code* __ec); 2584 2585 _LIBCPP_FUNC_VIS 2586 const directory_entry& __dereference() const; 2587 2588 _LIBCPP_FUNC_VIS 2589 bool __try_recursion(error_code* __ec); 2590 2591 _LIBCPP_FUNC_VIS 2592 void __advance(error_code* __ec = nullptr); 2593 2594 _LIBCPP_FUNC_VIS 2595 recursive_directory_iterator& __increment(error_code* __ec = nullptr); 2596 2597 _LIBCPP_FUNC_VIS 2598 void __pop(error_code* __ec = nullptr); 2599 2600 inline _LIBCPP_INLINE_VISIBILITY friend bool 2601 operator==(const recursive_directory_iterator&, 2602 const recursive_directory_iterator&) noexcept; 2603 2604 struct __shared_imp; 2605 shared_ptr<__shared_imp> __imp_; 2606 bool __rec_; 2607 }; // class recursive_directory_iterator 2608 2609 inline _LIBCPP_INLINE_VISIBILITY bool 2610 operator==(const recursive_directory_iterator& __lhs, 2611 const recursive_directory_iterator& __rhs) noexcept { 2612 return __lhs.__imp_ == __rhs.__imp_; 2613 } 2614 2615 _LIBCPP_INLINE_VISIBILITY 2616 inline bool operator!=(const recursive_directory_iterator& __lhs, 2617 const recursive_directory_iterator& __rhs) noexcept { 2618 return !(__lhs == __rhs); 2619 } 2620 // enable recursive_directory_iterator range-based for statements 2621 inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator 2622 begin(recursive_directory_iterator __iter) noexcept { 2623 return __iter; 2624 } 2625 2626 inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator 2627 end(const recursive_directory_iterator&) noexcept { 2628 return recursive_directory_iterator(); 2629 } 2630 2631 _LIBCPP_END_NAMESPACE_FILESYSTEM 2632 2633 #endif // !_LIBCPP_CXX03_LANG 2634 2635 _LIBCPP_POP_MACROS 2636 2637 #endif // _LIBCPP_FILESYSTEM 2638
