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