contrib/llvm-project/libcxx/include/filesystem

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