contrib/libc++/include/experimental/filesystem

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