blob: 10590a8c06728bc9b620145a5fc84b81f200d9a5 [file] [log] [blame]
Eric Fiselier6e9a6942016-06-17 19:46:40 +00001// -*- 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
Eric Fiselier2645dbe2016-07-23 03:10:56 +0000231#include <string_view>
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000232
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
Eric Fiselier833d6442016-09-15 22:27:07 +0000252enum class _LIBCPP_ENUM_VIS file_type : signed char
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000253{
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
Eric Fiselier833d6442016-09-15 22:27:07 +0000266enum class _LIBCPP_ENUM_VIS perms : unsigned
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000267{
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,
Eric Fiselier7c96ddb2016-06-21 22:42:42 +0000295 symlink_nofollow = 0x40000
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000296};
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
Eric Fiselier833d6442016-09-15 22:27:07 +0000326enum class _LIBCPP_ENUM_VIS copy_options : unsigned short
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000327{
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
Eric Fiselier833d6442016-09-15 22:27:07 +0000370enum class _LIBCPP_ENUM_VIS directory_options : unsigned char
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000371{
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 explicit file_status(file_type __ft = file_type::none,
412 perms __prms = perms::unknown) _NOEXCEPT
413 : __ft_(__ft), __prms_(__prms)
414 {}
415
416 file_status(const file_status&) _NOEXCEPT = default;
417 file_status(file_status&&) _NOEXCEPT = default;
418
419 _LIBCPP_INLINE_VISIBILITY
420 ~file_status() {}
421
422 file_status& operator=(const file_status&) _NOEXCEPT = default;
423 file_status& operator=(file_status&&) _NOEXCEPT = default;
424
425 // observers
426 _LIBCPP_ALWAYS_INLINE
427 file_type type() const _NOEXCEPT {
428 return __ft_;
429 }
430
431 _LIBCPP_ALWAYS_INLINE
432 perms permissions() const _NOEXCEPT {
433 return __prms_;
434 }
435
436 // modifiers
437 _LIBCPP_ALWAYS_INLINE
438 void type(file_type __ft) _NOEXCEPT {
439 __ft_ = __ft;
440 }
441
442 _LIBCPP_ALWAYS_INLINE
443 void permissions(perms __p) _NOEXCEPT {
444 __prms_ = __p;
445 }
446private:
447 file_type __ft_;
448 perms __prms_;
449};
450
451class _LIBCPP_TYPE_VIS directory_entry;
452
453template <class _Tp> struct __can_convert_char {
454 static const bool value = false;
455};
Eric Fiselier113315b2016-08-28 21:26:01 +0000456template <class _Tp> struct __can_convert_char<const _Tp>
457 : public __can_convert_char<_Tp> {
458};
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000459template <> struct __can_convert_char<char> {
460 static const bool value = true;
461 using __char_type = char;
462};
463template <> struct __can_convert_char<wchar_t> {
464 static const bool value = true;
465 using __char_type = wchar_t;
466};
467template <> struct __can_convert_char<char16_t> {
468 static const bool value = true;
469 using __char_type = char16_t;
470};
471template <> struct __can_convert_char<char32_t> {
472 static const bool value = true;
473 using __char_type = char32_t;
474};
475
476template <class _ECharT>
477typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
478__is_separator(_ECharT __e) {
479 return __e == _ECharT('/');
480};
481
482struct _NullSentinal {};
483
484template <class _Tp>
485using _Void = void;
486
487template <class _Tp, class = void>
488struct __is_pathable_string : public false_type {};
489
490template <class _ECharT, class _Traits, class _Alloc>
491struct __is_pathable_string<basic_string<_ECharT, _Traits, _Alloc>,
492 _Void<typename __can_convert_char<_ECharT>::__char_type>>
493: public __can_convert_char<_ECharT>
494{
495 using _Str = basic_string<_ECharT, _Traits, _Alloc>;
496 using _Base = __can_convert_char<_ECharT>;
497 static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
498 static _ECharT const* __range_end(_Str const& __s) { return __s.data() + __s.length(); }
499 static _ECharT __first_or_null(_Str const& __s) {
500 return __s.empty() ? _ECharT{} : __s[0];
501 }
502};
503
Eric Fiselier2645dbe2016-07-23 03:10:56 +0000504
505template <class _ECharT, class _Traits>
506struct __is_pathable_string<basic_string_view<_ECharT, _Traits>,
507 _Void<typename __can_convert_char<_ECharT>::__char_type>>
508: public __can_convert_char<_ECharT>
509{
510 using _Str = basic_string_view<_ECharT, _Traits>;
511 using _Base = __can_convert_char<_ECharT>;
512 static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
513 static _ECharT const* __range_end(_Str const& __s) { return __s.data() + __s.length(); }
514 static _ECharT __first_or_null(_Str const& __s) {
515 return __s.empty() ? _ECharT{} : __s[0];
516 }
517};
518
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000519template <class _Source,
520 class _DS = typename decay<_Source>::type,
521 class _UnqualPtrType = typename remove_const<
522 typename remove_pointer<_DS>::type>::type,
523 bool _IsCharPtr = is_pointer<_DS>::value &&
524 __can_convert_char<_UnqualPtrType>::value
525 >
526struct __is_pathable_char_array : false_type {};
527
528template <class _Source, class _ECharT, class _UPtr>
529struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
530 : __can_convert_char<typename remove_const<_ECharT>::type>
531{
532 using _Base = __can_convert_char<typename remove_const<_ECharT>::type>;
533
534 static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
535 static _ECharT const* __range_end(const _ECharT* __b)
536 {
537 using _Iter = const _ECharT*;
538 const _ECharT __sentinal = _ECharT{};
539 _Iter __e = __b;
540 for (; *__e != __sentinal; ++__e)
541 ;
542 return __e;
543 }
544
545 static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
546};
547
548template <class _Iter, bool _IsIt = __is_input_iterator<_Iter>::value, class = void>
549struct __is_pathable_iter : false_type {};
550
551template <class _Iter>
552struct __is_pathable_iter<_Iter, true,
553 _Void<typename __can_convert_char<typename iterator_traits<_Iter>::value_type>::__char_type>>
554 : __can_convert_char<typename iterator_traits<_Iter>::value_type>
555{
556 using _ECharT = typename iterator_traits<_Iter>::value_type;
557 using _Base = __can_convert_char<_ECharT>;
558
559 static _Iter __range_begin(_Iter __b) { return __b; }
560 static _NullSentinal __range_end(_Iter) { return _NullSentinal{}; }
561
562 static _ECharT __first_or_null(_Iter __b) { return *__b; }
563};
564
565template <class _Tp, bool _IsStringT = __is_pathable_string<_Tp>::value,
566 bool _IsCharIterT = __is_pathable_char_array<_Tp>::value,
567 bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value
568 >
569struct __is_pathable : false_type {
570 static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false");
571};
572
573template <class _Tp>
574struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {};
575
576
577template <class _Tp>
578struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {};
579
580
581template <class _Tp>
582struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
583
584
585template <class _ECharT>
586struct _PathCVT {
587 static_assert(__can_convert_char<_ECharT>::value, "Char type not convertible");
588
589 typedef __narrow_to_utf8<sizeof(_ECharT)*__CHAR_BIT__> _Narrower;
590
591 static void __append_range(string& __dest, _ECharT const* __b, _ECharT const* __e) {
592 _Narrower()(back_inserter(__dest), __b, __e);
593 }
594
595 template <class _Iter>
596 static void __append_range(string& __dest, _Iter __b, _Iter __e) {
597 static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
598 if (__b == __e) return;
599 basic_string<_ECharT> __tmp(__b, __e);
600 _Narrower()(back_inserter(__dest), __tmp.data(),
601 __tmp.data() + __tmp.length());
602 }
603
604 template <class _Iter>
605 static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
606 static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
607 const _ECharT __sentinal = _ECharT{};
608 if (*__b == __sentinal) return;
609 basic_string<_ECharT> __tmp;
610 for (; *__b != __sentinal; ++__b)
611 __tmp.push_back(*__b);
612 _Narrower()(back_inserter(__dest), __tmp.data(),
613 __tmp.data() + __tmp.length());
614 }
615
616 template <class _Source>
617 static void __append_source(string& __dest, _Source const& __s)
618 {
619 using _Traits = __is_pathable<_Source>;
620 __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s));
621 }
622};
623
624template <>
625struct _PathCVT<char> {
626 template <class _Iter>
627 static void __append_range(string& __dest, _Iter __b, _Iter __e) {
628 for (; __b != __e; ++__b)
629 __dest.push_back(*__b);
630 }
631
632 template <class _Iter>
633 static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
634 const char __sentinal = char{};
635 for (; *__b != __sentinal; ++__b)
636 __dest.push_back(*__b);
637 }
638
639 template <class _Source>
640 static void __append_source(string& __dest, _Source const& __s)
641 {
642 using _Traits = __is_pathable<_Source>;
643 __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s));
644 }
645};
646
647
648class _LIBCPP_TYPE_VIS path
649{
650 template <class _SourceOrIter, class _Tp = path&>
651 using _EnableIfPathable = typename
652 enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
653
654 template <class _Tp>
655 using _SourceChar = typename __is_pathable<_Tp>::__char_type;
656
657 template <class _Tp>
658 using _SourceCVT = _PathCVT<_SourceChar<_Tp>>;
659
660public:
661 typedef char value_type;
662 typedef basic_string<value_type> string_type;
Eric Fiselier2645dbe2016-07-23 03:10:56 +0000663 typedef _VSTD::string_view __string_view;
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000664 static _LIBCPP_CONSTEXPR value_type preferred_separator = '/';
665
666 // constructors and destructor
667 _LIBCPP_INLINE_VISIBILITY path() _NOEXCEPT {}
668 _LIBCPP_INLINE_VISIBILITY path(const path& __p) : __pn_(__p.__pn_) {}
669 _LIBCPP_INLINE_VISIBILITY path(path&& __p) _NOEXCEPT : __pn_(_VSTD::move(__p.__pn_)) {}
670
671 _LIBCPP_INLINE_VISIBILITY
672 path(string_type&& __s) _NOEXCEPT : __pn_(_VSTD::move(__s)) {}
673
674 template <
675 class _Source,
676 class = _EnableIfPathable<_Source, void>
677 >
678 path(const _Source& __src) {
679 _SourceCVT<_Source>::__append_source(__pn_, __src);
680 }
681
682 template <class _InputIt>
683 path(_InputIt __first, _InputIt __last) {
684 typedef typename iterator_traits<_InputIt>::value_type _ItVal;
685 _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
686 }
687
688 // TODO Implement locale conversions.
689 template <class _Source,
690 class = _EnableIfPathable<_Source, void>
691 >
692 path(const _Source& __src, const locale& __loc);
693 template <class _InputIt>
694 path(_InputIt __first, _InputIt _last, const locale& __loc);
695
696 _LIBCPP_INLINE_VISIBILITY
697 ~path() = default;
698
699 // assignments
700 _LIBCPP_INLINE_VISIBILITY
701 path& operator=(const path& __p) {
702 __pn_ = __p.__pn_;
703 return *this;
704 }
705
706 _LIBCPP_INLINE_VISIBILITY
707 path& operator=(path&& __p) _NOEXCEPT {
708 __pn_ = _VSTD::move(__p.__pn_);
709 return *this;
710 }
711
712 _LIBCPP_INLINE_VISIBILITY
713 path& operator=(string_type&& __s) _NOEXCEPT {
714 __pn_ = _VSTD::move(__s);
715 return *this;
716 }
717
718 _LIBCPP_INLINE_VISIBILITY
719 path& assign(string_type&& __s) _NOEXCEPT {
720 __pn_ = _VSTD::move(__s);
721 return *this;
722 }
723
724 template <class _Source>
725 _LIBCPP_INLINE_VISIBILITY
726 _EnableIfPathable<_Source>
727 operator=(const _Source& __src)
728 { return this->assign(__src); }
729
730
731 template <class _Source>
732 _EnableIfPathable<_Source>
733 assign(const _Source& __src) {
734 __pn_.clear();
735 _SourceCVT<_Source>::__append_source(__pn_, __src);
736 return *this;
737 }
738
739 template <class _InputIt>
740 path& assign(_InputIt __first, _InputIt __last) {
741 typedef typename iterator_traits<_InputIt>::value_type _ItVal;
742 __pn_.clear();
743 _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
744 return *this;
745 }
746
747private:
748 template <class _ECharT>
749 void __append_sep_if_needed(_ECharT __first_or_null) {
750 const _ECharT __null_val = {};
751 bool __append_sep = !empty() &&
752 !__is_separator(__pn_.back()) &&
753 __first_or_null != __null_val && // non-empty
754 !__is_separator(__first_or_null);
755 if (__append_sep)
756 __pn_ += preferred_separator;
757 }
758
759public:
760 // appends
761 path& operator/=(const path& __p) {
762 __append_sep_if_needed(__p.empty() ? char{} : __p.__pn_[0]);
763 __pn_ += __p.native();
764 return *this;
765 }
766
767 template <class _Source>
768 _LIBCPP_INLINE_VISIBILITY
769 _EnableIfPathable<_Source>
770 operator/=(const _Source& __src) {
771 return this->append(__src);
772 }
773
774 template <class _Source>
775 _EnableIfPathable<_Source>
776 append(const _Source& __src) {
777 using _Traits = __is_pathable<_Source>;
778 using _CVT = _PathCVT<_SourceChar<_Source>>;
779 __append_sep_if_needed(_Traits::__first_or_null(__src));
780 _CVT::__append_source(__pn_, __src);
781 return *this;
782 }
783
784 template <class _InputIt>
785 path& append(_InputIt __first, _InputIt __last) {
786 typedef typename iterator_traits<_InputIt>::value_type _ItVal;
787 static_assert(__can_convert_char<_ItVal>::value, "Must convertible");
788 using _CVT = _PathCVT<_ItVal>;
789 if (__first != __last) {
790 __append_sep_if_needed(*__first);
791 _CVT::__append_range(__pn_, __first, __last);
792 }
793 return *this;
794 }
795
796 // concatenation
797 _LIBCPP_INLINE_VISIBILITY
798 path& operator+=(const path& __x) {
799 __pn_ += __x.__pn_;
800 return *this;
801 }
802
803 _LIBCPP_INLINE_VISIBILITY
804 path& operator+=(const string_type& __x) {
805 __pn_ += __x;
806 return *this;
807 }
808
809 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier2645dbe2016-07-23 03:10:56 +0000810 path& operator+=(__string_view __x) {
811 __pn_ += __x;
812 return *this;
813 }
814
815 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000816 path& operator+=(const value_type* __x) {
817 __pn_ += __x;
818 return *this;
819 }
820
821 _LIBCPP_INLINE_VISIBILITY
822 path& operator+=(value_type __x) {
823 __pn_ += __x;
824 return *this;
825 }
826
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000827 template <class _ECharT>
828 typename enable_if<__can_convert_char<_ECharT>::value, path&>::type
829 operator+=(_ECharT __x)
830 {
831 basic_string<_ECharT> __tmp;
832 __tmp += __x;
833 _PathCVT<_ECharT>::__append_source(__pn_, __tmp);
834 return *this;
835 }
836
837 template <class _Source>
838 _EnableIfPathable<_Source>
839 operator+=(const _Source& __x) {
840 return this->concat(__x);
841 }
842
843 template <class _Source>
844 _EnableIfPathable<_Source>
845 concat(const _Source& __x) {
846 _SourceCVT<_Source>::__append_source(__pn_, __x);
847 return *this;
848 }
849
850 template <class _InputIt>
851 path& concat(_InputIt __first, _InputIt __last) {
852 typedef typename iterator_traits<_InputIt>::value_type _ItVal;
853 _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
854 return *this;
855 }
856
857 // modifiers
858 _LIBCPP_INLINE_VISIBILITY
859 void clear() _NOEXCEPT {
860 __pn_.clear();
861 }
862
863 path& make_preferred() { return *this; }
864 path& remove_filename() { return *this = parent_path(); }
865
866 path& replace_filename(const path& __replacement) {
867 remove_filename();
868 return (*this /= __replacement);
869 }
870
871 path& replace_extension(const path& __replacement = path());
872
873 _LIBCPP_INLINE_VISIBILITY
874 void swap(path& __rhs) _NOEXCEPT {
875 __pn_.swap(__rhs.__pn_);
876 }
877
878 // native format observers
879 _LIBCPP_INLINE_VISIBILITY
880 const string_type& native() const _NOEXCEPT {
881 return __pn_;
882 }
883
884 _LIBCPP_INLINE_VISIBILITY
885 const value_type* c_str() const _NOEXCEPT { return __pn_.c_str(); }
886
887 _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_; }
888
889 template <class _ECharT, class _Traits = char_traits<_ECharT>,
890 class _Allocator = allocator<_ECharT> >
891 basic_string<_ECharT, _Traits, _Allocator>
892 string(const _Allocator& __a = _Allocator()) const {
893 using _CVT = __widen_from_utf8<sizeof(_ECharT)*__CHAR_BIT__>;
894 using _Str = basic_string<_ECharT, _Traits, _Allocator>;
895 _Str __s(__a);
896 __s.reserve(__pn_.size());
897 _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
898 return __s;
899 }
900
901 _LIBCPP_INLINE_VISIBILITY std::string string() const { return __pn_; }
902 _LIBCPP_INLINE_VISIBILITY std::wstring wstring() const { return string<wchar_t>(); }
903 _LIBCPP_INLINE_VISIBILITY std::string u8string() const { return __pn_; }
904 _LIBCPP_INLINE_VISIBILITY std::u16string u16string() const { return string<char16_t>(); }
905 _LIBCPP_INLINE_VISIBILITY std::u32string u32string() const { return string<char32_t>(); }
906
907 // generic format observers
908 template <class _ECharT, class _Traits = char_traits<_ECharT>,
909 class _Allocator = allocator<_ECharT>
910 >
911 basic_string<_ECharT, _Traits, _Allocator>
912 generic_string(const _Allocator& __a = _Allocator()) const {
913 return string<_ECharT, _Traits, _Allocator>(__a);
914 }
915
916 std::string generic_string() const { return __pn_; }
917 std::wstring generic_wstring() const { return string<wchar_t>(); }
918 std::string generic_u8string() const { return __pn_; }
919 std::u16string generic_u16string() const { return string<char16_t>(); }
920 std::u32string generic_u32string() const { return string<char32_t>(); }
921
922private:
Eric Fiselier2645dbe2016-07-23 03:10:56 +0000923 _LIBCPP_FUNC_VIS int __compare(__string_view) const;
924 _LIBCPP_FUNC_VIS __string_view __root_name() const;
925 _LIBCPP_FUNC_VIS __string_view __root_directory() const;
926 _LIBCPP_FUNC_VIS __string_view __relative_path() const;
927 _LIBCPP_FUNC_VIS __string_view __parent_path() const;
928 _LIBCPP_FUNC_VIS __string_view __filename() const;
929 _LIBCPP_FUNC_VIS __string_view __stem() const;
930 _LIBCPP_FUNC_VIS __string_view __extension() const;
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000931
932public:
933 // compare
Eric Fiselier2645dbe2016-07-23 03:10:56 +0000934 _LIBCPP_INLINE_VISIBILITY int compare(const path& __p) const _NOEXCEPT { return __compare(__p.__pn_);}
935 _LIBCPP_INLINE_VISIBILITY int compare(const string_type& __s) const { return __compare(__s); }
936 _LIBCPP_INLINE_VISIBILITY int compare(__string_view __s) const { return __compare(__s); }
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000937 _LIBCPP_INLINE_VISIBILITY int compare(const value_type* __s) const { return __compare(__s); }
938
939 // decomposition
Eric Fiselier2645dbe2016-07-23 03:10:56 +0000940 _LIBCPP_INLINE_VISIBILITY path root_name() const { return string_type(__root_name()); }
941 _LIBCPP_INLINE_VISIBILITY path root_directory() const { return string_type(__root_directory()); }
942 _LIBCPP_INLINE_VISIBILITY path root_path() const { return root_name().append(string_type(__root_directory())); }
943 _LIBCPP_INLINE_VISIBILITY path relative_path() const { return string_type(__relative_path()); }
944 _LIBCPP_INLINE_VISIBILITY path parent_path() const { return string_type(__parent_path()); }
945 _LIBCPP_INLINE_VISIBILITY path filename() const { return string_type(__filename()); }
946 _LIBCPP_INLINE_VISIBILITY path stem() const { return string_type(__stem());}
947 _LIBCPP_INLINE_VISIBILITY path extension() const { return string_type(__extension()); }
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000948
949 // query
950 _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT { return __pn_.empty(); }
951
952 _LIBCPP_INLINE_VISIBILITY bool has_root_name() const { return !__root_name().empty(); }
953 _LIBCPP_INLINE_VISIBILITY bool has_root_directory() const { return !__root_directory().empty(); }
954 _LIBCPP_INLINE_VISIBILITY bool has_root_path() const { return !(__root_name().empty() && __root_directory().empty()); }
955 _LIBCPP_INLINE_VISIBILITY bool has_relative_path() const { return !__relative_path().empty(); }
956 _LIBCPP_INLINE_VISIBILITY bool has_parent_path() const { return !__parent_path().empty(); }
957 _LIBCPP_INLINE_VISIBILITY bool has_filename() const { return !__filename().empty(); }
958 _LIBCPP_INLINE_VISIBILITY bool has_stem() const { return !__stem().empty(); }
959 _LIBCPP_INLINE_VISIBILITY bool has_extension() const { return !__extension().empty(); }
960
961 _LIBCPP_INLINE_VISIBILITY bool is_absolute() const { return has_root_directory(); }
962 _LIBCPP_INLINE_VISIBILITY bool is_relative() const { return !is_absolute(); }
963
964 // iterators
965 class _LIBCPP_TYPE_VIS iterator;
966 typedef iterator const_iterator;
967
968 _LIBCPP_FUNC_VIS iterator begin() const;
969 _LIBCPP_FUNC_VIS iterator end() const;
970
971private:
972 inline _LIBCPP_INLINE_VISIBILITY
Eric Fiselier2645dbe2016-07-23 03:10:56 +0000973 path& __assign_view(__string_view const& __s) noexcept { __pn_ = string_type(__s); return *this; }
Eric Fiselier6e9a6942016-06-17 19:46:40 +0000974 string_type __pn_;
975};
976
977inline _LIBCPP_ALWAYS_INLINE
978void swap(path& __lhs, path& __rhs) _NOEXCEPT {
979 __lhs.swap(__rhs);
980}
981
982_LIBCPP_FUNC_VIS
983size_t hash_value(const path& __p) _NOEXCEPT;
984
985inline _LIBCPP_INLINE_VISIBILITY
986bool operator==(const path& __lhs, const path& __rhs) _NOEXCEPT
987{ return __lhs.compare(__rhs) == 0; }
988
989inline _LIBCPP_INLINE_VISIBILITY
990bool operator!=(const path& __lhs, const path& __rhs) _NOEXCEPT
991{ return __lhs.compare(__rhs) != 0; }
992
993inline _LIBCPP_INLINE_VISIBILITY
994bool operator<(const path& __lhs, const path& __rhs) _NOEXCEPT
995{ return __lhs.compare(__rhs) < 0; }
996
997inline _LIBCPP_INLINE_VISIBILITY
998bool operator<=(const path& __lhs, const path& __rhs) _NOEXCEPT
999{ return __lhs.compare(__rhs) <= 0; }
1000
1001inline _LIBCPP_INLINE_VISIBILITY
1002bool operator>(const path& __lhs, const path& __rhs) _NOEXCEPT
1003{ return __lhs.compare(__rhs) > 0; }
1004
1005inline _LIBCPP_INLINE_VISIBILITY
1006bool operator>=(const path& __lhs, const path& __rhs) _NOEXCEPT
1007{ return __lhs.compare(__rhs) >= 0; }
1008
1009inline _LIBCPP_INLINE_VISIBILITY
1010path operator/(const path& __lhs, const path& __rhs) {
1011 return path(__lhs) /= __rhs;
1012}
1013
1014template <class _CharT, class _Traits>
1015_LIBCPP_INLINE_VISIBILITY
1016typename enable_if<is_same<_CharT, char>::value &&
1017 is_same<_Traits, char_traits<char>>::value,
1018 basic_ostream<_CharT, _Traits>&
1019>::type
1020operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
1021 __os << std::__quoted(__p.native());
1022 return __os;
1023}
1024
1025template <class _CharT, class _Traits>
1026_LIBCPP_INLINE_VISIBILITY
1027typename enable_if<!is_same<_CharT, char>::value ||
1028 !is_same<_Traits, char_traits<char>>::value,
1029 basic_ostream<_CharT, _Traits>&
1030>::type
1031operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
1032 __os << std::__quoted(__p.string<_CharT, _Traits>());
1033 return __os;
1034}
1035
1036template <class _CharT, class _Traits>
1037_LIBCPP_INLINE_VISIBILITY
1038basic_istream<_CharT, _Traits>&
1039operator>>(basic_istream<_CharT, _Traits>& __is, path& __p)
1040{
1041 basic_string<_CharT, _Traits> __tmp;
1042 __is >> __quoted(__tmp);
1043 __p = __tmp;
1044 return __is;
1045}
1046
1047template <class _Source>
1048_LIBCPP_INLINE_VISIBILITY
1049typename enable_if<__is_pathable<_Source>::value, path>::type
1050u8path(const _Source& __s){
1051 static_assert(is_same<typename __is_pathable<_Source>::__char_type, char>::value,
1052 "u8path(Source const&) requires Source have a character type of type 'char'");
1053 return path(__s);
1054}
1055
1056template <class _InputIt>
1057_LIBCPP_INLINE_VISIBILITY
1058typename enable_if<__is_pathable<_InputIt>::value, path>::type
1059u8path(_InputIt __f, _InputIt __l) {
1060 static_assert(is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
1061 "u8path(Iter, Iter) requires Iter have a value_type of type 'char'");
1062 return path(__f, __l);
1063}
1064
1065class _LIBCPP_TYPE_VIS path::iterator
1066{
1067public:
1068 typedef bidirectional_iterator_tag iterator_category;
1069 typedef path value_type;
1070 typedef std::ptrdiff_t difference_type;
1071 typedef const path* pointer;
1072 typedef const path& reference;
1073public:
1074 _LIBCPP_INLINE_VISIBILITY
1075 iterator() : __elem_(), __path_ptr_(nullptr), __pos_(0) {}
1076
1077 iterator(const iterator&) = default;
1078 ~iterator() = default;
1079
1080 iterator& operator=(const iterator&) = default;
1081
1082 _LIBCPP_INLINE_VISIBILITY
1083 reference operator*() const {
1084 return __elem_;
1085 }
1086
1087 _LIBCPP_INLINE_VISIBILITY
1088 pointer operator->() const {
1089 return &__elem_;
1090 }
1091
1092 _LIBCPP_INLINE_VISIBILITY
1093 iterator& operator++() {
1094 return __increment();
1095 }
1096
1097 _LIBCPP_INLINE_VISIBILITY
1098 iterator operator++(int) {
1099 iterator __it(*this);
1100 this->operator++();
1101 return __it;
1102 }
1103
1104 _LIBCPP_INLINE_VISIBILITY
1105 iterator& operator--() {
1106 return __decrement();
1107 }
1108
1109 _LIBCPP_INLINE_VISIBILITY
1110 iterator operator--(int) {
1111 iterator __it(*this);
1112 this->operator--();
1113 return __it;
1114 }
1115
1116private:
1117 friend class path;
Eric Fiselier03f7d102016-09-16 00:07:16 +00001118
1119 inline _LIBCPP_INLINE_VISIBILITY
Eric Fiselier6e9a6942016-06-17 19:46:40 +00001120 friend bool operator==(const iterator&, const iterator&);
1121
1122 _LIBCPP_FUNC_VIS iterator& __increment();
1123 _LIBCPP_FUNC_VIS iterator& __decrement();
1124
1125 path __elem_;
1126 const path* __path_ptr_;
1127 size_t __pos_;
1128};
1129
1130inline _LIBCPP_INLINE_VISIBILITY
1131bool operator==(const path::iterator& __lhs, const path::iterator& __rhs) {
1132 return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
1133 __lhs.__pos_ == __rhs.__pos_;
1134}
1135
1136inline _LIBCPP_INLINE_VISIBILITY
1137bool operator!=(const path::iterator& __lhs, const path::iterator& __rhs) {
1138 return !(__lhs == __rhs);
1139}
1140
1141class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error
1142{
1143public:
1144 _LIBCPP_INLINE_VISIBILITY
1145 filesystem_error(const string& __what, error_code __ec)
1146 : system_error(__ec, __what),
1147 __paths_(make_shared<_Storage>(path(), path()))
1148 {}
1149
1150 _LIBCPP_INLINE_VISIBILITY
1151 filesystem_error(const string& __what, const path& __p1, error_code __ec)
1152 : system_error(__ec, __what),
1153 __paths_(make_shared<_Storage>(__p1, path()))
1154 {}
1155
1156 _LIBCPP_INLINE_VISIBILITY
1157 filesystem_error(const string& __what, const path& __p1, const path& __p2,
1158 error_code __ec)
1159 : system_error(__ec, __what),
1160 __paths_(make_shared<_Storage>(__p1, __p2))
1161 {}
1162
1163 _LIBCPP_INLINE_VISIBILITY
1164 const path& path1() const _NOEXCEPT {
1165 return __paths_->first;
1166 }
1167
1168 _LIBCPP_INLINE_VISIBILITY
1169 const path& path2() const _NOEXCEPT {
1170 return __paths_->second;
1171 }
1172
1173 _LIBCPP_FUNC_VIS
1174 ~filesystem_error() override; // key function
1175
1176 // TODO(ericwf): Create a custom error message.
1177 //const char* what() const _NOEXCEPT;
1178
1179private:
1180 typedef pair<path, path> _Storage;
1181 shared_ptr<_Storage> __paths_;
1182};
1183
Marshall Clowe7acb0e2016-08-25 17:47:09 +00001184template <class... _Args>
1185_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
1186void __throw_filesystem_error(_Args && ...__args)
1187{
1188#ifndef _LIBCPP_NO_EXCEPTIONS
1189 throw filesystem_error(std::forward<_Args>(__args)...);
1190#else
1191 _VSTD::abort();
1192#endif
1193}
1194
Eric Fiselier6e9a6942016-06-17 19:46:40 +00001195// operational functions
1196
1197_LIBCPP_FUNC_VIS
1198path __canonical(const path&, const path&, error_code *__ec=nullptr);
1199_LIBCPP_FUNC_VIS
1200void __copy(const path& __from, const path& __to, copy_options __opt,
1201 error_code *__ec=nullptr);
1202_LIBCPP_FUNC_VIS
1203bool __copy_file(const path& __from, const path& __to, copy_options __opt,
1204 error_code *__ec=nullptr);
1205_LIBCPP_FUNC_VIS
1206void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
1207 error_code *__ec=nullptr);
1208_LIBCPP_FUNC_VIS
1209bool __create_directories(const path& p, error_code *ec=nullptr);
1210_LIBCPP_FUNC_VIS
1211bool __create_directory(const path& p, error_code *ec=nullptr);
1212_LIBCPP_FUNC_VIS
1213bool __create_directory(const path& p, const path & attributes,
1214 error_code *ec=nullptr);
1215_LIBCPP_FUNC_VIS
1216void __create_directory_symlink(const path& __to, const path& __new_symlink,
1217 error_code *__ec=nullptr);
1218_LIBCPP_FUNC_VIS
1219void __create_hard_link(const path& __to, const path& __new_hard_link,
1220 error_code *__ec=nullptr);
1221_LIBCPP_FUNC_VIS
1222void __create_symlink(const path& __to, const path& __new_symlink,
1223 error_code *__ec=nullptr);
1224_LIBCPP_FUNC_VIS
1225path __current_path(error_code *__ec=nullptr);
1226_LIBCPP_FUNC_VIS
1227void __current_path(const path&, error_code *__ec=nullptr);
1228_LIBCPP_FUNC_VIS
1229bool __equivalent(const path&, const path&, error_code *__ec=nullptr);
1230_LIBCPP_FUNC_VIS
1231uintmax_t __file_size(const path&, error_code *__ec=nullptr);
1232_LIBCPP_FUNC_VIS
1233uintmax_t __hard_link_count(const path&, error_code *__ec=nullptr);
1234_LIBCPP_FUNC_VIS
1235bool __fs_is_empty(const path& p, error_code *ec=nullptr);
1236_LIBCPP_FUNC_VIS
1237file_time_type __last_write_time(const path& p, error_code *ec=nullptr);
1238_LIBCPP_FUNC_VIS
1239void __last_write_time(const path& p, file_time_type new_time,
1240 error_code *ec=nullptr);
1241_LIBCPP_FUNC_VIS
1242void __permissions(const path& p, perms prms, error_code *ec=nullptr);
1243_LIBCPP_FUNC_VIS
1244path __read_symlink(const path& p, error_code *ec=nullptr);
1245_LIBCPP_FUNC_VIS
1246bool __remove(const path& p, error_code *ec=nullptr);
1247_LIBCPP_FUNC_VIS
1248uintmax_t __remove_all(const path& p, error_code *ec=nullptr);
1249_LIBCPP_FUNC_VIS
1250void __rename(const path& from, const path& to, error_code *ec=nullptr);
1251_LIBCPP_FUNC_VIS
1252void __resize_file(const path& p, uintmax_t size, error_code *ec=nullptr);
1253_LIBCPP_FUNC_VIS
1254space_info __space(const path&, error_code *__ec=nullptr);
1255_LIBCPP_FUNC_VIS
1256file_status __status(const path&, error_code *__ec=nullptr);
1257_LIBCPP_FUNC_VIS
1258file_status __symlink_status(const path&, error_code *__ec=nullptr);
1259_LIBCPP_FUNC_VIS
1260path __system_complete(const path&, error_code *__ec=nullptr);
1261_LIBCPP_FUNC_VIS
1262path __temp_directory_path(error_code *__ec=nullptr);
1263
1264inline _LIBCPP_INLINE_VISIBILITY
1265path current_path() {
1266 return __current_path();
1267}
1268
1269inline _LIBCPP_INLINE_VISIBILITY
1270path current_path(error_code& __ec) {
1271 return __current_path(&__ec);
1272}
1273
1274inline _LIBCPP_INLINE_VISIBILITY
1275void current_path(const path& __p) {
1276 __current_path(__p);
1277}
1278
1279inline _LIBCPP_INLINE_VISIBILITY
1280void current_path(const path& __p, error_code& __ec) _NOEXCEPT {
1281 __current_path(__p, &__ec);
1282}
1283
1284_LIBCPP_FUNC_VIS
1285path absolute(const path&, const path& __p2 = current_path());
1286
1287inline _LIBCPP_INLINE_VISIBILITY
1288path canonical(const path& __p, const path& __base = current_path()) {
1289 return __canonical(__p, __base);
1290}
1291
1292inline _LIBCPP_INLINE_VISIBILITY
1293path canonical(const path& __p, error_code& __ec) {
1294 path __base = __current_path(&__ec);
1295 if (__ec) return {};
1296 return __canonical(__p, __base, &__ec);
1297}
1298
1299inline _LIBCPP_INLINE_VISIBILITY
1300path canonical(const path& __p, const path& __base, error_code& __ec) {
1301 return __canonical(__p, __base, &__ec);
1302}
1303
1304inline _LIBCPP_INLINE_VISIBILITY
1305void copy(const path& __from, const path& __to) {
1306 __copy(__from, __to, copy_options::none);
1307}
1308
1309inline _LIBCPP_INLINE_VISIBILITY
1310void copy(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
1311 __copy(__from, __to, copy_options::none, &__ec);
1312}
1313
1314inline _LIBCPP_INLINE_VISIBILITY
1315void copy(const path& __from, const path& __to, copy_options __opt) {
1316 __copy(__from, __to, __opt);
1317}
1318
1319inline _LIBCPP_INLINE_VISIBILITY
1320void copy(const path& __from, const path& __to,
1321 copy_options __opt, error_code& __ec) _NOEXCEPT {
1322 __copy(__from, __to, __opt, &__ec);
1323}
1324
1325inline _LIBCPP_INLINE_VISIBILITY
1326bool copy_file(const path& __from, const path& __to) {
1327 return __copy_file(__from, __to, copy_options::none);
1328}
1329
1330inline _LIBCPP_INLINE_VISIBILITY
1331bool copy_file(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
1332 return __copy_file(__from, __to, copy_options::none, &__ec);
1333}
1334
1335inline _LIBCPP_INLINE_VISIBILITY
1336bool copy_file(const path& __from, const path& __to, copy_options __opt) {
1337 return __copy_file(__from, __to, __opt);
1338}
1339
1340inline _LIBCPP_INLINE_VISIBILITY
1341bool copy_file(const path& __from, const path& __to,
1342 copy_options __opt, error_code& __ec) _NOEXCEPT {
1343 return __copy_file(__from, __to, __opt, &__ec);
1344}
1345
1346inline _LIBCPP_INLINE_VISIBILITY
1347void copy_symlink(const path& __existing, const path& __new) {
1348 __copy_symlink(__existing, __new);
1349}
1350
1351inline _LIBCPP_INLINE_VISIBILITY
1352void copy_symlink(const path& __ext, const path& __new, error_code& __ec) _NOEXCEPT {
1353 __copy_symlink(__ext, __new, &__ec);
1354}
1355
1356inline _LIBCPP_INLINE_VISIBILITY
1357bool create_directories(const path& __p) {
1358 return __create_directories(__p);
1359}
1360
1361inline _LIBCPP_INLINE_VISIBILITY
1362bool create_directories(const path& __p, error_code& __ec) _NOEXCEPT {
1363 return __create_directories(__p, &__ec);
1364}
1365
1366inline _LIBCPP_INLINE_VISIBILITY
1367bool create_directory(const path& __p) {
1368 return __create_directory(__p);
1369}
1370
1371inline _LIBCPP_INLINE_VISIBILITY
1372bool create_directory(const path& __p, error_code& __ec) _NOEXCEPT {
1373 return __create_directory(__p, &__ec);
1374}
1375
1376inline _LIBCPP_INLINE_VISIBILITY
1377bool create_directory(const path& __p, const path& __attrs) {
1378 return __create_directory(__p, __attrs);
1379}
1380
1381inline _LIBCPP_INLINE_VISIBILITY
1382bool create_directory(const path& __p, const path& __attrs, error_code& __ec) _NOEXCEPT {
1383 return __create_directory(__p, __attrs, &__ec);
1384}
1385
1386inline _LIBCPP_INLINE_VISIBILITY
1387void create_directory_symlink(const path& __to, const path& __new) {
1388 __create_directory_symlink(__to, __new);
1389}
1390
1391inline _LIBCPP_INLINE_VISIBILITY
1392void create_directory_symlink(const path& __to, const path& __new,
1393 error_code& __ec) _NOEXCEPT {
1394 __create_directory_symlink(__to, __new, &__ec);
1395}
1396
1397inline _LIBCPP_INLINE_VISIBILITY
1398void create_hard_link(const path& __to, const path& __new) {
1399 __create_hard_link(__to, __new);
1400}
1401
1402inline _LIBCPP_INLINE_VISIBILITY
1403void create_hard_link(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT {
1404 __create_hard_link(__to, __new, &__ec);
1405}
1406
1407inline _LIBCPP_INLINE_VISIBILITY
1408void create_symlink(const path& __to, const path& __new) {
1409 __create_symlink(__to, __new);
1410}
1411
1412inline _LIBCPP_INLINE_VISIBILITY
1413void create_symlink(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT {
1414 return __create_symlink(__to, __new, &__ec);
1415}
1416
1417inline _LIBCPP_INLINE_VISIBILITY
1418bool status_known(file_status __s) _NOEXCEPT {
1419 return __s.type() != file_type::none;
1420}
1421
1422inline _LIBCPP_INLINE_VISIBILITY
1423bool exists(file_status __s) _NOEXCEPT {
1424 return status_known(__s) && __s.type() != file_type::not_found;
1425}
1426
1427inline _LIBCPP_INLINE_VISIBILITY
1428bool exists(const path& __p) {
1429 return exists(__status(__p));
1430}
1431
1432inline _LIBCPP_INLINE_VISIBILITY
1433bool exists(const path& __p, error_code& __ec) _NOEXCEPT {
Eric Fiselier756a6bd2016-06-21 22:11:16 +00001434 auto __s = __status(__p, &__ec);
1435 if (status_known(__s)) __ec.clear();
1436 return exists(__s);
Eric Fiselier6e9a6942016-06-17 19:46:40 +00001437}
1438
1439inline _LIBCPP_INLINE_VISIBILITY
1440bool equivalent(const path& __p1, const path& __p2) {
1441 return __equivalent(__p1, __p2);
1442}
1443
1444inline _LIBCPP_INLINE_VISIBILITY
1445bool equivalent(const path& __p1, const path& __p2, error_code& __ec) _NOEXCEPT {
1446 return __equivalent(__p1, __p2, &__ec);
1447}
1448
1449inline _LIBCPP_INLINE_VISIBILITY
1450uintmax_t file_size(const path& __p) {
1451 return __file_size(__p);
1452}
1453
1454inline _LIBCPP_INLINE_VISIBILITY
1455uintmax_t file_size(const path& __p, error_code& __ec) _NOEXCEPT {
1456 return __file_size(__p, &__ec);
1457}
1458
1459inline _LIBCPP_INLINE_VISIBILITY
1460uintmax_t hard_link_count(const path& __p) {
1461 return __hard_link_count(__p);
1462}
1463
1464inline _LIBCPP_INLINE_VISIBILITY
1465uintmax_t hard_link_count(const path& __p, error_code& __ec) _NOEXCEPT {
1466 return __hard_link_count(__p, &__ec);
1467}
1468
1469inline _LIBCPP_INLINE_VISIBILITY
1470bool is_block_file(file_status __s) _NOEXCEPT {
1471 return __s.type() == file_type::block;
1472}
1473
1474inline _LIBCPP_INLINE_VISIBILITY
1475bool is_block_file(const path& __p) {
1476 return is_block_file(__status(__p));
1477}
1478
1479inline _LIBCPP_INLINE_VISIBILITY
1480bool is_block_file(const path& __p, error_code& __ec) _NOEXCEPT {
1481 return is_block_file(__status(__p, &__ec));
1482}
1483
1484inline _LIBCPP_INLINE_VISIBILITY
1485bool is_character_file(file_status __s) _NOEXCEPT {
1486 return __s.type() == file_type::character;
1487}
1488
1489inline _LIBCPP_INLINE_VISIBILITY
1490bool is_character_file(const path& __p) {
1491 return is_character_file(__status(__p));
1492}
1493
1494inline _LIBCPP_INLINE_VISIBILITY
1495bool is_character_file(const path& __p, error_code& __ec) _NOEXCEPT {
1496 return is_character_file(__status(__p, &__ec));
1497}
1498
1499inline _LIBCPP_INLINE_VISIBILITY
1500bool is_directory(file_status __s) _NOEXCEPT {
1501 return __s.type() == file_type::directory;
1502}
1503
1504inline _LIBCPP_INLINE_VISIBILITY
1505bool is_directory(const path& __p) {
1506 return is_directory(__status(__p));
1507}
1508
1509inline _LIBCPP_INLINE_VISIBILITY
1510bool is_directory(const path& __p, error_code& __ec) _NOEXCEPT {
1511 return is_directory(__status(__p, &__ec));
1512}
1513
1514inline _LIBCPP_INLINE_VISIBILITY
1515bool is_empty(const path& __p) {
1516 return __fs_is_empty(__p);
1517}
1518
1519inline _LIBCPP_INLINE_VISIBILITY
1520bool is_empty(const path& __p, error_code& __ec) _NOEXCEPT {
1521 return __fs_is_empty(__p, &__ec);
1522}
1523
1524inline _LIBCPP_INLINE_VISIBILITY
1525bool is_fifo(file_status __s) _NOEXCEPT {
1526 return __s.type() == file_type::fifo;
1527}
1528inline _LIBCPP_INLINE_VISIBILITY
1529bool is_fifo(const path& __p) {
1530 return is_fifo(__status(__p));
1531}
1532
1533inline _LIBCPP_INLINE_VISIBILITY
1534bool is_fifo(const path& __p, error_code& __ec) _NOEXCEPT {
1535 return is_fifo(__status(__p, &__ec));
1536}
1537
1538inline _LIBCPP_INLINE_VISIBILITY
1539bool is_regular_file(file_status __s) _NOEXCEPT {
1540 return __s.type() == file_type::regular;
1541}
1542
1543inline _LIBCPP_INLINE_VISIBILITY
1544bool is_regular_file(const path& __p) {
1545 return is_regular_file(__status(__p));
1546}
1547
1548inline _LIBCPP_INLINE_VISIBILITY
1549bool is_regular_file(const path& __p, error_code& __ec) _NOEXCEPT {
1550 return is_regular_file(__status(__p, &__ec));
1551}
1552
1553inline _LIBCPP_INLINE_VISIBILITY
1554bool is_socket(file_status __s) _NOEXCEPT {
1555 return __s.type() == file_type::socket;
1556}
1557
1558inline _LIBCPP_INLINE_VISIBILITY
1559bool is_socket(const path& __p) {
1560 return is_socket(__status(__p));
1561}
1562
1563inline _LIBCPP_INLINE_VISIBILITY
1564bool is_socket(const path& __p, error_code& __ec) _NOEXCEPT {
1565 return is_socket(__status(__p, &__ec));
1566}
1567
1568inline _LIBCPP_INLINE_VISIBILITY
1569bool is_symlink(file_status __s) _NOEXCEPT {
1570 return __s.type() == file_type::symlink;
1571}
1572
1573inline _LIBCPP_INLINE_VISIBILITY
1574bool is_symlink(const path& __p) {
1575 return is_symlink(__symlink_status(__p));
1576}
1577
1578inline _LIBCPP_INLINE_VISIBILITY
1579bool is_symlink(const path& __p, error_code& __ec) _NOEXCEPT {
1580 return is_symlink(__symlink_status(__p, &__ec));
1581}
1582
1583inline _LIBCPP_INLINE_VISIBILITY
1584bool is_other(file_status __s) _NOEXCEPT {
1585 return exists(__s)
1586 && !is_regular_file(__s) && !is_directory(__s) && !is_symlink(__s);
1587}
1588
1589inline _LIBCPP_INLINE_VISIBILITY
1590bool is_other(const path& __p) {
1591 return is_other(__status(__p));
1592}
1593
1594inline _LIBCPP_INLINE_VISIBILITY
1595bool is_other(const path& __p, error_code& __ec) _NOEXCEPT {
1596 return is_other(__status(__p, &__ec));
1597}
1598
1599inline _LIBCPP_INLINE_VISIBILITY
1600file_time_type last_write_time(const path& __p) {
1601 return __last_write_time(__p);
1602}
1603
1604inline _LIBCPP_INLINE_VISIBILITY
1605file_time_type last_write_time(const path& __p, error_code& __ec) _NOEXCEPT {
1606 return __last_write_time(__p, &__ec);
1607}
1608
1609inline _LIBCPP_INLINE_VISIBILITY
1610void last_write_time(const path& __p, file_time_type __t) {
1611 __last_write_time(__p, __t);
1612}
1613
1614inline _LIBCPP_INLINE_VISIBILITY
1615void last_write_time(const path& __p, file_time_type __t, error_code& __ec) _NOEXCEPT {
1616 __last_write_time(__p, __t, &__ec);
1617}
1618
1619inline _LIBCPP_INLINE_VISIBILITY
1620void permissions(const path& __p, perms __prms) {
1621 __permissions(__p, __prms);
1622}
1623
1624inline _LIBCPP_INLINE_VISIBILITY
1625void permissions(const path& __p, perms __prms, error_code& __ec) {
1626 __permissions(__p, __prms, &__ec);
1627}
1628
1629inline _LIBCPP_INLINE_VISIBILITY
1630path read_symlink(const path& __p) {
1631 return __read_symlink(__p);
1632}
1633
1634inline _LIBCPP_INLINE_VISIBILITY
1635path read_symlink(const path& __p, error_code& __ec) {
1636 return __read_symlink(__p, &__ec);
1637}
1638
1639inline _LIBCPP_INLINE_VISIBILITY
1640bool remove(const path& __p) {
1641 return __remove(__p);
1642}
1643
1644inline _LIBCPP_INLINE_VISIBILITY
1645bool remove(const path& __p, error_code& __ec) _NOEXCEPT {
1646 return __remove(__p, &__ec);
1647}
1648
1649inline _LIBCPP_INLINE_VISIBILITY
1650uintmax_t remove_all(const path& __p) {
1651 return __remove_all(__p);
1652}
1653
1654inline _LIBCPP_INLINE_VISIBILITY
1655uintmax_t remove_all(const path& __p, error_code& __ec) _NOEXCEPT {
1656 return __remove_all(__p, &__ec);
1657}
1658
1659inline _LIBCPP_INLINE_VISIBILITY
1660void rename(const path& __from, const path& __to) {
1661 return __rename(__from, __to);
1662}
1663
1664inline _LIBCPP_INLINE_VISIBILITY
1665void rename(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
1666 return __rename(__from, __to, &__ec);
1667}
1668
1669inline _LIBCPP_INLINE_VISIBILITY
1670void resize_file(const path& __p, uintmax_t __ns) {
1671 return __resize_file(__p, __ns);
1672}
1673
1674inline _LIBCPP_INLINE_VISIBILITY
1675void resize_file(const path& __p, uintmax_t __ns, error_code& __ec) _NOEXCEPT {
1676 return __resize_file(__p, __ns, &__ec);
1677}
1678
1679inline _LIBCPP_INLINE_VISIBILITY
1680space_info space(const path& __p) {
1681 return __space(__p);
1682}
1683
1684inline _LIBCPP_INLINE_VISIBILITY
1685space_info space(const path& __p, error_code& __ec) _NOEXCEPT {
1686 return __space(__p, &__ec);
1687}
1688
1689inline _LIBCPP_INLINE_VISIBILITY
1690file_status status(const path& __p) {
1691 return __status(__p);
1692}
1693
1694inline _LIBCPP_INLINE_VISIBILITY
1695file_status status(const path& __p, error_code& __ec) _NOEXCEPT {
1696 return __status(__p, &__ec);
1697}
1698
1699inline _LIBCPP_INLINE_VISIBILITY
1700file_status symlink_status(const path& __p) {
1701 return __symlink_status(__p);
1702}
1703
1704inline _LIBCPP_INLINE_VISIBILITY
1705file_status symlink_status(const path& __p, error_code& __ec) _NOEXCEPT {
1706 return __symlink_status(__p, &__ec);
1707}
1708
1709inline _LIBCPP_INLINE_VISIBILITY
1710path system_complete(const path& __p) {
1711 return __system_complete(__p);
1712}
1713
1714inline _LIBCPP_INLINE_VISIBILITY
1715path system_complete(const path& __p, error_code& __ec) {
1716 return __system_complete(__p, &__ec);
1717}
1718
1719inline _LIBCPP_INLINE_VISIBILITY
1720path temp_directory_path() {
1721 return __temp_directory_path();
1722}
1723
1724inline _LIBCPP_INLINE_VISIBILITY
1725path temp_directory_path(error_code& __ec) {
1726 return __temp_directory_path(&__ec);
1727}
1728
1729
1730class directory_entry
1731{
1732 typedef _VSTD_FS::path _Path;
1733
1734public:
1735 // constructors and destructors
1736 directory_entry() _NOEXCEPT = default;
1737 directory_entry(directory_entry const&) = default;
1738 directory_entry(directory_entry&&) _NOEXCEPT = default;
1739
1740 _LIBCPP_INLINE_VISIBILITY
1741 explicit directory_entry(_Path const& __p) : __p_(__p) {}
1742
1743 ~directory_entry() {}
1744
1745 directory_entry& operator=(directory_entry const&) = default;
1746 directory_entry& operator=(directory_entry&&) _NOEXCEPT = default;
1747
1748 _LIBCPP_INLINE_VISIBILITY
1749 void assign(_Path const& __p) {
1750 __p_ = __p;
1751 }
1752
1753 _LIBCPP_INLINE_VISIBILITY
1754 void replace_filename(_Path const& __p) {
1755 __p_ = __p_.parent_path() / __p;
1756 }
1757
1758 _LIBCPP_INLINE_VISIBILITY
1759 _Path const& path() const _NOEXCEPT {
1760 return __p_;
1761 }
1762
1763 _LIBCPP_INLINE_VISIBILITY
1764 operator const _Path&() const _NOEXCEPT {
1765 return __p_;
1766 }
1767
1768 _LIBCPP_INLINE_VISIBILITY
1769 file_status status() const {
1770 return _VSTD_FS::status(__p_);
1771 }
1772
1773 _LIBCPP_INLINE_VISIBILITY
1774 file_status status(error_code& __ec) const _NOEXCEPT {
1775 return _VSTD_FS::status(__p_, __ec);
1776 }
1777
1778 _LIBCPP_INLINE_VISIBILITY
1779 file_status symlink_status() const {
1780 return _VSTD_FS::symlink_status(__p_);
1781 }
1782
1783 _LIBCPP_INLINE_VISIBILITY
1784 file_status symlink_status(error_code& __ec) const _NOEXCEPT {
1785 return _VSTD_FS::symlink_status(__p_, __ec);
1786 }
1787
1788 _LIBCPP_INLINE_VISIBILITY
1789 bool operator< (directory_entry const& __rhs) const _NOEXCEPT {
1790 return __p_ < __rhs.__p_;
1791 }
1792
1793 _LIBCPP_INLINE_VISIBILITY
1794 bool operator==(directory_entry const& __rhs) const _NOEXCEPT {
1795 return __p_ == __rhs.__p_;
1796 }
1797
1798 _LIBCPP_INLINE_VISIBILITY
1799 bool operator!=(directory_entry const& __rhs) const _NOEXCEPT {
1800 return __p_ != __rhs.__p_;
1801 }
1802
1803 _LIBCPP_INLINE_VISIBILITY
1804 bool operator<=(directory_entry const& __rhs) const _NOEXCEPT {
1805 return __p_ <= __rhs.__p_;
1806 }
1807
1808 _LIBCPP_INLINE_VISIBILITY
1809 bool operator> (directory_entry const& __rhs) const _NOEXCEPT {
1810 return __p_ > __rhs.__p_;
1811 }
1812
1813 _LIBCPP_INLINE_VISIBILITY
1814 bool operator>=(directory_entry const& __rhs) const _NOEXCEPT {
1815 return __p_ >= __rhs.__p_;
1816 }
1817private:
1818 _Path __p_;
1819};
1820
1821
1822class directory_iterator;
1823class recursive_directory_iterator;
1824class __dir_stream;
1825
1826class __dir_element_proxy {
1827public:
1828
1829 inline _LIBCPP_INLINE_VISIBILITY
1830 directory_entry operator*() { return _VSTD::move(__elem_); }
1831
1832private:
1833 friend class directory_iterator;
1834 friend class recursive_directory_iterator;
1835 explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
1836 __dir_element_proxy(__dir_element_proxy&& __o) : __elem_(_VSTD::move(__o.__elem_)) {}
1837 directory_entry __elem_;
1838};
1839
1840class directory_iterator
1841{
1842public:
1843 typedef directory_entry value_type;
1844 typedef ptrdiff_t difference_type;
1845 typedef value_type const* pointer;
1846 typedef value_type const& reference;
1847 typedef input_iterator_tag iterator_category;
1848
1849public:
1850 //ctor & dtor
1851 directory_iterator() _NOEXCEPT
1852 { }
1853
1854 explicit directory_iterator(const path& __p)
1855 : directory_iterator(__p, nullptr)
1856 { }
1857
1858 directory_iterator(const path& __p, directory_options __opts)
1859 : directory_iterator(__p, nullptr, __opts)
1860 { }
1861
1862 directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
1863 : directory_iterator(__p, &__ec)
1864 { }
1865
1866 directory_iterator(const path& __p, directory_options __opts,
1867 error_code& __ec) _NOEXCEPT
1868 : directory_iterator(__p, &__ec, __opts)
1869 { }
1870
1871 directory_iterator(const directory_iterator&) = default;
1872 directory_iterator(directory_iterator&&) = default;
1873 directory_iterator& operator=(const directory_iterator&) = default;
1874
1875 directory_iterator& operator=(directory_iterator&& __o) _NOEXCEPT {
1876 // non-default implementation provided to support self-move assign.
1877 if (this != &__o) {
1878 __imp_ = _VSTD::move(__o.__imp_);
1879 }
1880 return *this;
1881 }
1882
1883 ~directory_iterator() = default;
1884
1885 const directory_entry& operator*() const {
1886 _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
1887 return __deref();
1888 }
1889
1890 const directory_entry* operator->() const
1891 { return &**this; }
1892
1893 directory_iterator& operator++()
1894 { return __increment(); }
1895
1896 __dir_element_proxy operator++(int) {
1897 __dir_element_proxy __p(**this);
1898 __increment();
1899 return __p;
1900 }
1901
1902 directory_iterator& increment(error_code& __ec) _NOEXCEPT
1903 { return __increment(&__ec); }
1904
1905private:
Eric Fiselier03f7d102016-09-16 00:07:16 +00001906 inline _LIBCPP_INLINE_VISIBILITY
Eric Fiselier6e9a6942016-06-17 19:46:40 +00001907 friend bool operator==(const directory_iterator& __lhs,
1908 const directory_iterator& __rhs) _NOEXCEPT;
1909
1910 // construct the dir_stream
1911 _LIBCPP_FUNC_VIS
1912 directory_iterator(const path&, error_code *, directory_options = directory_options::none);
1913 _LIBCPP_FUNC_VIS
1914 directory_iterator& __increment(error_code * __ec = nullptr);
1915 _LIBCPP_FUNC_VIS
1916 const directory_entry& __deref() const;
1917
1918private:
1919 shared_ptr<__dir_stream> __imp_;
1920};
1921
1922
1923inline _LIBCPP_INLINE_VISIBILITY
1924bool operator==(const directory_iterator& __lhs,
1925 const directory_iterator& __rhs) _NOEXCEPT {
1926 return __lhs.__imp_ == __rhs.__imp_;
1927}
1928
1929inline _LIBCPP_INLINE_VISIBILITY
1930bool operator!=(const directory_iterator& __lhs,
1931 const directory_iterator& __rhs) _NOEXCEPT {
1932 return !(__lhs == __rhs);
1933}
1934
1935// enable directory_iterator range-based for statements
1936inline _LIBCPP_INLINE_VISIBILITY
1937directory_iterator begin(directory_iterator __iter) _NOEXCEPT {
1938 return __iter;
1939}
1940
1941inline _LIBCPP_INLINE_VISIBILITY
1942directory_iterator end(const directory_iterator&) _NOEXCEPT {
1943 return directory_iterator();
1944}
1945
1946class recursive_directory_iterator {
1947public:
1948 using value_type = directory_entry;
1949 using difference_type = std::ptrdiff_t;
1950 using pointer = directory_entry const *;
1951 using reference = directory_entry const &;
1952 using iterator_category = std::input_iterator_tag;
1953
1954public:
1955 // constructors and destructor
1956 _LIBCPP_INLINE_VISIBILITY
1957 recursive_directory_iterator() _NOEXCEPT
1958 : __rec_(false)
1959 {}
1960
1961 _LIBCPP_INLINE_VISIBILITY
1962 explicit recursive_directory_iterator(const path& __p,
1963 directory_options __xoptions = directory_options::none)
1964 : recursive_directory_iterator(__p, __xoptions, nullptr)
1965 { }
1966
1967 _LIBCPP_INLINE_VISIBILITY
1968 recursive_directory_iterator(const path& __p,
1969 directory_options __xoptions, error_code& __ec) _NOEXCEPT
1970 : recursive_directory_iterator(__p, __xoptions, &__ec)
1971 { }
1972
1973 _LIBCPP_INLINE_VISIBILITY
1974 recursive_directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
1975 : recursive_directory_iterator(__p, directory_options::none, &__ec)
1976 { }
1977
1978 recursive_directory_iterator(const recursive_directory_iterator&) = default;
1979 recursive_directory_iterator(recursive_directory_iterator&&) = default;
1980
1981 recursive_directory_iterator &
1982 operator=(const recursive_directory_iterator&) = default;
1983
1984 _LIBCPP_INLINE_VISIBILITY
1985 recursive_directory_iterator &
1986 operator=(recursive_directory_iterator&& __o) noexcept {
1987 // non-default implementation provided to support self-move assign.
1988 if (this != &__o) {
1989 __imp_ = _VSTD::move(__o.__imp_);
1990 __rec_ = __o.__rec_;
1991 }
1992 return *this;
1993 }
1994
1995 ~recursive_directory_iterator() = default;
1996
1997 _LIBCPP_INLINE_VISIBILITY
1998 const directory_entry& operator*() const
1999 { return __deref(); }
2000
2001 _LIBCPP_INLINE_VISIBILITY
2002 const directory_entry* operator->() const
2003 { return &__deref(); }
2004
2005 recursive_directory_iterator& operator++()
2006 { return __increment(); }
2007
2008 _LIBCPP_INLINE_VISIBILITY
2009 __dir_element_proxy operator++(int) {
2010 __dir_element_proxy __p(**this);
2011 __increment();
2012 return __p;
2013 }
2014
2015 _LIBCPP_INLINE_VISIBILITY
2016 recursive_directory_iterator& increment(error_code& __ec) _NOEXCEPT
2017 { return __increment(&__ec); }
2018
2019 _LIBCPP_FUNC_VIS directory_options options() const;
2020 _LIBCPP_FUNC_VIS int depth() const;
2021
2022 _LIBCPP_INLINE_VISIBILITY
2023 void pop() { __pop(); }
2024
2025 _LIBCPP_INLINE_VISIBILITY
2026 void pop(error_code& __ec)
2027 { __pop(&__ec); }
2028
2029 _LIBCPP_INLINE_VISIBILITY
2030 bool recursion_pending() const
2031 { return __rec_; }
2032
2033 _LIBCPP_INLINE_VISIBILITY
2034 void disable_recursion_pending()
2035 { __rec_ = false; }
2036
2037private:
2038 recursive_directory_iterator(const path& __p, directory_options __opt,
2039 error_code *__ec);
2040
2041 _LIBCPP_FUNC_VIS
2042 const directory_entry& __deref() const;
2043
2044 _LIBCPP_FUNC_VIS
2045 bool __try_recursion(error_code* __ec);
2046
2047 _LIBCPP_FUNC_VIS
2048 void __advance(error_code* __ec=nullptr);
2049
2050 _LIBCPP_FUNC_VIS
2051 recursive_directory_iterator& __increment(error_code *__ec=nullptr);
2052
2053 _LIBCPP_FUNC_VIS
2054 void __pop(error_code* __ec=nullptr);
2055
Eric Fiselier03f7d102016-09-16 00:07:16 +00002056 inline _LIBCPP_INLINE_VISIBILITY
Eric Fiselier6e9a6942016-06-17 19:46:40 +00002057 friend bool operator==(const recursive_directory_iterator&,
2058 const recursive_directory_iterator&) _NOEXCEPT;
2059
2060 struct __shared_imp;
2061 shared_ptr<__shared_imp> __imp_;
2062 bool __rec_;
2063}; // class recursive_directory_iterator
2064
2065
Eric Fiselier03f7d102016-09-16 00:07:16 +00002066inline _LIBCPP_INLINE_VISIBILITY
2067bool operator==(const recursive_directory_iterator& __lhs,
2068 const recursive_directory_iterator& __rhs) _NOEXCEPT
Eric Fiselier6e9a6942016-06-17 19:46:40 +00002069{
2070 return __lhs.__imp_ == __rhs.__imp_;
2071}
2072
2073_LIBCPP_INLINE_VISIBILITY
2074inline bool operator!=(const recursive_directory_iterator& __lhs,
2075 const recursive_directory_iterator& __rhs) _NOEXCEPT
2076{
2077 return !(__lhs == __rhs);
2078}
2079// enable recursive_directory_iterator range-based for statements
2080inline _LIBCPP_INLINE_VISIBILITY
2081recursive_directory_iterator begin(recursive_directory_iterator __iter) _NOEXCEPT {
2082 return __iter;
2083}
2084
2085inline _LIBCPP_INLINE_VISIBILITY
2086recursive_directory_iterator end(const recursive_directory_iterator&) _NOEXCEPT {
2087 return recursive_directory_iterator();
2088}
2089
2090_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
2091
2092#endif // _LIBCPP_EXPERIMENTAL_FILESYSTEM