1// -*- C++ -*-
2//===--------------------------- filesystem -------------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10#ifndef _LIBCPP_EXPERIMENTAL_FILESYSTEM
11#define _LIBCPP_EXPERIMENTAL_FILESYSTEM
12/*
13    filesystem synopsis
14
15    namespace std { namespace experimental { namespace filesystem { inline namespace v1 {
16
17    class path;
18
19    void swap(path& lhs, path& rhs) _NOEXCEPT;
20    size_t hash_value(const path& p) _NOEXCEPT;
21
22    bool operator==(const path& lhs, const path& rhs) _NOEXCEPT;
23    bool operator!=(const path& lhs, const path& rhs) _NOEXCEPT;
24    bool operator< (const path& lhs, const path& rhs) _NOEXCEPT;
25    bool operator<=(const path& lhs, const path& rhs) _NOEXCEPT;
26    bool operator> (const path& lhs, const path& rhs) _NOEXCEPT;
27    bool operator>=(const path& lhs, const path& rhs) _NOEXCEPT;
28
29    path operator/ (const path& lhs, const path& rhs);
30
31    template <class charT, class traits>
32    basic_ostream<charT, traits>&
33    operator<<(basic_ostream<charT, traits>& os, const path& p);
34
35    template <class charT, class traits>
36    basic_istream<charT, traits>&
37    operator>>(basic_istream<charT, traits>& is, path& p);
38
39    template <class Source>
40      path u8path(const Source& source);
41    template <class InputIterator>
42      path u8path(InputIterator first, InputIterator last);
43
44    class filesystem_error;
45    class directory_entry;
46
47    class directory_iterator;
48
49    // enable directory_iterator range-based for statements
50    directory_iterator begin(directory_iterator iter) noexcept;
51    directory_iterator end(const directory_iterator&) noexcept;
52
53    class recursive_directory_iterator;
54
55    // enable recursive_directory_iterator range-based for statements
56    recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
57    recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
58
59    class file_status;
60
61    struct space_info
62    {
63      uintmax_t capacity;
64      uintmax_t free;
65      uintmax_t available;
66    };
67
68    enum class file_type;
69    enum class perms;
70    enum class copy_options;
71    enum class directory_options;
72
73    typedef chrono::time_point<trivial-clock>  file_time_type;
74
75    // operational functions
76
77    path absolute(const path& p, const path& base=current_path());
78
79    path canonical(const path& p, const path& base = current_path());
80    path canonical(const path& p, error_code& ec);
81    path canonical(const path& p, const path& base, error_code& ec);
82
83    void copy(const path& from, const path& to);
84    void copy(const path& from, const path& to, error_code& ec) _NOEXCEPT;
85    void copy(const path& from, const path& to, copy_options options);
86    void copy(const path& from, const path& to, copy_options options,
87                   error_code& ec) _NOEXCEPT;
88
89    bool copy_file(const path& from, const path& to);
90    bool copy_file(const path& from, const path& to, error_code& ec) _NOEXCEPT;
91    bool copy_file(const path& from, const path& to, copy_options option);
92    bool copy_file(const path& from, const path& to, copy_options option,
93                           error_code& ec) _NOEXCEPT;
94
95    void copy_symlink(const path& existing_symlink, const path& new_symlink);
96    void copy_symlink(const path& existing_symlink, const path& new_symlink,
97                              error_code& ec) _NOEXCEPT;
98
99    bool create_directories(const path& p);
100    bool create_directories(const path& p, error_code& ec) _NOEXCEPT;
101
102    bool create_directory(const path& p);
103    bool create_directory(const path& p, error_code& ec) _NOEXCEPT;
104
105    bool create_directory(const path& p, const path& attributes);
106    bool create_directory(const path& p, const path& attributes,
107                                  error_code& ec) _NOEXCEPT;
108
109    void create_directory_symlink(const path& to, const path& new_symlink);
110    void create_directory_symlink(const path& to, const path& new_symlink,
111                                          error_code& ec) _NOEXCEPT;
112
113    void create_hard_link(const path& to, const path& new_hard_link);
114    void create_hard_link(const path& to, const path& new_hard_link,
115                                  error_code& ec) _NOEXCEPT;
116
117    void create_symlink(const path& to, const path& new_symlink);
118    void create_symlink(const path& to, const path& new_symlink,
119                                error_code& ec) _NOEXCEPT;
120
121    path current_path();
122    path current_path(error_code& ec);
123    void current_path(const path& p);
124    void current_path(const path& p, error_code& ec) _NOEXCEPT;
125
126    bool exists(file_status s) _NOEXCEPT;
127    bool exists(const path& p);
128    bool exists(const path& p, error_code& ec) _NOEXCEPT;
129
130    bool equivalent(const path& p1, const path& p2);
131    bool equivalent(const path& p1, const path& p2, error_code& ec) _NOEXCEPT;
132
133    uintmax_t    file_size(const path& p);
134    uintmax_t    file_size(const path& p, error_code& ec) _NOEXCEPT;
135
136    uintmax_t    hard_link_count(const path& p);
137    uintmax_t    hard_link_count(const path& p, error_code& ec) _NOEXCEPT;
138
139    bool is_block_file(file_status s) _NOEXCEPT;
140    bool is_block_file(const path& p);
141    bool is_block_file(const path& p, error_code& ec) _NOEXCEPT;
142
143    bool is_character_file(file_status s) _NOEXCEPT;
144    bool is_character_file(const path& p);
145    bool is_character_file(const path& p, error_code& ec) _NOEXCEPT;
146
147    bool is_directory(file_status s) _NOEXCEPT;
148    bool is_directory(const path& p);
149    bool is_directory(const path& p, error_code& ec) _NOEXCEPT;
150
151    bool is_empty(const path& p);
152    bool is_empty(const path& p, error_code& ec) _NOEXCEPT;
153
154    bool is_fifo(file_status s) _NOEXCEPT;
155    bool is_fifo(const path& p);
156    bool is_fifo(const path& p, error_code& ec) _NOEXCEPT;
157
158    bool is_other(file_status s) _NOEXCEPT;
159    bool is_other(const path& p);
160    bool is_other(const path& p, error_code& ec) _NOEXCEPT;
161
162    bool is_regular_file(file_status s) _NOEXCEPT;
163    bool is_regular_file(const path& p);
164    bool is_regular_file(const path& p, error_code& ec) _NOEXCEPT;
165
166    bool is_socket(file_status s) _NOEXCEPT;
167    bool is_socket(const path& p);
168    bool is_socket(const path& p, error_code& ec) _NOEXCEPT;
169
170    bool is_symlink(file_status s) _NOEXCEPT;
171    bool is_symlink(const path& p);
172    bool is_symlink(const path& p, error_code& ec) _NOEXCEPT;
173
174    file_time_type  last_write_time(const path& p);
175    file_time_type  last_write_time(const path& p, error_code& ec) _NOEXCEPT;
176    void last_write_time(const path& p, file_time_type new_time);
177    void last_write_time(const path& p, file_time_type new_time,
178                                 error_code& ec) _NOEXCEPT;
179
180    void permissions(const path& p, perms prms);
181    void permissions(const path& p, perms prms, error_code& ec) _NOEXCEPT;
182
183    path read_symlink(const path& p);
184    path read_symlink(const path& p, error_code& ec);
185
186    bool remove(const path& p);
187    bool remove(const path& p, error_code& ec) _NOEXCEPT;
188
189    uintmax_t    remove_all(const path& p);
190    uintmax_t    remove_all(const path& p, error_code& ec) _NOEXCEPT;
191
192    void rename(const path& from, const path& to);
193    void rename(const path& from, const path& to, error_code& ec) _NOEXCEPT;
194
195    void resize_file(const path& p, uintmax_t size);
196    void resize_file(const path& p, uintmax_t size, error_code& ec) _NOEXCEPT;
197
198    space_info   space(const path& p);
199    space_info   space(const path& p, error_code& ec) _NOEXCEPT;
200
201    file_status  status(const path& p);
202    file_status  status(const path& p, error_code& ec) _NOEXCEPT;
203
204    bool status_known(file_status s) _NOEXCEPT;
205
206    file_status  symlink_status(const path& p);
207    file_status  symlink_status(const path& p, error_code& ec) _NOEXCEPT;
208
209    path system_complete(const path& p);
210    path system_complete(const path& p, error_code& ec);
211
212    path temp_directory_path();
213    path temp_directory_path(error_code& ec);
214
215} } } }  // namespaces std::experimental::filesystem::v1
216
217*/
218
219#include <experimental/__config>
220#include <cstddef>
221#include <chrono>
222#include <iterator>
223#include <iosfwd>
224#include <locale>
225#include <memory>
226#include <stack>
227#include <string>
228#include <system_error>
229#include <utility>
230#include <iomanip> // for quoted
231#include <string_view>
232
233#include <__debug>
234
235#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
236#pragma GCC system_header
237#endif
238
239#define __cpp_lib_experimental_filesystem 201406
240
241_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
242
243typedef chrono::time_point<std::chrono::system_clock>  file_time_type;
244
245struct _LIBCPP_TYPE_VIS space_info
246{
247  uintmax_t capacity;
248  uintmax_t free;
249  uintmax_t available;
250};
251
252enum class _LIBCPP_ENUM_VIS file_type : signed char
253{
254    none       = 0,
255    not_found  = -1,
256    regular    = 1,
257    directory  = 2,
258    symlink    = 3,
259    block      = 4,
260    character  = 5,
261    fifo       = 6,
262    socket     = 7,
263    unknown    = 8
264};
265
266enum class _LIBCPP_ENUM_VIS perms : unsigned
267{
268    none         = 0,
269
270    owner_read   = 0400,
271    owner_write  = 0200,
272    owner_exec   = 0100,
273    owner_all    = 0700,
274
275    group_read   = 040,
276    group_write  = 020,
277    group_exec   = 010,
278    group_all    = 070,
279
280    others_read  = 04,
281    others_write = 02,
282    others_exec  = 01,
283    others_all   = 07,
284
285    all          = 0777,
286
287    set_uid      = 04000,
288    set_gid      = 02000,
289    sticky_bit   = 01000,
290    mask         = 07777,
291    unknown      = 0xFFFF,
292
293    add_perms        = 0x10000,
294    remove_perms     = 0x20000,
295    symlink_nofollow = 0x40000
296};
297
298_LIBCPP_INLINE_VISIBILITY
299inline _LIBCPP_CONSTEXPR perms operator&(perms _LHS, perms _RHS)
300{ return static_cast<perms>(static_cast<unsigned>(_LHS) & static_cast<unsigned>(_RHS)); }
301
302_LIBCPP_INLINE_VISIBILITY
303inline _LIBCPP_CONSTEXPR perms operator|(perms _LHS, perms _RHS)
304{ return static_cast<perms>(static_cast<unsigned>(_LHS) | static_cast<unsigned>(_RHS)); }
305
306_LIBCPP_INLINE_VISIBILITY
307inline _LIBCPP_CONSTEXPR perms operator^(perms _LHS, perms _RHS)
308{ return static_cast<perms>(static_cast<unsigned>(_LHS) ^ static_cast<unsigned>(_RHS)); }
309
310_LIBCPP_INLINE_VISIBILITY
311inline _LIBCPP_CONSTEXPR perms operator~(perms _LHS)
312{ return static_cast<perms>(~static_cast<unsigned>(_LHS)); }
313
314_LIBCPP_INLINE_VISIBILITY
315inline perms& operator&=(perms& _LHS, perms _RHS)
316{ return _LHS = _LHS & _RHS; }
317
318_LIBCPP_INLINE_VISIBILITY
319inline perms& operator|=(perms& _LHS, perms _RHS)
320{ return _LHS = _LHS | _RHS; }
321
322_LIBCPP_INLINE_VISIBILITY
323inline perms& operator^=(perms& _LHS, perms _RHS)
324{ return _LHS = _LHS ^ _RHS; }
325
326enum class _LIBCPP_ENUM_VIS copy_options : unsigned short
327{
328    none               = 0,
329    skip_existing      = 1,
330    overwrite_existing = 2,
331    update_existing    = 4,
332    recursive          = 8,
333    copy_symlinks      = 16,
334    skip_symlinks      = 32,
335    directories_only   = 64,
336    create_symlinks    = 128,
337    create_hard_links  = 256,
338    __in_recursive_copy = 512,
339};
340
341_LIBCPP_INLINE_VISIBILITY
342inline _LIBCPP_CONSTEXPR copy_options operator&(copy_options _LHS, copy_options _RHS)
343{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) & static_cast<unsigned short>(_RHS)); }
344
345_LIBCPP_INLINE_VISIBILITY
346inline _LIBCPP_CONSTEXPR copy_options operator|(copy_options _LHS, copy_options _RHS)
347{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) | static_cast<unsigned short>(_RHS)); }
348
349_LIBCPP_INLINE_VISIBILITY
350inline _LIBCPP_CONSTEXPR copy_options operator^(copy_options _LHS, copy_options _RHS)
351{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^ static_cast<unsigned short>(_RHS)); }
352
353_LIBCPP_INLINE_VISIBILITY
354inline _LIBCPP_CONSTEXPR copy_options operator~(copy_options _LHS)
355{ return static_cast<copy_options>(~static_cast<unsigned short>(_LHS)); }
356
357_LIBCPP_INLINE_VISIBILITY
358inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS)
359{ return _LHS = _LHS & _RHS; }
360
361_LIBCPP_INLINE_VISIBILITY
362inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS)
363{ return _LHS = _LHS | _RHS; }
364
365_LIBCPP_INLINE_VISIBILITY
366inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS)
367{ return _LHS = _LHS ^ _RHS; }
368
369
370enum class _LIBCPP_ENUM_VIS directory_options : unsigned char
371{
372    none                     = 0,
373    follow_directory_symlink = 1,
374    skip_permission_denied   = 2
375};
376
377_LIBCPP_INLINE_VISIBILITY
378inline _LIBCPP_CONSTEXPR directory_options operator&(directory_options _LHS, directory_options _RHS)
379{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) & static_cast<unsigned char>(_RHS)); }
380
381_LIBCPP_INLINE_VISIBILITY
382inline _LIBCPP_CONSTEXPR directory_options operator|(directory_options _LHS, directory_options _RHS)
383{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) | static_cast<unsigned char>(_RHS)); }
384
385_LIBCPP_INLINE_VISIBILITY
386inline _LIBCPP_CONSTEXPR directory_options operator^(directory_options _LHS, directory_options _RHS)
387{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^ static_cast<unsigned char>(_RHS)); }
388
389_LIBCPP_INLINE_VISIBILITY
390inline _LIBCPP_CONSTEXPR directory_options operator~(directory_options _LHS)
391{ return static_cast<directory_options>(~static_cast<unsigned char>(_LHS)); }
392
393_LIBCPP_INLINE_VISIBILITY
394inline directory_options& operator&=(directory_options& _LHS, directory_options _RHS)
395{ return _LHS = _LHS & _RHS; }
396
397_LIBCPP_INLINE_VISIBILITY
398inline directory_options& operator|=(directory_options& _LHS, directory_options _RHS)
399{ return _LHS = _LHS | _RHS; }
400
401_LIBCPP_INLINE_VISIBILITY
402inline directory_options& operator^=(directory_options& _LHS, directory_options _RHS)
403{ return _LHS = _LHS ^ _RHS; }
404
405
406class _LIBCPP_TYPE_VIS file_status
407{
408public:
409    // constructors
410    _LIBCPP_INLINE_VISIBILITY
411    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_INLINE_VISIBILITY bool empty() const _NOEXCEPT { return __pn_.empty(); }
976
977    _LIBCPP_INLINE_VISIBILITY bool has_root_name()      const { return !__root_name().empty(); }
978    _LIBCPP_INLINE_VISIBILITY bool has_root_directory() const { return !__root_directory().empty(); }
979    _LIBCPP_INLINE_VISIBILITY bool has_root_path()      const { return !__root_path_raw().empty(); }
980    _LIBCPP_INLINE_VISIBILITY bool has_relative_path()  const { return !__relative_path().empty(); }
981    _LIBCPP_INLINE_VISIBILITY bool has_parent_path()    const { return !__parent_path().empty(); }
982    _LIBCPP_INLINE_VISIBILITY bool has_filename()       const { return !__filename().empty(); }
983    _LIBCPP_INLINE_VISIBILITY bool has_stem()           const { return !__stem().empty(); }
984    _LIBCPP_INLINE_VISIBILITY bool has_extension()      const { return !__extension().empty(); }
985
986    _LIBCPP_INLINE_VISIBILITY bool is_absolute()        const { return has_root_directory(); }
987    _LIBCPP_INLINE_VISIBILITY bool is_relative()        const { return !is_absolute(); }
988
989    // iterators
990    class _LIBCPP_TYPE_VIS iterator;
991    typedef iterator const_iterator;
992
993    iterator begin() const;
994    iterator end() const;
995
996private:
997    inline _LIBCPP_INLINE_VISIBILITY
998    path& __assign_view(__string_view const& __s) noexcept { __pn_ = string_type(__s); return *this; }
999    string_type __pn_;
1000};
1001
1002inline _LIBCPP_ALWAYS_INLINE
1003void swap(path& __lhs, path& __rhs) _NOEXCEPT {
1004    __lhs.swap(__rhs);
1005}
1006
1007_LIBCPP_FUNC_VIS
1008size_t hash_value(const path& __p) _NOEXCEPT;
1009
1010inline _LIBCPP_INLINE_VISIBILITY
1011bool operator==(const path& __lhs, const path& __rhs) _NOEXCEPT
1012{ return __lhs.compare(__rhs) == 0; }
1013
1014inline _LIBCPP_INLINE_VISIBILITY
1015bool operator!=(const path& __lhs, const path& __rhs) _NOEXCEPT
1016{ return __lhs.compare(__rhs) != 0; }
1017
1018inline _LIBCPP_INLINE_VISIBILITY
1019bool operator<(const path& __lhs, const path& __rhs) _NOEXCEPT
1020{ return __lhs.compare(__rhs) < 0; }
1021
1022inline _LIBCPP_INLINE_VISIBILITY
1023bool operator<=(const path& __lhs, const path& __rhs) _NOEXCEPT
1024{ return __lhs.compare(__rhs) <= 0; }
1025
1026inline _LIBCPP_INLINE_VISIBILITY
1027bool operator>(const path& __lhs, const path& __rhs) _NOEXCEPT
1028{ return __lhs.compare(__rhs) > 0; }
1029
1030inline _LIBCPP_INLINE_VISIBILITY
1031bool operator>=(const path& __lhs, const path& __rhs) _NOEXCEPT
1032{ return __lhs.compare(__rhs) >= 0; }
1033
1034inline _LIBCPP_INLINE_VISIBILITY
1035path operator/(const path& __lhs, const path& __rhs) {
1036    return path(__lhs) /= __rhs;
1037}
1038
1039template <class _CharT, class _Traits>
1040_LIBCPP_INLINE_VISIBILITY
1041typename enable_if<is_same<_CharT, char>::value &&
1042                   is_same<_Traits, char_traits<char>>::value,
1043                   basic_ostream<_CharT, _Traits>&
1044>::type
1045operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
1046    __os << std::__quoted(__p.native());
1047    return __os;
1048}
1049
1050template <class _CharT, class _Traits>
1051_LIBCPP_INLINE_VISIBILITY
1052typename enable_if<!is_same<_CharT, char>::value ||
1053                   !is_same<_Traits, char_traits<char>>::value,
1054                   basic_ostream<_CharT, _Traits>&
1055>::type
1056operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
1057    __os << std::__quoted(__p.string<_CharT, _Traits>());
1058    return __os;
1059}
1060
1061template <class _CharT, class _Traits>
1062_LIBCPP_INLINE_VISIBILITY
1063basic_istream<_CharT, _Traits>&
1064operator>>(basic_istream<_CharT, _Traits>& __is, path& __p)
1065{
1066    basic_string<_CharT, _Traits> __tmp;
1067    __is >> __quoted(__tmp);
1068    __p = __tmp;
1069    return __is;
1070}
1071
1072template <class _Source>
1073_LIBCPP_INLINE_VISIBILITY
1074typename enable_if<__is_pathable<_Source>::value, path>::type
1075u8path(const _Source& __s){
1076    static_assert(is_same<typename __is_pathable<_Source>::__char_type, char>::value,
1077        "u8path(Source const&) requires Source have a character type of type 'char'");
1078    return path(__s);
1079}
1080
1081template <class _InputIt>
1082_LIBCPP_INLINE_VISIBILITY
1083typename enable_if<__is_pathable<_InputIt>::value, path>::type
1084u8path(_InputIt __f, _InputIt __l) {
1085    static_assert(is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
1086        "u8path(Iter, Iter) requires Iter have a value_type of type 'char'");
1087    return path(__f, __l);
1088}
1089
1090class _LIBCPP_TYPE_VIS path::iterator
1091{
1092public:
1093    typedef bidirectional_iterator_tag iterator_category;
1094
1095    typedef path                       value_type;
1096    typedef std::ptrdiff_t             difference_type;
1097    typedef const path*                pointer;
1098    typedef const path&                reference;
1099
1100    typedef void __stashing_iterator_tag; // See reverse_iterator and __is_stashing_iterator
1101public:
1102    _LIBCPP_INLINE_VISIBILITY
1103    iterator() : __stashed_elem_(), __path_ptr_(nullptr),
1104                 __entry_(), __state_(__singular) {}
1105
1106    iterator(const iterator&) = default;
1107    ~iterator() = default;
1108
1109    iterator& operator=(const iterator&) = default;
1110
1111    _LIBCPP_INLINE_VISIBILITY
1112    reference operator*() const {
1113        return __stashed_elem_;
1114    }
1115
1116    _LIBCPP_INLINE_VISIBILITY
1117    pointer operator->() const {
1118        return &__stashed_elem_;
1119    }
1120
1121    _LIBCPP_INLINE_VISIBILITY
1122    iterator& operator++() {
1123        _LIBCPP_ASSERT(__state_ != __singular,
1124                       "attempting to increment a singular iterator");
1125        _LIBCPP_ASSERT(__state_ != __at_end,
1126                      "attempting to increment the end iterator");
1127        return __increment();
1128    }
1129
1130    _LIBCPP_INLINE_VISIBILITY
1131    iterator operator++(int) {
1132        iterator __it(*this);
1133        this->operator++();
1134        return __it;
1135    }
1136
1137    _LIBCPP_INLINE_VISIBILITY
1138    iterator& operator--() {
1139        _LIBCPP_ASSERT(__state_ != __singular,
1140                       "attempting to decrement a singular iterator");
1141        _LIBCPP_ASSERT(__entry_.data() != __path_ptr_->native().data(),
1142                       "attempting to decrement the begin iterator");
1143        return __decrement();
1144    }
1145
1146    _LIBCPP_INLINE_VISIBILITY
1147    iterator operator--(int) {
1148        iterator __it(*this);
1149        this->operator--();
1150        return __it;
1151    }
1152
1153private:
1154    friend class path;
1155
1156    static constexpr unsigned char __singular = 0;
1157    static constexpr unsigned char __at_end = 6;
1158
1159    inline _LIBCPP_INLINE_VISIBILITY
1160    friend bool operator==(const iterator&, const iterator&);
1161
1162    iterator& __increment();
1163    iterator& __decrement();
1164
1165    path __stashed_elem_;
1166    const path* __path_ptr_;
1167    path::__string_view __entry_;
1168    unsigned char __state_;
1169};
1170
1171inline _LIBCPP_INLINE_VISIBILITY
1172bool operator==(const path::iterator& __lhs, const path::iterator& __rhs) {
1173    return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
1174           __lhs.__entry_.data() == __rhs.__entry_.data();
1175}
1176
1177inline _LIBCPP_INLINE_VISIBILITY
1178bool operator!=(const path::iterator& __lhs, const path::iterator& __rhs) {
1179    return !(__lhs == __rhs);
1180}
1181
1182class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error
1183{
1184public:
1185    _LIBCPP_INLINE_VISIBILITY
1186    filesystem_error(const string& __what, error_code __ec)
1187        : system_error(__ec, __what),
1188          __paths_(make_shared<_Storage>(path(), path()))
1189    {}
1190
1191    _LIBCPP_INLINE_VISIBILITY
1192    filesystem_error(const string& __what, const path& __p1, error_code __ec)
1193        : system_error(__ec, __what),
1194        __paths_(make_shared<_Storage>(__p1, path()))
1195    {}
1196
1197    _LIBCPP_INLINE_VISIBILITY
1198    filesystem_error(const string& __what, const path& __p1, const path& __p2,
1199                     error_code __ec)
1200        : system_error(__ec, __what),
1201          __paths_(make_shared<_Storage>(__p1, __p2))
1202    {}
1203
1204    _LIBCPP_INLINE_VISIBILITY
1205    const path& path1() const _NOEXCEPT {
1206        return __paths_->first;
1207    }
1208
1209    _LIBCPP_INLINE_VISIBILITY
1210    const path& path2() const _NOEXCEPT {
1211        return __paths_->second;
1212    }
1213
1214    ~filesystem_error() override; // key function
1215
1216    // TODO(ericwf): Create a custom error message.
1217    //const char* what() const _NOEXCEPT;
1218
1219private:
1220    typedef pair<path, path> _Storage;
1221    shared_ptr<_Storage> __paths_;
1222};
1223
1224template <class... _Args>
1225_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
1226#ifndef _LIBCPP_NO_EXCEPTIONS
1227void __throw_filesystem_error(_Args && ...__args)
1228{
1229    throw filesystem_error(std::forward<_Args>(__args)...);
1230}
1231#else
1232void __throw_filesystem_error(_Args&&...)
1233{
1234    _VSTD::abort();
1235}
1236#endif
1237
1238
1239// operational functions
1240
1241_LIBCPP_FUNC_VIS
1242path __canonical(const path&, const path&, error_code *__ec=nullptr);
1243_LIBCPP_FUNC_VIS
1244void __copy(const path& __from, const path& __to, copy_options __opt,
1245        error_code *__ec=nullptr);
1246_LIBCPP_FUNC_VIS
1247bool __copy_file(const path& __from, const path& __to, copy_options __opt,
1248        error_code *__ec=nullptr);
1249_LIBCPP_FUNC_VIS
1250void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
1251        error_code *__ec=nullptr);
1252_LIBCPP_FUNC_VIS
1253bool __create_directories(const path& p, error_code *ec=nullptr);
1254_LIBCPP_FUNC_VIS
1255bool __create_directory(const path& p, error_code *ec=nullptr);
1256_LIBCPP_FUNC_VIS
1257bool __create_directory(const path& p, const path & attributes,
1258        error_code *ec=nullptr);
1259_LIBCPP_FUNC_VIS
1260void __create_directory_symlink(const path& __to, const path& __new_symlink,
1261        error_code *__ec=nullptr);
1262_LIBCPP_FUNC_VIS
1263void __create_hard_link(const path& __to, const path& __new_hard_link,
1264        error_code *__ec=nullptr);
1265_LIBCPP_FUNC_VIS
1266void __create_symlink(const path& __to, const path& __new_symlink,
1267        error_code *__ec=nullptr);
1268_LIBCPP_FUNC_VIS
1269path __current_path(error_code *__ec=nullptr);
1270_LIBCPP_FUNC_VIS
1271void __current_path(const path&, error_code *__ec=nullptr);
1272_LIBCPP_FUNC_VIS
1273bool __equivalent(const path&, const path&, error_code *__ec=nullptr);
1274_LIBCPP_FUNC_VIS
1275uintmax_t __file_size(const path&, error_code *__ec=nullptr);
1276_LIBCPP_FUNC_VIS
1277uintmax_t __hard_link_count(const path&, error_code *__ec=nullptr);
1278_LIBCPP_FUNC_VIS
1279bool __fs_is_empty(const path& p, error_code *ec=nullptr);
1280_LIBCPP_FUNC_VIS
1281file_time_type __last_write_time(const path& p, error_code *ec=nullptr);
1282_LIBCPP_FUNC_VIS
1283void __last_write_time(const path& p, file_time_type new_time,
1284        error_code *ec=nullptr);
1285_LIBCPP_FUNC_VIS
1286void __permissions(const path& p, perms prms, error_code *ec=nullptr);
1287_LIBCPP_FUNC_VIS
1288path __read_symlink(const path& p, error_code *ec=nullptr);
1289_LIBCPP_FUNC_VIS
1290bool __remove(const path& p, error_code *ec=nullptr);
1291_LIBCPP_FUNC_VIS
1292uintmax_t __remove_all(const path& p, error_code *ec=nullptr);
1293_LIBCPP_FUNC_VIS
1294void __rename(const path& from, const path& to, error_code *ec=nullptr);
1295_LIBCPP_FUNC_VIS
1296void __resize_file(const path& p, uintmax_t size, error_code *ec=nullptr);
1297_LIBCPP_FUNC_VIS
1298space_info __space(const path&, error_code *__ec=nullptr);
1299_LIBCPP_FUNC_VIS
1300file_status __status(const path&, error_code *__ec=nullptr);
1301_LIBCPP_FUNC_VIS
1302file_status __symlink_status(const path&, error_code *__ec=nullptr);
1303_LIBCPP_FUNC_VIS
1304path __system_complete(const path&, error_code *__ec=nullptr);
1305_LIBCPP_FUNC_VIS
1306path __temp_directory_path(error_code *__ec=nullptr);
1307
1308inline _LIBCPP_INLINE_VISIBILITY
1309path current_path() {
1310    return __current_path();
1311}
1312
1313inline _LIBCPP_INLINE_VISIBILITY
1314path current_path(error_code& __ec) {
1315    return __current_path(&__ec);
1316}
1317
1318inline _LIBCPP_INLINE_VISIBILITY
1319void current_path(const path& __p) {
1320    __current_path(__p);
1321}
1322
1323inline _LIBCPP_INLINE_VISIBILITY
1324void current_path(const path& __p, error_code& __ec) _NOEXCEPT {
1325    __current_path(__p, &__ec);
1326}
1327
1328_LIBCPP_FUNC_VIS
1329path absolute(const path&, const path& __p2 = current_path());
1330
1331inline _LIBCPP_INLINE_VISIBILITY
1332path canonical(const path& __p, const path& __base = current_path()) {
1333    return __canonical(__p, __base);
1334}
1335
1336inline _LIBCPP_INLINE_VISIBILITY
1337path canonical(const path& __p, error_code& __ec) {
1338    path __base = __current_path(&__ec);
1339    if (__ec) return {};
1340    return __canonical(__p, __base, &__ec);
1341}
1342
1343inline _LIBCPP_INLINE_VISIBILITY
1344path canonical(const path& __p, const path& __base, error_code& __ec) {
1345    return __canonical(__p, __base, &__ec);
1346}
1347
1348inline _LIBCPP_INLINE_VISIBILITY
1349void copy(const path& __from, const path& __to) {
1350    __copy(__from, __to, copy_options::none);
1351}
1352
1353inline _LIBCPP_INLINE_VISIBILITY
1354void copy(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
1355    __copy(__from, __to, copy_options::none, &__ec);
1356}
1357
1358inline _LIBCPP_INLINE_VISIBILITY
1359void copy(const path& __from, const path& __to, copy_options __opt) {
1360    __copy(__from, __to, __opt);
1361}
1362
1363inline _LIBCPP_INLINE_VISIBILITY
1364void copy(const path& __from, const path& __to,
1365          copy_options __opt, error_code& __ec) _NOEXCEPT {
1366    __copy(__from, __to, __opt, &__ec);
1367}
1368
1369inline _LIBCPP_INLINE_VISIBILITY
1370bool copy_file(const path& __from, const path& __to) {
1371    return __copy_file(__from, __to, copy_options::none);
1372}
1373
1374inline _LIBCPP_INLINE_VISIBILITY
1375bool copy_file(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
1376    return __copy_file(__from, __to, copy_options::none, &__ec);
1377}
1378
1379inline _LIBCPP_INLINE_VISIBILITY
1380bool copy_file(const path& __from, const path& __to, copy_options __opt) {
1381    return __copy_file(__from, __to, __opt);
1382}
1383
1384inline _LIBCPP_INLINE_VISIBILITY
1385bool copy_file(const path& __from, const path& __to,
1386               copy_options __opt, error_code& __ec) _NOEXCEPT {
1387    return __copy_file(__from, __to, __opt, &__ec);
1388}
1389
1390inline _LIBCPP_INLINE_VISIBILITY
1391void copy_symlink(const path& __existing, const path& __new) {
1392    __copy_symlink(__existing, __new);
1393}
1394
1395inline _LIBCPP_INLINE_VISIBILITY
1396void copy_symlink(const path& __ext, const path& __new, error_code& __ec) _NOEXCEPT {
1397    __copy_symlink(__ext, __new, &__ec);
1398}
1399
1400inline _LIBCPP_INLINE_VISIBILITY
1401bool create_directories(const path& __p) {
1402    return __create_directories(__p);
1403}
1404
1405inline _LIBCPP_INLINE_VISIBILITY
1406bool create_directories(const path& __p, error_code& __ec) _NOEXCEPT {
1407    return __create_directories(__p, &__ec);
1408}
1409
1410inline _LIBCPP_INLINE_VISIBILITY
1411bool create_directory(const path& __p) {
1412    return __create_directory(__p);
1413}
1414
1415inline _LIBCPP_INLINE_VISIBILITY
1416bool create_directory(const path& __p, error_code& __ec) _NOEXCEPT {
1417    return __create_directory(__p, &__ec);
1418}
1419
1420inline _LIBCPP_INLINE_VISIBILITY
1421bool create_directory(const path& __p, const path& __attrs) {
1422    return __create_directory(__p, __attrs);
1423}
1424
1425inline _LIBCPP_INLINE_VISIBILITY
1426bool create_directory(const path& __p, const path& __attrs, error_code& __ec) _NOEXCEPT {
1427    return __create_directory(__p, __attrs, &__ec);
1428}
1429
1430inline _LIBCPP_INLINE_VISIBILITY
1431void create_directory_symlink(const path& __to, const path& __new) {
1432    __create_directory_symlink(__to, __new);
1433}
1434
1435inline _LIBCPP_INLINE_VISIBILITY
1436void create_directory_symlink(const path& __to, const path& __new,
1437                              error_code& __ec) _NOEXCEPT {
1438    __create_directory_symlink(__to, __new, &__ec);
1439}
1440
1441inline _LIBCPP_INLINE_VISIBILITY
1442void create_hard_link(const path& __to, const path& __new) {
1443    __create_hard_link(__to, __new);
1444}
1445
1446inline _LIBCPP_INLINE_VISIBILITY
1447void create_hard_link(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT {
1448    __create_hard_link(__to, __new, &__ec);
1449}
1450
1451inline _LIBCPP_INLINE_VISIBILITY
1452void create_symlink(const path& __to, const path& __new) {
1453    __create_symlink(__to, __new);
1454}
1455
1456inline _LIBCPP_INLINE_VISIBILITY
1457void create_symlink(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT {
1458    return __create_symlink(__to, __new, &__ec);
1459}
1460
1461inline _LIBCPP_INLINE_VISIBILITY
1462bool status_known(file_status __s) _NOEXCEPT {
1463    return __s.type() != file_type::none;
1464}
1465
1466inline _LIBCPP_INLINE_VISIBILITY
1467bool exists(file_status __s) _NOEXCEPT {
1468    return status_known(__s) && __s.type() != file_type::not_found;
1469}
1470
1471inline _LIBCPP_INLINE_VISIBILITY
1472bool exists(const path& __p) {
1473    return exists(__status(__p));
1474}
1475
1476inline _LIBCPP_INLINE_VISIBILITY
1477bool exists(const path& __p, error_code& __ec) _NOEXCEPT {
1478    auto __s = __status(__p, &__ec);
1479    if (status_known(__s)) __ec.clear();
1480    return exists(__s);
1481}
1482
1483inline _LIBCPP_INLINE_VISIBILITY
1484bool equivalent(const path& __p1, const path& __p2) {
1485    return __equivalent(__p1, __p2);
1486}
1487
1488inline _LIBCPP_INLINE_VISIBILITY
1489bool equivalent(const path& __p1, const path& __p2, error_code& __ec) _NOEXCEPT {
1490    return __equivalent(__p1, __p2, &__ec);
1491}
1492
1493inline _LIBCPP_INLINE_VISIBILITY
1494uintmax_t file_size(const path& __p) {
1495    return __file_size(__p);
1496}
1497
1498inline _LIBCPP_INLINE_VISIBILITY
1499uintmax_t file_size(const path& __p, error_code& __ec) _NOEXCEPT {
1500    return __file_size(__p, &__ec);
1501}
1502
1503inline _LIBCPP_INLINE_VISIBILITY
1504uintmax_t hard_link_count(const path& __p) {
1505    return __hard_link_count(__p);
1506}
1507
1508inline _LIBCPP_INLINE_VISIBILITY
1509uintmax_t hard_link_count(const path& __p, error_code& __ec) _NOEXCEPT {
1510    return __hard_link_count(__p, &__ec);
1511}
1512
1513inline _LIBCPP_INLINE_VISIBILITY
1514bool is_block_file(file_status __s) _NOEXCEPT {
1515    return __s.type() == file_type::block;
1516}
1517
1518inline _LIBCPP_INLINE_VISIBILITY
1519bool is_block_file(const path& __p) {
1520    return is_block_file(__status(__p));
1521}
1522
1523inline _LIBCPP_INLINE_VISIBILITY
1524bool is_block_file(const path& __p, error_code& __ec) _NOEXCEPT {
1525    return is_block_file(__status(__p, &__ec));
1526}
1527
1528inline _LIBCPP_INLINE_VISIBILITY
1529bool is_character_file(file_status __s) _NOEXCEPT {
1530    return __s.type() == file_type::character;
1531}
1532
1533inline _LIBCPP_INLINE_VISIBILITY
1534bool is_character_file(const path& __p) {
1535    return is_character_file(__status(__p));
1536}
1537
1538inline _LIBCPP_INLINE_VISIBILITY
1539bool is_character_file(const path& __p, error_code& __ec) _NOEXCEPT {
1540    return is_character_file(__status(__p, &__ec));
1541}
1542
1543inline _LIBCPP_INLINE_VISIBILITY
1544bool is_directory(file_status __s) _NOEXCEPT {
1545    return __s.type() == file_type::directory;
1546}
1547
1548inline _LIBCPP_INLINE_VISIBILITY
1549bool is_directory(const path& __p) {
1550    return is_directory(__status(__p));
1551}
1552
1553inline _LIBCPP_INLINE_VISIBILITY
1554bool is_directory(const path& __p, error_code& __ec) _NOEXCEPT {
1555    return is_directory(__status(__p, &__ec));
1556}
1557
1558inline _LIBCPP_INLINE_VISIBILITY
1559bool is_empty(const path& __p) {
1560    return __fs_is_empty(__p);
1561}
1562
1563inline _LIBCPP_INLINE_VISIBILITY
1564bool is_empty(const path& __p, error_code& __ec) _NOEXCEPT {
1565    return __fs_is_empty(__p, &__ec);
1566}
1567
1568inline _LIBCPP_INLINE_VISIBILITY
1569bool is_fifo(file_status __s) _NOEXCEPT {
1570    return __s.type() == file_type::fifo;
1571}
1572inline _LIBCPP_INLINE_VISIBILITY
1573bool is_fifo(const path& __p) {
1574    return is_fifo(__status(__p));
1575}
1576
1577inline _LIBCPP_INLINE_VISIBILITY
1578bool is_fifo(const path& __p, error_code& __ec) _NOEXCEPT {
1579    return is_fifo(__status(__p, &__ec));
1580}
1581
1582inline _LIBCPP_INLINE_VISIBILITY
1583bool is_regular_file(file_status __s) _NOEXCEPT {
1584    return __s.type() == file_type::regular;
1585}
1586
1587inline _LIBCPP_INLINE_VISIBILITY
1588bool is_regular_file(const path& __p) {
1589    return is_regular_file(__status(__p));
1590}
1591
1592inline _LIBCPP_INLINE_VISIBILITY
1593bool is_regular_file(const path& __p, error_code& __ec) _NOEXCEPT {
1594    return is_regular_file(__status(__p, &__ec));
1595}
1596
1597inline _LIBCPP_INLINE_VISIBILITY
1598bool is_socket(file_status __s) _NOEXCEPT {
1599    return __s.type() == file_type::socket;
1600}
1601
1602inline _LIBCPP_INLINE_VISIBILITY
1603bool is_socket(const path& __p) {
1604    return is_socket(__status(__p));
1605}
1606
1607inline _LIBCPP_INLINE_VISIBILITY
1608bool is_socket(const path& __p, error_code& __ec) _NOEXCEPT {
1609    return is_socket(__status(__p, &__ec));
1610}
1611
1612inline _LIBCPP_INLINE_VISIBILITY
1613bool is_symlink(file_status __s) _NOEXCEPT {
1614    return __s.type() == file_type::symlink;
1615}
1616
1617inline _LIBCPP_INLINE_VISIBILITY
1618bool is_symlink(const path& __p) {
1619    return is_symlink(__symlink_status(__p));
1620}
1621
1622inline _LIBCPP_INLINE_VISIBILITY
1623bool is_symlink(const path& __p, error_code& __ec) _NOEXCEPT {
1624    return is_symlink(__symlink_status(__p, &__ec));
1625}
1626
1627inline _LIBCPP_INLINE_VISIBILITY
1628bool is_other(file_status __s) _NOEXCEPT {
1629    return exists(__s)
1630        && !is_regular_file(__s) && !is_directory(__s) && !is_symlink(__s);
1631}
1632
1633inline _LIBCPP_INLINE_VISIBILITY
1634bool is_other(const path& __p) {
1635    return is_other(__status(__p));
1636}
1637
1638inline _LIBCPP_INLINE_VISIBILITY
1639bool is_other(const path& __p, error_code& __ec) _NOEXCEPT {
1640    return is_other(__status(__p, &__ec));
1641}
1642
1643inline _LIBCPP_INLINE_VISIBILITY
1644file_time_type last_write_time(const path& __p) {
1645    return __last_write_time(__p);
1646}
1647
1648inline _LIBCPP_INLINE_VISIBILITY
1649file_time_type last_write_time(const path& __p, error_code& __ec) _NOEXCEPT {
1650    return __last_write_time(__p, &__ec);
1651}
1652
1653inline _LIBCPP_INLINE_VISIBILITY
1654void last_write_time(const path& __p, file_time_type __t) {
1655    __last_write_time(__p, __t);
1656}
1657
1658inline _LIBCPP_INLINE_VISIBILITY
1659void last_write_time(const path& __p, file_time_type __t, error_code& __ec) _NOEXCEPT {
1660    __last_write_time(__p, __t, &__ec);
1661}
1662
1663inline _LIBCPP_INLINE_VISIBILITY
1664void permissions(const path& __p, perms __prms) {
1665    __permissions(__p, __prms);
1666}
1667
1668inline _LIBCPP_INLINE_VISIBILITY
1669void permissions(const path& __p, perms __prms, error_code& __ec)  {
1670    __permissions(__p, __prms, &__ec);
1671}
1672
1673inline _LIBCPP_INLINE_VISIBILITY
1674path read_symlink(const path& __p) {
1675    return __read_symlink(__p);
1676}
1677
1678inline _LIBCPP_INLINE_VISIBILITY
1679path read_symlink(const path& __p, error_code& __ec) {
1680    return __read_symlink(__p, &__ec);
1681}
1682
1683inline _LIBCPP_INLINE_VISIBILITY
1684bool remove(const path& __p) {
1685    return __remove(__p);
1686}
1687
1688inline _LIBCPP_INLINE_VISIBILITY
1689bool remove(const path& __p, error_code& __ec) _NOEXCEPT {
1690    return __remove(__p, &__ec);
1691}
1692
1693inline _LIBCPP_INLINE_VISIBILITY
1694uintmax_t remove_all(const path& __p) {
1695    return __remove_all(__p);
1696}
1697
1698inline _LIBCPP_INLINE_VISIBILITY
1699uintmax_t remove_all(const path& __p, error_code& __ec) _NOEXCEPT {
1700    return __remove_all(__p, &__ec);
1701}
1702
1703inline _LIBCPP_INLINE_VISIBILITY
1704void rename(const path& __from, const path& __to) {
1705    return __rename(__from, __to);
1706}
1707
1708inline _LIBCPP_INLINE_VISIBILITY
1709void rename(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
1710    return __rename(__from, __to, &__ec);
1711}
1712
1713inline _LIBCPP_INLINE_VISIBILITY
1714void resize_file(const path& __p, uintmax_t __ns) {
1715    return __resize_file(__p, __ns);
1716}
1717
1718inline _LIBCPP_INLINE_VISIBILITY
1719void resize_file(const path& __p, uintmax_t __ns, error_code& __ec) _NOEXCEPT {
1720    return __resize_file(__p, __ns, &__ec);
1721}
1722
1723inline _LIBCPP_INLINE_VISIBILITY
1724space_info space(const path& __p) {
1725    return __space(__p);
1726}
1727
1728inline _LIBCPP_INLINE_VISIBILITY
1729space_info space(const path& __p, error_code& __ec) _NOEXCEPT {
1730    return __space(__p, &__ec);
1731}
1732
1733inline _LIBCPP_INLINE_VISIBILITY
1734file_status status(const path& __p) {
1735    return __status(__p);
1736}
1737
1738inline _LIBCPP_INLINE_VISIBILITY
1739file_status status(const path& __p, error_code& __ec) _NOEXCEPT {
1740    return __status(__p, &__ec);
1741}
1742
1743inline _LIBCPP_INLINE_VISIBILITY
1744file_status symlink_status(const path& __p) {
1745    return __symlink_status(__p);
1746}
1747
1748inline _LIBCPP_INLINE_VISIBILITY
1749file_status symlink_status(const path& __p, error_code& __ec) _NOEXCEPT {
1750    return __symlink_status(__p, &__ec);
1751}
1752
1753inline _LIBCPP_INLINE_VISIBILITY
1754path system_complete(const path& __p) {
1755    return __system_complete(__p);
1756}
1757
1758inline _LIBCPP_INLINE_VISIBILITY
1759path system_complete(const path& __p, error_code& __ec) {
1760    return __system_complete(__p, &__ec);
1761}
1762
1763inline _LIBCPP_INLINE_VISIBILITY
1764path temp_directory_path() {
1765    return __temp_directory_path();
1766}
1767
1768inline _LIBCPP_INLINE_VISIBILITY
1769path temp_directory_path(error_code& __ec) {
1770    return __temp_directory_path(&__ec);
1771}
1772
1773
1774class directory_entry
1775{
1776    typedef _VSTD_FS::path _Path;
1777
1778public:
1779    // constructors and destructors
1780    directory_entry() _NOEXCEPT = default;
1781    directory_entry(directory_entry const&) = default;
1782    directory_entry(directory_entry&&) _NOEXCEPT = default;
1783
1784    _LIBCPP_INLINE_VISIBILITY
1785    explicit directory_entry(_Path const& __p) : __p_(__p) {}
1786
1787    ~directory_entry() {}
1788
1789    directory_entry& operator=(directory_entry const&) = default;
1790    directory_entry& operator=(directory_entry&&) _NOEXCEPT = default;
1791
1792    _LIBCPP_INLINE_VISIBILITY
1793    void assign(_Path const& __p) {
1794        __p_ = __p;
1795    }
1796
1797    _LIBCPP_INLINE_VISIBILITY
1798    void replace_filename(_Path const& __p) {
1799        __p_ = __p_.parent_path() / __p;
1800    }
1801
1802    _LIBCPP_INLINE_VISIBILITY
1803    _Path const& path() const _NOEXCEPT {
1804        return __p_;
1805    }
1806
1807    _LIBCPP_INLINE_VISIBILITY
1808    operator const _Path&() const _NOEXCEPT {
1809        return __p_;
1810    }
1811
1812    _LIBCPP_INLINE_VISIBILITY
1813    file_status status() const {
1814        return _VSTD_FS::status(__p_);
1815    }
1816
1817    _LIBCPP_INLINE_VISIBILITY
1818    file_status status(error_code& __ec) const _NOEXCEPT {
1819        return _VSTD_FS::status(__p_, __ec);
1820    }
1821
1822    _LIBCPP_INLINE_VISIBILITY
1823    file_status symlink_status() const {
1824        return _VSTD_FS::symlink_status(__p_);
1825    }
1826
1827    _LIBCPP_INLINE_VISIBILITY
1828    file_status symlink_status(error_code& __ec) const _NOEXCEPT {
1829        return _VSTD_FS::symlink_status(__p_, __ec);
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
1857    _LIBCPP_INLINE_VISIBILITY
1858    bool operator>=(directory_entry const& __rhs) const _NOEXCEPT {
1859        return __p_ >= __rhs.__p_;
1860    }
1861private:
1862    _Path __p_;
1863};
1864
1865
1866class directory_iterator;
1867class recursive_directory_iterator;
1868class __dir_stream;
1869
1870class __dir_element_proxy {
1871public:
1872
1873    inline _LIBCPP_INLINE_VISIBILITY
1874    directory_entry operator*() { return _VSTD::move(__elem_); }
1875
1876private:
1877    friend class directory_iterator;
1878    friend class recursive_directory_iterator;
1879    explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
1880    __dir_element_proxy(__dir_element_proxy&& __o) : __elem_(_VSTD::move(__o.__elem_)) {}
1881    directory_entry __elem_;
1882};
1883
1884class directory_iterator
1885{
1886public:
1887    typedef directory_entry value_type;
1888    typedef ptrdiff_t difference_type;
1889    typedef value_type const* pointer;
1890    typedef value_type const& reference;
1891    typedef input_iterator_tag iterator_category;
1892
1893public:
1894    //ctor & dtor
1895    directory_iterator() _NOEXCEPT
1896    { }
1897
1898    explicit directory_iterator(const path& __p)
1899        : directory_iterator(__p, nullptr)
1900    { }
1901
1902    directory_iterator(const path& __p, directory_options __opts)
1903        : directory_iterator(__p, nullptr, __opts)
1904    { }
1905
1906    directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
1907        : directory_iterator(__p, &__ec)
1908    { }
1909
1910    directory_iterator(const path& __p, directory_options __opts,
1911                       error_code& __ec) _NOEXCEPT
1912        : directory_iterator(__p, &__ec, __opts)
1913    { }
1914
1915    directory_iterator(const directory_iterator&) = default;
1916    directory_iterator(directory_iterator&&) = default;
1917    directory_iterator& operator=(const directory_iterator&) = default;
1918
1919    directory_iterator& operator=(directory_iterator&& __o) _NOEXCEPT {
1920        // non-default implementation provided to support self-move assign.
1921        if (this != &__o) {
1922            __imp_ = _VSTD::move(__o.__imp_);
1923        }
1924        return *this;
1925    }
1926
1927    ~directory_iterator() = default;
1928
1929    const directory_entry& operator*() const {
1930        _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
1931        return __dereference();
1932    }
1933
1934    const directory_entry* operator->() const
1935    { return &**this; }
1936
1937    directory_iterator& operator++()
1938    { return __increment(); }
1939
1940    __dir_element_proxy operator++(int) {
1941        __dir_element_proxy __p(**this);
1942        __increment();
1943        return __p;
1944    }
1945
1946    directory_iterator& increment(error_code& __ec) _NOEXCEPT
1947    { return __increment(&__ec); }
1948
1949private:
1950    inline _LIBCPP_INLINE_VISIBILITY
1951    friend bool operator==(const directory_iterator& __lhs,
1952                           const directory_iterator& __rhs) _NOEXCEPT;
1953
1954    // construct the dir_stream
1955    _LIBCPP_FUNC_VIS
1956    directory_iterator(const path&, error_code *,
1957                       directory_options = directory_options::none);
1958
1959    _LIBCPP_FUNC_VIS
1960    directory_iterator& __increment(error_code * __ec = nullptr);
1961
1962    _LIBCPP_FUNC_VIS
1963    const directory_entry& __dereference() const;
1964
1965private:
1966    shared_ptr<__dir_stream> __imp_;
1967};
1968
1969
1970inline _LIBCPP_INLINE_VISIBILITY
1971bool operator==(const directory_iterator& __lhs,
1972                const directory_iterator& __rhs) _NOEXCEPT {
1973    return __lhs.__imp_ == __rhs.__imp_;
1974}
1975
1976inline _LIBCPP_INLINE_VISIBILITY
1977bool operator!=(const directory_iterator& __lhs,
1978                const directory_iterator& __rhs) _NOEXCEPT {
1979    return !(__lhs == __rhs);
1980}
1981
1982// enable directory_iterator range-based for statements
1983inline _LIBCPP_INLINE_VISIBILITY
1984directory_iterator begin(directory_iterator __iter) _NOEXCEPT {
1985    return __iter;
1986}
1987
1988inline _LIBCPP_INLINE_VISIBILITY
1989directory_iterator end(const directory_iterator&) _NOEXCEPT {
1990    return directory_iterator();
1991}
1992
1993class recursive_directory_iterator {
1994public:
1995    using value_type = directory_entry;
1996    using difference_type = std::ptrdiff_t;
1997    using pointer = directory_entry const *;
1998    using reference = directory_entry const &;
1999    using iterator_category = std::input_iterator_tag;
2000
2001public:
2002    // constructors and destructor
2003    _LIBCPP_INLINE_VISIBILITY
2004    recursive_directory_iterator()  _NOEXCEPT
2005        : __rec_(false)
2006    {}
2007
2008    _LIBCPP_INLINE_VISIBILITY
2009    explicit recursive_directory_iterator(const path& __p,
2010                directory_options __xoptions = directory_options::none)
2011        : recursive_directory_iterator(__p, __xoptions,  nullptr)
2012    { }
2013
2014    _LIBCPP_INLINE_VISIBILITY
2015    recursive_directory_iterator(const path& __p,
2016        directory_options __xoptions, error_code& __ec) _NOEXCEPT
2017        : recursive_directory_iterator(__p, __xoptions, &__ec)
2018    { }
2019
2020    _LIBCPP_INLINE_VISIBILITY
2021    recursive_directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
2022        : recursive_directory_iterator(__p, directory_options::none,  &__ec)
2023    { }
2024
2025    recursive_directory_iterator(const recursive_directory_iterator&) = default;
2026    recursive_directory_iterator(recursive_directory_iterator&&) = default;
2027
2028    recursive_directory_iterator &
2029    operator=(const recursive_directory_iterator&) = default;
2030
2031    _LIBCPP_INLINE_VISIBILITY
2032    recursive_directory_iterator &
2033    operator=(recursive_directory_iterator&& __o) noexcept {
2034        // non-default implementation provided to support self-move assign.
2035        if (this != &__o) {
2036            __imp_ = _VSTD::move(__o.__imp_);
2037            __rec_ = __o.__rec_;
2038        }
2039        return *this;
2040    }
2041
2042    ~recursive_directory_iterator() = default;
2043
2044    _LIBCPP_INLINE_VISIBILITY
2045    const directory_entry& operator*() const
2046    { return __dereference(); }
2047
2048    _LIBCPP_INLINE_VISIBILITY
2049    const directory_entry* operator->() const
2050    { return &__dereference(); }
2051
2052    recursive_directory_iterator& operator++()
2053    { return __increment(); }
2054
2055    _LIBCPP_INLINE_VISIBILITY
2056    __dir_element_proxy operator++(int) {
2057        __dir_element_proxy __p(**this);
2058        __increment();
2059        return __p;
2060    }
2061
2062    _LIBCPP_INLINE_VISIBILITY
2063    recursive_directory_iterator& increment(error_code& __ec) _NOEXCEPT
2064    { return __increment(&__ec); }
2065
2066    _LIBCPP_FUNC_VIS directory_options options() const;
2067    _LIBCPP_FUNC_VIS int  depth() const;
2068
2069    _LIBCPP_INLINE_VISIBILITY
2070    void pop() { __pop(); }
2071
2072    _LIBCPP_INLINE_VISIBILITY
2073    void pop(error_code& __ec)
2074    { __pop(&__ec); }
2075
2076    _LIBCPP_INLINE_VISIBILITY
2077    bool recursion_pending() const
2078    { return __rec_; }
2079
2080    _LIBCPP_INLINE_VISIBILITY
2081    void disable_recursion_pending()
2082    { __rec_ = false; }
2083
2084private:
2085    recursive_directory_iterator(const path& __p, directory_options __opt,
2086                                 error_code *__ec);
2087
2088    _LIBCPP_FUNC_VIS
2089    const directory_entry& __dereference() const;
2090
2091    _LIBCPP_FUNC_VIS
2092    bool __try_recursion(error_code* __ec);
2093
2094    _LIBCPP_FUNC_VIS
2095    void __advance(error_code* __ec=nullptr);
2096
2097    _LIBCPP_FUNC_VIS
2098    recursive_directory_iterator& __increment(error_code *__ec=nullptr);
2099
2100    _LIBCPP_FUNC_VIS
2101    void __pop(error_code* __ec=nullptr);
2102
2103    inline _LIBCPP_INLINE_VISIBILITY
2104    friend bool operator==(const recursive_directory_iterator&,
2105                           const recursive_directory_iterator&) _NOEXCEPT;
2106
2107    struct __shared_imp;
2108    shared_ptr<__shared_imp> __imp_;
2109    bool __rec_;
2110};                                     // class recursive_directory_iterator
2111
2112
2113inline _LIBCPP_INLINE_VISIBILITY
2114bool operator==(const recursive_directory_iterator& __lhs,
2115                const recursive_directory_iterator& __rhs) _NOEXCEPT
2116{
2117    return __lhs.__imp_ == __rhs.__imp_;
2118}
2119
2120_LIBCPP_INLINE_VISIBILITY
2121inline bool operator!=(const recursive_directory_iterator& __lhs,
2122                        const recursive_directory_iterator& __rhs) _NOEXCEPT
2123{
2124    return !(__lhs == __rhs);
2125}
2126// enable recursive_directory_iterator range-based for statements
2127inline _LIBCPP_INLINE_VISIBILITY
2128recursive_directory_iterator begin(recursive_directory_iterator __iter) _NOEXCEPT {
2129    return __iter;
2130}
2131
2132inline _LIBCPP_INLINE_VISIBILITY
2133recursive_directory_iterator end(const recursive_directory_iterator&) _NOEXCEPT {
2134    return recursive_directory_iterator();
2135}
2136
2137_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
2138
2139#endif // _LIBCPP_EXPERIMENTAL_FILESYSTEM
2140