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