contrib/libc++/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_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_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_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() override; // key function
1350
1351   _LIBCPP_INLINE_VISIBILITY
1352   const char* what() const noexcept override {
1353     return __storage_->__what_.c_str();
1354   }
1355
1356   void __create_what(int __num_paths);
1357
1358 private:
1359   struct _LIBCPP_HIDDEN _Storage {
1360     _LIBCPP_INLINE_VISIBILITY
1361     _Storage(const path& __p1, const path& __p2) : __p1_(__p1), __p2_(__p2) {}
1362
1363     path __p1_;
1364     path __p2_;
1365     string __what_;
1366   };
1367   shared_ptr<_Storage> __storage_;
1368 };
1369
1370 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
1371
1372 template <class... _Args>
1373 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
1374 #ifndef _LIBCPP_NO_EXCEPTIONS
1375 void __throw_filesystem_error(_Args&&... __args) {
1376   throw filesystem_error(std::forward<_Args>(__args)...);
1377 }
1378 #else
1379 void __throw_filesystem_error(_Args&&...) {
1380   _VSTD::abort();
1381 }
1382 #endif
1383
1384 // operational functions
1385
1386 _LIBCPP_FUNC_VIS
1387 path __absolute(const path&, error_code* __ec = nullptr);
1388 _LIBCPP_FUNC_VIS
1389 path __canonical(const path&, error_code* __ec = nullptr);
1390 _LIBCPP_FUNC_VIS
1391 void __copy(const path& __from, const path& __to, copy_options __opt,
1392             error_code* __ec = nullptr);
1393 _LIBCPP_FUNC_VIS
1394 bool __copy_file(const path& __from, const path& __to, copy_options __opt,
1395                  error_code* __ec = nullptr);
1396 _LIBCPP_FUNC_VIS
1397 void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
1398                     error_code* __ec = nullptr);
1399 _LIBCPP_FUNC_VIS
1400 bool __create_directories(const path& p, error_code* ec = nullptr);
1401 _LIBCPP_FUNC_VIS
1402 bool __create_directory(const path& p, error_code* ec = nullptr);
1403 _LIBCPP_FUNC_VIS
1404 bool __create_directory(const path& p, const path& attributes,
1405                         error_code* ec = nullptr);
1406 _LIBCPP_FUNC_VIS
1407 void __create_directory_symlink(const path& __to, const path& __new_symlink,
1408                                 error_code* __ec = nullptr);
1409 _LIBCPP_FUNC_VIS
1410 void __create_hard_link(const path& __to, const path& __new_hard_link,
1411                         error_code* __ec = nullptr);
1412 _LIBCPP_FUNC_VIS
1413 void __create_symlink(const path& __to, const path& __new_symlink,
1414                       error_code* __ec = nullptr);
1415 _LIBCPP_FUNC_VIS
1416 path __current_path(error_code* __ec = nullptr);
1417 _LIBCPP_FUNC_VIS
1418 void __current_path(const path&, error_code* __ec = nullptr);
1419 _LIBCPP_FUNC_VIS
1420 bool __equivalent(const path&, const path&, error_code* __ec = nullptr);
1421 _LIBCPP_FUNC_VIS
1422 uintmax_t __file_size(const path&, error_code* __ec = nullptr);
1423 _LIBCPP_FUNC_VIS
1424 uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr);
1425 _LIBCPP_FUNC_VIS
1426 bool __fs_is_empty(const path& p, error_code* ec = nullptr);
1427 _LIBCPP_FUNC_VIS
1428 file_time_type __last_write_time(const path& p, error_code* ec = nullptr);
1429 _LIBCPP_FUNC_VIS
1430 void __last_write_time(const path& p, file_time_type new_time,
1431                        error_code* ec = nullptr);
1432 _LIBCPP_FUNC_VIS
1433 void __permissions(const path&, perms, perm_options, error_code* = nullptr);
1434 _LIBCPP_FUNC_VIS
1435 path __read_symlink(const path& p, error_code* ec = nullptr);
1436 _LIBCPP_FUNC_VIS
1437 bool __remove(const path& p, error_code* ec = nullptr);
1438 _LIBCPP_FUNC_VIS
1439 uintmax_t __remove_all(const path& p, error_code* ec = nullptr);
1440 _LIBCPP_FUNC_VIS
1441 void __rename(const path& from, const path& to, error_code* ec = nullptr);
1442 _LIBCPP_FUNC_VIS
1443 void __resize_file(const path& p, uintmax_t size, error_code* ec = nullptr);
1444 _LIBCPP_FUNC_VIS
1445 space_info __space(const path&, error_code* __ec = nullptr);
1446 _LIBCPP_FUNC_VIS
1447 file_status __status(const path&, error_code* __ec = nullptr);
1448 _LIBCPP_FUNC_VIS
1449 file_status __symlink_status(const path&, error_code* __ec = nullptr);
1450 _LIBCPP_FUNC_VIS
1451 path __system_complete(const path&, error_code* __ec = nullptr);
1452 _LIBCPP_FUNC_VIS
1453 path __temp_directory_path(error_code* __ec = nullptr);
1454 _LIBCPP_FUNC_VIS
1455 path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
1456
1457 inline _LIBCPP_INLINE_VISIBILITY path current_path() {
1458   return __current_path();
1459 }
1460
1461 inline _LIBCPP_INLINE_VISIBILITY path current_path(error_code& __ec) {
1462   return __current_path(&__ec);
1463 }
1464
1465 inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p) {
1466   __current_path(__p);
1467 }
1468
1469 inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p,
1470                                                    error_code& __ec) noexcept {
1471   __current_path(__p, &__ec);
1472 }
1473
1474 inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p) {
1475   return __absolute(__p);
1476 }
1477
1478 inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p,
1479                                                error_code& __ec) {
1480   return __absolute(__p, &__ec);
1481 }
1482
1483 inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p) {
1484   return __canonical(__p);
1485 }
1486
1487 inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p,
1488                                                 error_code& __ec) {
1489   return __canonical(__p, &__ec);
1490 }
1491
1492 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from,
1493                                            const path& __to) {
1494   __copy(__from, __to, copy_options::none);
1495 }
1496
1497 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
1498                                            error_code& __ec) {
1499   __copy(__from, __to, copy_options::none, &__ec);
1500 }
1501
1502 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
1503                                            copy_options __opt) {
1504   __copy(__from, __to, __opt);
1505 }
1506
1507 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
1508                                            copy_options __opt,
1509                                            error_code& __ec) {
1510   __copy(__from, __to, __opt, &__ec);
1511 }
1512
1513 inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
1514                                                 const path& __to) {
1515   return __copy_file(__from, __to, copy_options::none);
1516 }
1517
1518 inline _LIBCPP_INLINE_VISIBILITY bool
1519 copy_file(const path& __from, const path& __to, error_code& __ec) {
1520   return __copy_file(__from, __to, copy_options::none, &__ec);
1521 }
1522
1523 inline _LIBCPP_INLINE_VISIBILITY bool
1524 copy_file(const path& __from, const path& __to, copy_options __opt) {
1525   return __copy_file(__from, __to, __opt);
1526 }
1527
1528 inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
1529                                                 const path& __to,
1530                                                 copy_options __opt,
1531                                                 error_code& __ec) {
1532   return __copy_file(__from, __to, __opt, &__ec);
1533 }
1534
1535 inline _LIBCPP_INLINE_VISIBILITY void copy_symlink(const path& __existing,
1536                                                    const path& __new) {
1537   __copy_symlink(__existing, __new);
1538 }
1539
1540 inline _LIBCPP_INLINE_VISIBILITY void
1541 copy_symlink(const path& __ext, const path& __new, error_code& __ec) noexcept {
1542   __copy_symlink(__ext, __new, &__ec);
1543 }
1544
1545 inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p) {
1546   return __create_directories(__p);
1547 }
1548
1549 inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p,
1550                                                          error_code& __ec) {
1551   return __create_directories(__p, &__ec);
1552 }
1553
1554 inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p) {
1555   return __create_directory(__p);
1556 }
1557
1558 inline _LIBCPP_INLINE_VISIBILITY bool
1559 create_directory(const path& __p, error_code& __ec) noexcept {
1560   return __create_directory(__p, &__ec);
1561 }
1562
1563 inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p,
1564                                                        const path& __attrs) {
1565   return __create_directory(__p, __attrs);
1566 }
1567
1568 inline _LIBCPP_INLINE_VISIBILITY bool
1569 create_directory(const path& __p, const path& __attrs,
1570                  error_code& __ec) noexcept {
1571   return __create_directory(__p, __attrs, &__ec);
1572 }
1573
1574 inline _LIBCPP_INLINE_VISIBILITY void
1575 create_directory_symlink(const path& __to, const path& __new) {
1576   __create_directory_symlink(__to, __new);
1577 }
1578
1579 inline _LIBCPP_INLINE_VISIBILITY void
1580 create_directory_symlink(const path& __to, const path& __new,
1581                          error_code& __ec) noexcept {
1582   __create_directory_symlink(__to, __new, &__ec);
1583 }
1584
1585 inline _LIBCPP_INLINE_VISIBILITY void create_hard_link(const path& __to,
1586                                                        const path& __new) {
1587   __create_hard_link(__to, __new);
1588 }
1589
1590 inline _LIBCPP_INLINE_VISIBILITY void
1591 create_hard_link(const path& __to, const path& __new,
1592                  error_code& __ec) noexcept {
1593   __create_hard_link(__to, __new, &__ec);
1594 }
1595
1596 inline _LIBCPP_INLINE_VISIBILITY void create_symlink(const path& __to,
1597                                                      const path& __new) {
1598   __create_symlink(__to, __new);
1599 }
1600
1601 inline _LIBCPP_INLINE_VISIBILITY void
1602 create_symlink(const path& __to, const path& __new, error_code& __ec) noexcept {
1603   return __create_symlink(__to, __new, &__ec);
1604 }
1605
1606 inline _LIBCPP_INLINE_VISIBILITY bool status_known(file_status __s) noexcept {
1607   return __s.type() != file_type::none;
1608 }
1609
1610 inline _LIBCPP_INLINE_VISIBILITY bool exists(file_status __s) noexcept {
1611   return status_known(__s) && __s.type() != file_type::not_found;
1612 }
1613
1614 inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p) {
1615   return exists(__status(__p));
1616 }
1617
1618 inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p,
1619                                              error_code& __ec) noexcept {
1620   auto __s = __status(__p, &__ec);
1621   if (status_known(__s))
1622     __ec.clear();
1623   return exists(__s);
1624 }
1625
1626 inline _LIBCPP_INLINE_VISIBILITY bool equivalent(const path& __p1,
1627                                                  const path& __p2) {
1628   return __equivalent(__p1, __p2);
1629 }
1630
1631 inline _LIBCPP_INLINE_VISIBILITY bool
1632 equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept {
1633   return __equivalent(__p1, __p2, &__ec);
1634 }
1635
1636 inline _LIBCPP_INLINE_VISIBILITY uintmax_t file_size(const path& __p) {
1637   return __file_size(__p);
1638 }
1639
1640 inline _LIBCPP_INLINE_VISIBILITY uintmax_t
1641 file_size(const path& __p, error_code& __ec) noexcept {
1642   return __file_size(__p, &__ec);
1643 }
1644
1645 inline _LIBCPP_INLINE_VISIBILITY uintmax_t hard_link_count(const path& __p) {
1646   return __hard_link_count(__p);
1647 }
1648
1649 inline _LIBCPP_INLINE_VISIBILITY uintmax_t
1650 hard_link_count(const path& __p, error_code& __ec) noexcept {
1651   return __hard_link_count(__p, &__ec);
1652 }
1653
1654 inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(file_status __s) noexcept {
1655   return __s.type() == file_type::block;
1656 }
1657
1658 inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p) {
1659   return is_block_file(__status(__p));
1660 }
1661
1662 inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p,
1663                                                     error_code& __ec) noexcept {
1664   return is_block_file(__status(__p, &__ec));
1665 }
1666
1667 inline _LIBCPP_INLINE_VISIBILITY bool
1668 is_character_file(file_status __s) noexcept {
1669   return __s.type() == file_type::character;
1670 }
1671
1672 inline _LIBCPP_INLINE_VISIBILITY bool is_character_file(const path& __p) {
1673   return is_character_file(__status(__p));
1674 }
1675
1676 inline _LIBCPP_INLINE_VISIBILITY bool
1677 is_character_file(const path& __p, error_code& __ec) noexcept {
1678   return is_character_file(__status(__p, &__ec));
1679 }
1680
1681 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(file_status __s) noexcept {
1682   return __s.type() == file_type::directory;
1683 }
1684
1685 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p) {
1686   return is_directory(__status(__p));
1687 }
1688
1689 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p,
1690                                                    error_code& __ec) noexcept {
1691   return is_directory(__status(__p, &__ec));
1692 }
1693
1694 inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p) {
1695   return __fs_is_empty(__p);
1696 }
1697
1698 inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p,
1699                                                error_code& __ec) {
1700   return __fs_is_empty(__p, &__ec);
1701 }
1702
1703 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(file_status __s) noexcept {
1704   return __s.type() == file_type::fifo;
1705 }
1706 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p) {
1707   return is_fifo(__status(__p));
1708 }
1709
1710 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p,
1711                                               error_code& __ec) noexcept {
1712   return is_fifo(__status(__p, &__ec));
1713 }
1714
1715 inline _LIBCPP_INLINE_VISIBILITY bool
1716 is_regular_file(file_status __s) noexcept {
1717   return __s.type() == file_type::regular;
1718 }
1719
1720 inline _LIBCPP_INLINE_VISIBILITY bool is_regular_file(const path& __p) {
1721   return is_regular_file(__status(__p));
1722 }
1723
1724 inline _LIBCPP_INLINE_VISIBILITY bool
1725 is_regular_file(const path& __p, error_code& __ec) noexcept {
1726   return is_regular_file(__status(__p, &__ec));
1727 }
1728
1729 inline _LIBCPP_INLINE_VISIBILITY bool is_socket(file_status __s) noexcept {
1730   return __s.type() == file_type::socket;
1731 }
1732
1733 inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p) {
1734   return is_socket(__status(__p));
1735 }
1736
1737 inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p,
1738                                                 error_code& __ec) noexcept {
1739   return is_socket(__status(__p, &__ec));
1740 }
1741
1742 inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(file_status __s) noexcept {
1743   return __s.type() == file_type::symlink;
1744 }
1745
1746 inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p) {
1747   return is_symlink(__symlink_status(__p));
1748 }
1749
1750 inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p,
1751                                                  error_code& __ec) noexcept {
1752   return is_symlink(__symlink_status(__p, &__ec));
1753 }
1754
1755 inline _LIBCPP_INLINE_VISIBILITY bool is_other(file_status __s) noexcept {
1756   return exists(__s) && !is_regular_file(__s) && !is_directory(__s) &&
1757          !is_symlink(__s);
1758 }
1759
1760 inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p) {
1761   return is_other(__status(__p));
1762 }
1763
1764 inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p,
1765                                                error_code& __ec) noexcept {
1766   return is_other(__status(__p, &__ec));
1767 }
1768
1769 inline _LIBCPP_INLINE_VISIBILITY file_time_type
1770 last_write_time(const path& __p) {
1771   return __last_write_time(__p);
1772 }
1773
1774 inline _LIBCPP_INLINE_VISIBILITY file_time_type
1775 last_write_time(const path& __p, error_code& __ec) noexcept {
1776   return __last_write_time(__p, &__ec);
1777 }
1778
1779 inline _LIBCPP_INLINE_VISIBILITY void last_write_time(const path& __p,
1780                                                       file_time_type __t) {
1781   __last_write_time(__p, __t);
1782 }
1783
1784 inline _LIBCPP_INLINE_VISIBILITY void
1785 last_write_time(const path& __p, file_time_type __t,
1786                 error_code& __ec) noexcept {
1787   __last_write_time(__p, __t, &__ec);
1788 }
1789
1790 inline _LIBCPP_INLINE_VISIBILITY void
1791 permissions(const path& __p, perms __prms,
1792             perm_options __opts = perm_options::replace) {
1793   __permissions(__p, __prms, __opts);
1794 }
1795
1796 inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
1797                                                   error_code& __ec) noexcept {
1798   __permissions(__p, __prms, perm_options::replace, &__ec);
1799 }
1800
1801 inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
1802                                                   perm_options __opts,
1803                                                   error_code& __ec) {
1804   __permissions(__p, __prms, __opts, &__ec);
1805 }
1806
1807 inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
1808                                                 const path& __base,
1809                                                 error_code& __ec) {
1810   path __tmp = __weakly_canonical(__p, &__ec);
1811   if (__ec)
1812     return {};
1813   path __tmp_base = __weakly_canonical(__base, &__ec);
1814   if (__ec)
1815     return {};
1816   return __tmp.lexically_proximate(__tmp_base);
1817 }
1818
1819 inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
1820                                                 error_code& __ec) {
1821   return proximate(__p, current_path(), __ec);
1822 }
1823
1824 inline _LIBCPP_INLINE_VISIBILITY path
1825 proximate(const path& __p, const path& __base = current_path()) {
1826   return __weakly_canonical(__p).lexically_proximate(
1827       __weakly_canonical(__base));
1828 }
1829
1830 inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p) {
1831   return __read_symlink(__p);
1832 }
1833
1834 inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p,
1835                                                    error_code& __ec) {
1836   return __read_symlink(__p, &__ec);
1837 }
1838
1839 inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
1840                                                const path& __base,
1841                                                error_code& __ec) {
1842   path __tmp = __weakly_canonical(__p, &__ec);
1843   if (__ec)
1844     return path();
1845   path __tmpbase = __weakly_canonical(__base, &__ec);
1846   if (__ec)
1847     return path();
1848   return __tmp.lexically_relative(__tmpbase);
1849 }
1850
1851 inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
1852                                                error_code& __ec) {
1853   return relative(__p, current_path(), __ec);
1854 }
1855
1856 inline _LIBCPP_INLINE_VISIBILITY path
1857 relative(const path& __p, const path& __base = current_path()) {
1858   return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base));
1859 }
1860
1861 inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p) {
1862   return __remove(__p);
1863 }
1864
1865 inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p,
1866                                              error_code& __ec) noexcept {
1867   return __remove(__p, &__ec);
1868 }
1869
1870 inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p) {
1871   return __remove_all(__p);
1872 }
1873
1874 inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p,
1875                                                       error_code& __ec) {
1876   return __remove_all(__p, &__ec);
1877 }
1878
1879 inline _LIBCPP_INLINE_VISIBILITY void rename(const path& __from,
1880                                              const path& __to) {
1881   return __rename(__from, __to);
1882 }
1883
1884 inline _LIBCPP_INLINE_VISIBILITY void
1885 rename(const path& __from, const path& __to, error_code& __ec) noexcept {
1886   return __rename(__from, __to, &__ec);
1887 }
1888
1889 inline _LIBCPP_INLINE_VISIBILITY void resize_file(const path& __p,
1890                                                   uintmax_t __ns) {
1891   return __resize_file(__p, __ns);
1892 }
1893
1894 inline _LIBCPP_INLINE_VISIBILITY void
1895 resize_file(const path& __p, uintmax_t __ns, error_code& __ec) noexcept {
1896   return __resize_file(__p, __ns, &__ec);
1897 }
1898
1899 inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p) {
1900   return __space(__p);
1901 }
1902
1903 inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p,
1904                                                   error_code& __ec) noexcept {
1905   return __space(__p, &__ec);
1906 }
1907
1908 inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p) {
1909   return __status(__p);
1910 }
1911
1912 inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p,
1913                                                     error_code& __ec) noexcept {
1914   return __status(__p, &__ec);
1915 }
1916
1917 inline _LIBCPP_INLINE_VISIBILITY file_status symlink_status(const path& __p) {
1918   return __symlink_status(__p);
1919 }
1920
1921 inline _LIBCPP_INLINE_VISIBILITY file_status
1922 symlink_status(const path& __p, error_code& __ec) noexcept {
1923   return __symlink_status(__p, &__ec);
1924 }
1925
1926 inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path() {
1927   return __temp_directory_path();
1928 }
1929
1930 inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path(error_code& __ec) {
1931   return __temp_directory_path(&__ec);
1932 }
1933
1934 inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p) {
1935   return __weakly_canonical(__p);
1936 }
1937
1938 inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p,
1939                                                        error_code& __ec) {
1940   return __weakly_canonical(__p, &__ec);
1941 }
1942
1943 class directory_iterator;
1944 class recursive_directory_iterator;
1945 class _LIBCPP_HIDDEN __dir_stream;
1946
1947 class directory_entry {
1948   typedef _VSTD_FS::path _Path;
1949
1950 public:
1951   // constructors and destructors
1952   directory_entry() noexcept = default;
1953   directory_entry(directory_entry const&) = default;
1954   directory_entry(directory_entry&&) noexcept = default;
1955
1956   _LIBCPP_INLINE_VISIBILITY
1957   explicit directory_entry(_Path const& __p) : __p_(__p) {
1958     error_code __ec;
1959     __refresh(&__ec);
1960   }
1961
1962   _LIBCPP_INLINE_VISIBILITY
1963   directory_entry(_Path const& __p, error_code& __ec) : __p_(__p) {
1964     __refresh(&__ec);
1965   }
1966
1967   ~directory_entry() {}
1968
1969   directory_entry& operator=(directory_entry const&) = default;
1970   directory_entry& operator=(directory_entry&&) noexcept = default;
1971
1972   _LIBCPP_INLINE_VISIBILITY
1973   void assign(_Path const& __p) {
1974     __p_ = __p;
1975     error_code __ec;
1976     __refresh(&__ec);
1977   }
1978
1979   _LIBCPP_INLINE_VISIBILITY
1980   void assign(_Path const& __p, error_code& __ec) {
1981     __p_ = __p;
1982     __refresh(&__ec);
1983   }
1984
1985   _LIBCPP_INLINE_VISIBILITY
1986   void replace_filename(_Path const& __p) {
1987     __p_.replace_filename(__p);
1988     error_code __ec;
1989     __refresh(&__ec);
1990   }
1991
1992   _LIBCPP_INLINE_VISIBILITY
1993   void replace_filename(_Path const& __p, error_code& __ec) {
1994     __p_ = __p_.parent_path() / __p;
1995     __refresh(&__ec);
1996   }
1997
1998   _LIBCPP_INLINE_VISIBILITY
1999   void refresh() { __refresh(); }
2000
2001   _LIBCPP_INLINE_VISIBILITY
2002   void refresh(error_code& __ec) noexcept { __refresh(&__ec); }
2003
2004   _LIBCPP_INLINE_VISIBILITY
2005   _Path const& path() const noexcept { return __p_; }
2006
2007   _LIBCPP_INLINE_VISIBILITY
2008   operator const _Path&() const noexcept { return __p_; }
2009
2010   _LIBCPP_INLINE_VISIBILITY
2011   bool exists() const { return _VSTD_FS::exists(file_status{__get_ft()}); }
2012
2013   _LIBCPP_INLINE_VISIBILITY
2014   bool exists(error_code& __ec) const noexcept {
2015     return _VSTD_FS::exists(file_status{__get_ft(&__ec)});
2016   }
2017
2018   _LIBCPP_INLINE_VISIBILITY
2019   bool is_block_file() const { return __get_ft() == file_type::block; }
2020
2021   _LIBCPP_INLINE_VISIBILITY
2022   bool is_block_file(error_code& __ec) const noexcept {
2023     return __get_ft(&__ec) == file_type::block;
2024   }
2025
2026   _LIBCPP_INLINE_VISIBILITY
2027   bool is_character_file() const { return __get_ft() == file_type::character; }
2028
2029   _LIBCPP_INLINE_VISIBILITY
2030   bool is_character_file(error_code& __ec) const noexcept {
2031     return __get_ft(&__ec) == file_type::character;
2032   }
2033
2034   _LIBCPP_INLINE_VISIBILITY
2035   bool is_directory() const { return __get_ft() == file_type::directory; }
2036
2037   _LIBCPP_INLINE_VISIBILITY
2038   bool is_directory(error_code& __ec) const noexcept {
2039     return __get_ft(&__ec) == file_type::directory;
2040   }
2041
2042   _LIBCPP_INLINE_VISIBILITY
2043   bool is_fifo() const { return __get_ft() == file_type::fifo; }
2044
2045   _LIBCPP_INLINE_VISIBILITY
2046   bool is_fifo(error_code& __ec) const noexcept {
2047     return __get_ft(&__ec) == file_type::fifo;
2048   }
2049
2050   _LIBCPP_INLINE_VISIBILITY
2051   bool is_other() const { return _VSTD_FS::is_other(file_status{__get_ft()}); }
2052
2053   _LIBCPP_INLINE_VISIBILITY
2054   bool is_other(error_code& __ec) const noexcept {
2055     return _VSTD_FS::is_other(file_status{__get_ft(&__ec)});
2056   }
2057
2058   _LIBCPP_INLINE_VISIBILITY
2059   bool is_regular_file() const { return __get_ft() == file_type::regular; }
2060
2061   _LIBCPP_INLINE_VISIBILITY
2062   bool is_regular_file(error_code& __ec) const noexcept {
2063     return __get_ft(&__ec) == file_type::regular;
2064   }
2065
2066   _LIBCPP_INLINE_VISIBILITY
2067   bool is_socket() const { return __get_ft() == file_type::socket; }
2068
2069   _LIBCPP_INLINE_VISIBILITY
2070   bool is_socket(error_code& __ec) const noexcept {
2071     return __get_ft(&__ec) == file_type::socket;
2072   }
2073
2074   _LIBCPP_INLINE_VISIBILITY
2075   bool is_symlink() const { return __get_sym_ft() == file_type::symlink; }
2076
2077   _LIBCPP_INLINE_VISIBILITY
2078   bool is_symlink(error_code& __ec) const noexcept {
2079     return __get_sym_ft(&__ec) == file_type::symlink;
2080   }
2081   _LIBCPP_INLINE_VISIBILITY
2082   uintmax_t file_size() const { return __get_size(); }
2083
2084   _LIBCPP_INLINE_VISIBILITY
2085   uintmax_t file_size(error_code& __ec) const noexcept {
2086     return __get_size(&__ec);
2087   }
2088
2089   _LIBCPP_INLINE_VISIBILITY
2090   uintmax_t hard_link_count() const { return __get_nlink(); }
2091
2092   _LIBCPP_INLINE_VISIBILITY
2093   uintmax_t hard_link_count(error_code& __ec) const noexcept {
2094     return __get_nlink(&__ec);
2095   }
2096
2097   _LIBCPP_INLINE_VISIBILITY
2098   file_time_type last_write_time() const { return __get_write_time(); }
2099
2100   _LIBCPP_INLINE_VISIBILITY
2101   file_time_type last_write_time(error_code& __ec) const noexcept {
2102     return __get_write_time(&__ec);
2103   }
2104
2105   _LIBCPP_INLINE_VISIBILITY
2106   file_status status() const { return __get_status(); }
2107
2108   _LIBCPP_INLINE_VISIBILITY
2109   file_status status(error_code& __ec) const noexcept {
2110     return __get_status(&__ec);
2111   }
2112
2113   _LIBCPP_INLINE_VISIBILITY
2114   file_status symlink_status() const { return __get_symlink_status(); }
2115
2116   _LIBCPP_INLINE_VISIBILITY
2117   file_status symlink_status(error_code& __ec) const noexcept {
2118     return __get_symlink_status(&__ec);
2119   }
2120
2121   _LIBCPP_INLINE_VISIBILITY
2122   bool operator<(directory_entry const& __rhs) const noexcept {
2123     return __p_ < __rhs.__p_;
2124   }
2125
2126   _LIBCPP_INLINE_VISIBILITY
2127   bool operator==(directory_entry const& __rhs) const noexcept {
2128     return __p_ == __rhs.__p_;
2129   }
2130
2131   _LIBCPP_INLINE_VISIBILITY
2132   bool operator!=(directory_entry const& __rhs) const noexcept {
2133     return __p_ != __rhs.__p_;
2134   }
2135
2136   _LIBCPP_INLINE_VISIBILITY
2137   bool operator<=(directory_entry const& __rhs) const noexcept {
2138     return __p_ <= __rhs.__p_;
2139   }
2140
2141   _LIBCPP_INLINE_VISIBILITY
2142   bool operator>(directory_entry const& __rhs) const noexcept {
2143     return __p_ > __rhs.__p_;
2144   }
2145
2146   _LIBCPP_INLINE_VISIBILITY
2147   bool operator>=(directory_entry const& __rhs) const noexcept {
2148     return __p_ >= __rhs.__p_;
2149   }
2150
2151 private:
2152   friend class directory_iterator;
2153   friend class recursive_directory_iterator;
2154   friend class __dir_stream;
2155
2156   enum _CacheType : unsigned char {
2157     _Empty,
2158     _IterSymlink,
2159     _IterNonSymlink,
2160     _RefreshSymlink,
2161     _RefreshSymlinkUnresolved,
2162     _RefreshNonSymlink
2163   };
2164
2165   struct __cached_data {
2166     uintmax_t __size_;
2167     uintmax_t __nlink_;
2168     file_time_type __write_time_;
2169     perms __sym_perms_;
2170     perms __non_sym_perms_;
2171     file_type __type_;
2172     _CacheType __cache_type_;
2173
2174     _LIBCPP_INLINE_VISIBILITY
2175     __cached_data() noexcept { __reset(); }
2176
2177     _LIBCPP_INLINE_VISIBILITY
2178     void __reset() {
2179       __cache_type_ = _Empty;
2180       __type_ = file_type::none;
2181       __sym_perms_ = __non_sym_perms_ = perms::unknown;
2182       __size_ = __nlink_ = uintmax_t(-1);
2183       __write_time_ = file_time_type::min();
2184     }
2185   };
2186
2187   _LIBCPP_INLINE_VISIBILITY
2188   static __cached_data __create_iter_result(file_type __ft) {
2189     __cached_data __data;
2190     __data.__type_ = __ft;
2191     __data.__cache_type_ = [&]() {
2192       switch (__ft) {
2193       case file_type::none:
2194         return _Empty;
2195       case file_type::symlink:
2196         return _IterSymlink;
2197       default:
2198         return _IterNonSymlink;
2199       }
2200     }();
2201     return __data;
2202   }
2203
2204   _LIBCPP_INLINE_VISIBILITY
2205   void __assign_iter_entry(_Path&& __p, __cached_data __dt) {
2206     __p_ = std::move(__p);
2207     __data_ = __dt;
2208   }
2209
2210   _LIBCPP_FUNC_VIS
2211   error_code __do_refresh() noexcept;
2212
2213   _LIBCPP_INLINE_VISIBILITY
2214   static bool __is_dne_error(error_code const& __ec) {
2215     if (!__ec)
2216       return true;
2217     switch (static_cast<errc>(__ec.value())) {
2218     case errc::no_such_file_or_directory:
2219     case errc::not_a_directory:
2220       return true;
2221     default:
2222       return false;
2223     }
2224   }
2225
2226   _LIBCPP_INLINE_VISIBILITY
2227   void __handle_error(const char* __msg, error_code* __dest_ec,
2228                       error_code const& __ec, bool __allow_dne = false) const {
2229     if (__dest_ec) {
2230       *__dest_ec = __ec;
2231       return;
2232     }
2233     if (__ec && (!__allow_dne || !__is_dne_error(__ec)))
2234       __throw_filesystem_error(__msg, __p_, __ec);
2235   }
2236
2237   _LIBCPP_INLINE_VISIBILITY
2238   void __refresh(error_code* __ec = nullptr) {
2239     __handle_error("in directory_entry::refresh", __ec, __do_refresh(),
2240                    /*allow_dne*/ true);
2241   }
2242
2243   _LIBCPP_INLINE_VISIBILITY
2244   file_type __get_sym_ft(error_code* __ec = nullptr) const {
2245     switch (__data_.__cache_type_) {
2246     case _Empty:
2247       return __symlink_status(__p_, __ec).type();
2248     case _IterSymlink:
2249     case _RefreshSymlink:
2250     case _RefreshSymlinkUnresolved:
2251       if (__ec)
2252         __ec->clear();
2253       return file_type::symlink;
2254     case _IterNonSymlink:
2255     case _RefreshNonSymlink:
2256       file_status __st(__data_.__type_);
2257       if (__ec && !_VSTD_FS::exists(__st))
2258         *__ec = make_error_code(errc::no_such_file_or_directory);
2259       else if (__ec)
2260         __ec->clear();
2261       return __data_.__type_;
2262     }
2263     _LIBCPP_UNREACHABLE();
2264   }
2265
2266   _LIBCPP_INLINE_VISIBILITY
2267   file_type __get_ft(error_code* __ec = nullptr) const {
2268     switch (__data_.__cache_type_) {
2269     case _Empty:
2270     case _IterSymlink:
2271     case _RefreshSymlinkUnresolved:
2272       return __status(__p_, __ec).type();
2273     case _IterNonSymlink:
2274     case _RefreshNonSymlink:
2275     case _RefreshSymlink: {
2276       file_status __st(__data_.__type_);
2277       if (__ec && !_VSTD_FS::exists(__st))
2278         *__ec = make_error_code(errc::no_such_file_or_directory);
2279       else if (__ec)
2280         __ec->clear();
2281       return __data_.__type_;
2282     }
2283     }
2284     _LIBCPP_UNREACHABLE();
2285   }
2286
2287   _LIBCPP_INLINE_VISIBILITY
2288   file_status __get_status(error_code* __ec = nullptr) const {
2289     switch (__data_.__cache_type_) {
2290     case _Empty:
2291     case _IterNonSymlink:
2292     case _IterSymlink:
2293     case _RefreshSymlinkUnresolved:
2294       return __status(__p_, __ec);
2295     case _RefreshNonSymlink:
2296     case _RefreshSymlink:
2297       return file_status(__get_ft(__ec), __data_.__non_sym_perms_);
2298     }
2299     _LIBCPP_UNREACHABLE();
2300   }
2301
2302   _LIBCPP_INLINE_VISIBILITY
2303   file_status __get_symlink_status(error_code* __ec = nullptr) const {
2304     switch (__data_.__cache_type_) {
2305     case _Empty:
2306     case _IterNonSymlink:
2307     case _IterSymlink:
2308       return __symlink_status(__p_, __ec);
2309     case _RefreshNonSymlink:
2310       return file_status(__get_sym_ft(__ec), __data_.__non_sym_perms_);
2311     case _RefreshSymlink:
2312     case _RefreshSymlinkUnresolved:
2313       return file_status(__get_sym_ft(__ec), __data_.__sym_perms_);
2314     }
2315     _LIBCPP_UNREACHABLE();
2316   }
2317
2318   _LIBCPP_INLINE_VISIBILITY
2319   uintmax_t __get_size(error_code* __ec = nullptr) const {
2320     switch (__data_.__cache_type_) {
2321     case _Empty:
2322     case _IterNonSymlink:
2323     case _IterSymlink:
2324     case _RefreshSymlinkUnresolved:
2325       return _VSTD_FS::__file_size(__p_, __ec);
2326     case _RefreshSymlink:
2327     case _RefreshNonSymlink: {
2328       error_code __m_ec;
2329       file_status __st(__get_ft(&__m_ec));
2330       __handle_error("in directory_entry::file_size", __ec, __m_ec);
2331       if (_VSTD_FS::exists(__st) && !_VSTD_FS::is_regular_file(__st)) {
2332         errc __err_kind = _VSTD_FS::is_directory(__st) ? errc::is_a_directory
2333                                                        : errc::not_supported;
2334         __handle_error("in directory_entry::file_size", __ec,
2335                        make_error_code(__err_kind));
2336       }
2337       return __data_.__size_;
2338     }
2339     }
2340     _LIBCPP_UNREACHABLE();
2341   }
2342
2343   _LIBCPP_INLINE_VISIBILITY
2344   uintmax_t __get_nlink(error_code* __ec = nullptr) const {
2345     switch (__data_.__cache_type_) {
2346     case _Empty:
2347     case _IterNonSymlink:
2348     case _IterSymlink:
2349     case _RefreshSymlinkUnresolved:
2350       return _VSTD_FS::__hard_link_count(__p_, __ec);
2351     case _RefreshSymlink:
2352     case _RefreshNonSymlink: {
2353       error_code __m_ec;
2354       (void)__get_ft(&__m_ec);
2355       __handle_error("in directory_entry::hard_link_count", __ec, __m_ec);
2356       return __data_.__nlink_;
2357     }
2358     }
2359     _LIBCPP_UNREACHABLE();
2360   }
2361
2362   _LIBCPP_INLINE_VISIBILITY
2363   file_time_type __get_write_time(error_code* __ec = nullptr) const {
2364     switch (__data_.__cache_type_) {
2365     case _Empty:
2366     case _IterNonSymlink:
2367     case _IterSymlink:
2368     case _RefreshSymlinkUnresolved:
2369       return _VSTD_FS::__last_write_time(__p_, __ec);
2370     case _RefreshSymlink:
2371     case _RefreshNonSymlink: {
2372       error_code __m_ec;
2373       file_status __st(__get_ft(&__m_ec));
2374       __handle_error("in directory_entry::last_write_time", __ec, __m_ec);
2375       if (_VSTD_FS::exists(__st) &&
2376           __data_.__write_time_ == file_time_type::min())
2377         __handle_error("in directory_entry::last_write_time", __ec,
2378                        make_error_code(errc::value_too_large));
2379       return __data_.__write_time_;
2380     }
2381     }
2382     _LIBCPP_UNREACHABLE();
2383   }
2384
2385 private:
2386   _Path __p_;
2387   __cached_data __data_;
2388 };
2389
2390 class __dir_element_proxy {
2391 public:
2392   inline _LIBCPP_INLINE_VISIBILITY directory_entry operator*() {
2393     return _VSTD::move(__elem_);
2394   }
2395
2396 private:
2397   friend class directory_iterator;
2398   friend class recursive_directory_iterator;
2399   explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
2400   __dir_element_proxy(__dir_element_proxy&& __o)
2401       : __elem_(_VSTD::move(__o.__elem_)) {}
2402   directory_entry __elem_;
2403 };
2404
2405 class directory_iterator {
2406 public:
2407   typedef directory_entry value_type;
2408   typedef ptrdiff_t difference_type;
2409   typedef value_type const* pointer;
2410   typedef value_type const& reference;
2411   typedef input_iterator_tag iterator_category;
2412
2413 public:
2414   //ctor & dtor
2415   directory_iterator() noexcept {}
2416
2417   explicit directory_iterator(const path& __p)
2418       : directory_iterator(__p, nullptr) {}
2419
2420   directory_iterator(const path& __p, directory_options __opts)
2421       : directory_iterator(__p, nullptr, __opts) {}
2422
2423   directory_iterator(const path& __p, error_code& __ec)
2424       : directory_iterator(__p, &__ec) {}
2425
2426   directory_iterator(const path& __p, directory_options __opts,
2427                      error_code& __ec)
2428       : directory_iterator(__p, &__ec, __opts) {}
2429
2430   directory_iterator(const directory_iterator&) = default;
2431   directory_iterator(directory_iterator&&) = default;
2432   directory_iterator& operator=(const directory_iterator&) = default;
2433
2434   directory_iterator& operator=(directory_iterator&& __o) noexcept {
2435     // non-default implementation provided to support self-move assign.
2436     if (this != &__o) {
2437       __imp_ = _VSTD::move(__o.__imp_);
2438     }
2439     return *this;
2440   }
2441
2442   ~directory_iterator() = default;
2443
2444   const directory_entry& operator*() const {
2445     _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
2446     return __dereference();
2447   }
2448
2449   const directory_entry* operator->() const { return &**this; }
2450
2451   directory_iterator& operator++() { return __increment(); }
2452
2453   __dir_element_proxy operator++(int) {
2454     __dir_element_proxy __p(**this);
2455     __increment();
2456     return __p;
2457   }
2458
2459   directory_iterator& increment(error_code& __ec) { return __increment(&__ec); }
2460
2461 private:
2462   inline _LIBCPP_INLINE_VISIBILITY friend bool
2463   operator==(const directory_iterator& __lhs,
2464              const directory_iterator& __rhs) noexcept;
2465
2466   // construct the dir_stream
2467   _LIBCPP_FUNC_VIS
2468   directory_iterator(const path&, error_code*,
2469                      directory_options = directory_options::none);
2470
2471   _LIBCPP_FUNC_VIS
2472   directory_iterator& __increment(error_code* __ec = nullptr);
2473
2474   _LIBCPP_FUNC_VIS
2475   const directory_entry& __dereference() const;
2476
2477 private:
2478   shared_ptr<__dir_stream> __imp_;
2479 };
2480
2481 inline _LIBCPP_INLINE_VISIBILITY bool
2482 operator==(const directory_iterator& __lhs,
2483            const directory_iterator& __rhs) noexcept {
2484   return __lhs.__imp_ == __rhs.__imp_;
2485 }
2486
2487 inline _LIBCPP_INLINE_VISIBILITY bool
2488 operator!=(const directory_iterator& __lhs,
2489            const directory_iterator& __rhs) noexcept {
2490   return !(__lhs == __rhs);
2491 }
2492
2493 // enable directory_iterator range-based for statements
2494 inline _LIBCPP_INLINE_VISIBILITY directory_iterator
2495 begin(directory_iterator __iter) noexcept {
2496   return __iter;
2497 }
2498
2499 inline _LIBCPP_INLINE_VISIBILITY directory_iterator
2500 end(const directory_iterator&) noexcept {
2501   return directory_iterator();
2502 }
2503
2504 class recursive_directory_iterator {
2505 public:
2506   using value_type = directory_entry;
2507   using difference_type = std::ptrdiff_t;
2508   using pointer = directory_entry const*;
2509   using reference = directory_entry const&;
2510   using iterator_category = std::input_iterator_tag;
2511
2512 public:
2513   // constructors and destructor
2514   _LIBCPP_INLINE_VISIBILITY
2515   recursive_directory_iterator() noexcept : __rec_(false) {}
2516
2517   _LIBCPP_INLINE_VISIBILITY
2518   explicit recursive_directory_iterator(
2519       const path& __p, directory_options __xoptions = directory_options::none)
2520       : recursive_directory_iterator(__p, __xoptions, nullptr) {}
2521
2522   _LIBCPP_INLINE_VISIBILITY
2523   recursive_directory_iterator(const path& __p, directory_options __xoptions,
2524                                error_code& __ec)
2525       : recursive_directory_iterator(__p, __xoptions, &__ec) {}
2526
2527   _LIBCPP_INLINE_VISIBILITY
2528   recursive_directory_iterator(const path& __p, error_code& __ec)
2529       : recursive_directory_iterator(__p, directory_options::none, &__ec) {}
2530
2531   recursive_directory_iterator(const recursive_directory_iterator&) = default;
2532   recursive_directory_iterator(recursive_directory_iterator&&) = default;
2533
2534   recursive_directory_iterator&
2535   operator=(const recursive_directory_iterator&) = default;
2536
2537   _LIBCPP_INLINE_VISIBILITY
2538   recursive_directory_iterator&
2539   operator=(recursive_directory_iterator&& __o) noexcept {
2540     // non-default implementation provided to support self-move assign.
2541     if (this != &__o) {
2542       __imp_ = _VSTD::move(__o.__imp_);
2543       __rec_ = __o.__rec_;
2544     }
2545     return *this;
2546   }
2547
2548   ~recursive_directory_iterator() = default;
2549
2550   _LIBCPP_INLINE_VISIBILITY
2551   const directory_entry& operator*() const { return __dereference(); }
2552
2553   _LIBCPP_INLINE_VISIBILITY
2554   const directory_entry* operator->() const { return &__dereference(); }
2555
2556   recursive_directory_iterator& operator++() { return __increment(); }
2557
2558   _LIBCPP_INLINE_VISIBILITY
2559   __dir_element_proxy operator++(int) {
2560     __dir_element_proxy __p(**this);
2561     __increment();
2562     return __p;
2563   }
2564
2565   _LIBCPP_INLINE_VISIBILITY
2566   recursive_directory_iterator& increment(error_code& __ec) {
2567     return __increment(&__ec);
2568   }
2569
2570   _LIBCPP_FUNC_VIS directory_options options() const;
2571   _LIBCPP_FUNC_VIS int depth() const;
2572
2573   _LIBCPP_INLINE_VISIBILITY
2574   void pop() { __pop(); }
2575
2576   _LIBCPP_INLINE_VISIBILITY
2577   void pop(error_code& __ec) { __pop(&__ec); }
2578
2579   _LIBCPP_INLINE_VISIBILITY
2580   bool recursion_pending() const { return __rec_; }
2581
2582   _LIBCPP_INLINE_VISIBILITY
2583   void disable_recursion_pending() { __rec_ = false; }
2584
2585 private:
2586   recursive_directory_iterator(const path& __p, directory_options __opt,
2587                                error_code* __ec);
2588
2589   _LIBCPP_FUNC_VIS
2590   const directory_entry& __dereference() const;
2591
2592   _LIBCPP_FUNC_VIS
2593   bool __try_recursion(error_code* __ec);
2594
2595   _LIBCPP_FUNC_VIS
2596   void __advance(error_code* __ec = nullptr);
2597
2598   _LIBCPP_FUNC_VIS
2599   recursive_directory_iterator& __increment(error_code* __ec = nullptr);
2600
2601   _LIBCPP_FUNC_VIS
2602   void __pop(error_code* __ec = nullptr);
2603
2604   inline _LIBCPP_INLINE_VISIBILITY friend bool
2605   operator==(const recursive_directory_iterator&,
2606              const recursive_directory_iterator&) noexcept;
2607
2608   struct _LIBCPP_HIDDEN __shared_imp;
2609   shared_ptr<__shared_imp> __imp_;
2610   bool __rec_;
2611 }; // class recursive_directory_iterator
2612
2613 inline _LIBCPP_INLINE_VISIBILITY bool
2614 operator==(const recursive_directory_iterator& __lhs,
2615            const recursive_directory_iterator& __rhs) noexcept {
2616   return __lhs.__imp_ == __rhs.__imp_;
2617 }
2618
2619 _LIBCPP_INLINE_VISIBILITY
2620 inline bool operator!=(const recursive_directory_iterator& __lhs,
2621                        const recursive_directory_iterator& __rhs) noexcept {
2622   return !(__lhs == __rhs);
2623 }
2624 // enable recursive_directory_iterator range-based for statements
2625 inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
2626 begin(recursive_directory_iterator __iter) noexcept {
2627   return __iter;
2628 }
2629
2630 inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
2631 end(const recursive_directory_iterator&) noexcept {
2632   return recursive_directory_iterator();
2633 }
2634
2635 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
2636
2637 _LIBCPP_END_NAMESPACE_FILESYSTEM
2638
2639 #endif // !_LIBCPP_CXX03_LANG
2640
2641 _LIBCPP_POP_MACROS
2642
2643 #endif // _LIBCPP_FILESYSTEM