Coverage Report

Created: 2020-02-25 14:32

/Users/buildslave/jenkins/workspace/coverage/llvm-project/libcxx/include/filesystem
Line
Count
Source (jump to first uncovered line)
1
// -*- C++ -*-
2
//===--------------------------- filesystem -------------------------------===//
3
//
4
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5
// See https://llvm.org/LICENSE.txt for license information.
6
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7
//
8
//===----------------------------------------------------------------------===//
9
#ifndef _LIBCPP_FILESYSTEM
10
#define _LIBCPP_FILESYSTEM
11
/*
12
    filesystem synopsis
13
14
    namespace std { namespace filesystem {
15
16
    class path;
17
18
    void swap(path& lhs, path& rhs) noexcept;
19
    size_t hash_value(const path& p) noexcept;
20
21
    bool operator==(const path& lhs, const path& rhs) noexcept;
22
    bool operator!=(const path& lhs, const path& rhs) noexcept;
23
    bool operator< (const path& lhs, const path& rhs) noexcept;
24
    bool operator<=(const path& lhs, const path& rhs) noexcept;
25
    bool operator> (const path& lhs, const path& rhs) noexcept;
26
    bool operator>=(const path& lhs, const path& rhs) noexcept;
27
28
    path operator/ (const path& lhs, const path& rhs);
29
30
    // fs.path.io operators are friends of path.
31
    template <class charT, class traits>
32
    friend basic_ostream<charT, traits>&
33
    operator<<(basic_ostream<charT, traits>& os, const path& p);
34
35
    template <class charT, class traits>
36
    friend basic_istream<charT, traits>&
37
    operator>>(basic_istream<charT, traits>& is, path& p);
38
39
    template <class Source>
40
      path u8path(const Source& source);
41
    template <class InputIterator>
42
      path u8path(InputIterator first, InputIterator last);
43
44
    class filesystem_error;
45
    class directory_entry;
46
47
    class directory_iterator;
48
49
    // enable directory_iterator range-based for statements
50
    directory_iterator begin(directory_iterator iter) noexcept;
51
    directory_iterator end(const directory_iterator&) noexcept;
52
53
    class recursive_directory_iterator;
54
55
    // enable recursive_directory_iterator range-based for statements
56
    recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
57
    recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
58
59
    class file_status;
60
61
    struct space_info
62
    {
63
      uintmax_t capacity;
64
      uintmax_t free;
65
      uintmax_t available;
66
    };
67
68
    enum class file_type;
69
    enum class perms;
70
    enum class perm_options;
71
    enum class copy_options;
72
    enum class directory_options;
73
74
    typedef chrono::time_point<trivial-clock>  file_time_type;
75
76
    // operational functions
77
78
    path absolute(const path& p);
79
    path absolute(const path& p, error_code &ec);
80
81
    path canonical(const path& p);
82
    path canonical(const path& p, error_code& ec);
83
84
    void copy(const path& from, const path& to);
85
    void copy(const path& from, const path& to, error_code& ec);
86
    void copy(const path& from, const path& to, copy_options options);
87
    void copy(const path& from, const path& to, copy_options options,
88
                   error_code& ec);
89
90
    bool copy_file(const path& from, const path& to);
91
    bool copy_file(const path& from, const path& to, error_code& ec);
92
    bool copy_file(const path& from, const path& to, copy_options option);
93
    bool copy_file(const path& from, const path& to, copy_options option,
94
                           error_code& ec);
95
96
    void copy_symlink(const path& existing_symlink, const path& new_symlink);
97
    void copy_symlink(const path& existing_symlink, const path& new_symlink,
98
                              error_code& ec) noexcept;
99
100
    bool create_directories(const path& p);
101
    bool create_directories(const path& p, error_code& ec);
102
103
    bool create_directory(const path& p);
104
    bool create_directory(const path& p, error_code& ec) noexcept;
105
106
    bool create_directory(const path& p, const path& attributes);
107
    bool create_directory(const path& p, const path& attributes,
108
                                  error_code& ec) noexcept;
109
110
    void create_directory_symlink(const path& to, const path& new_symlink);
111
    void create_directory_symlink(const path& to, const path& new_symlink,
112
                                          error_code& ec) noexcept;
113
114
    void create_hard_link(const path& to, const path& new_hard_link);
115
    void create_hard_link(const path& to, const path& new_hard_link,
116
                                  error_code& ec) noexcept;
117
118
    void create_symlink(const path& to, const path& new_symlink);
119
    void create_symlink(const path& to, const path& new_symlink,
120
                                error_code& ec) noexcept;
121
122
    path current_path();
123
    path current_path(error_code& ec);
124
    void current_path(const path& p);
125
    void current_path(const path& p, error_code& ec) noexcept;
126
127
    bool exists(file_status s) noexcept;
128
    bool exists(const path& p);
129
    bool exists(const path& p, error_code& ec) noexcept;
130
131
    bool equivalent(const path& p1, const path& p2);
132
    bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
133
134
    uintmax_t    file_size(const path& p);
135
    uintmax_t    file_size(const path& p, error_code& ec) noexcept;
136
137
    uintmax_t    hard_link_count(const path& p);
138
    uintmax_t    hard_link_count(const path& p, error_code& ec) noexcept;
139
140
    bool is_block_file(file_status s) noexcept;
141
    bool is_block_file(const path& p);
142
    bool is_block_file(const path& p, error_code& ec) noexcept;
143
144
    bool is_character_file(file_status s) noexcept;
145
    bool is_character_file(const path& p);
146
    bool is_character_file(const path& p, error_code& ec) noexcept;
147
148
    bool is_directory(file_status s) noexcept;
149
    bool is_directory(const path& p);
150
    bool is_directory(const path& p, error_code& ec) noexcept;
151
152
    bool is_empty(const path& p);
153
    bool is_empty(const path& p, error_code& ec) noexcept;
154
155
    bool is_fifo(file_status s) noexcept;
156
    bool is_fifo(const path& p);
157
    bool is_fifo(const path& p, error_code& ec) noexcept;
158
159
    bool is_other(file_status s) noexcept;
160
    bool is_other(const path& p);
161
    bool is_other(const path& p, error_code& ec) noexcept;
162
163
    bool is_regular_file(file_status s) noexcept;
164
    bool is_regular_file(const path& p);
165
    bool is_regular_file(const path& p, error_code& ec) noexcept;
166
167
    bool is_socket(file_status s) noexcept;
168
    bool is_socket(const path& p);
169
    bool is_socket(const path& p, error_code& ec) noexcept;
170
171
    bool is_symlink(file_status s) noexcept;
172
    bool is_symlink(const path& p);
173
    bool is_symlink(const path& p, error_code& ec) noexcept;
174
175
    file_time_type  last_write_time(const path& p);
176
    file_time_type  last_write_time(const path& p, error_code& ec) noexcept;
177
    void last_write_time(const path& p, file_time_type new_time);
178
    void last_write_time(const path& p, file_time_type new_time,
179
                                 error_code& ec) noexcept;
180
181
    void permissions(const path& p, perms prms,
182
                     perm_options opts=perm_options::replace);
183
    void permissions(const path& p, perms prms, error_code& ec) noexcept;
184
    void permissions(const path& p, perms prms, perm_options opts,
185
                     error_code& ec);
186
187
    path proximate(const path& p, error_code& ec);
188
    path proximate(const path& p, const path& base = current_path());
189
    path proximate(const path& p, const path& base, error_code &ec);
190
191
    path read_symlink(const path& p);
192
    path read_symlink(const path& p, error_code& ec);
193
194
    path relative(const path& p, error_code& ec);
195
    path relative(const path& p, const path& base=current_path());
196
    path relative(const path& p, const path& base, error_code& ec);
197
198
    bool remove(const path& p);
199
    bool remove(const path& p, error_code& ec) noexcept;
200
201
    uintmax_t    remove_all(const path& p);
202
    uintmax_t    remove_all(const path& p, error_code& ec);
203
204
    void rename(const path& from, const path& to);
205
    void rename(const path& from, const path& to, error_code& ec) noexcept;
206
207
    void resize_file(const path& p, uintmax_t size);
208
    void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;
209
210
    space_info   space(const path& p);
211
    space_info   space(const path& p, error_code& ec) noexcept;
212
213
    file_status  status(const path& p);
214
    file_status  status(const path& p, error_code& ec) noexcept;
215
216
    bool status_known(file_status s) noexcept;
217
218
    file_status  symlink_status(const path& p);
219
    file_status  symlink_status(const path& p, error_code& ec) noexcept;
220
221
    path temp_directory_path();
222
    path temp_directory_path(error_code& ec);
223
224
    path weakly_canonical(path const& p);
225
    path weakly_canonical(path const& p, error_code& ec);
226
227
228
} }  // namespaces std::filesystem
229
230
*/
231
232
#include <__config>
233
#include <cstddef>
234
#include <cstdlib>
235
#include <chrono>
236
#include <iterator>
237
#include <iosfwd>
238
#include <locale>
239
#include <memory>
240
#include <stack>
241
#include <string>
242
#include <system_error>
243
#include <utility>
244
#include <iomanip> // for quoted
245
#include <string_view>
246
#include <version>
247
248
#include <__debug>
249
250
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
251
#pragma GCC system_header
252
#endif
253
254
_LIBCPP_PUSH_MACROS
255
#include <__undef_macros>
256
257
#ifndef _LIBCPP_CXX03_LANG
258
259
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
260
261
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
262
263
typedef chrono::time_point<_FilesystemClock> file_time_type;
264
265
struct _LIBCPP_TYPE_VIS space_info {
266
  uintmax_t capacity;
267
  uintmax_t free;
268
  uintmax_t available;
269
};
270
271
enum class _LIBCPP_ENUM_VIS file_type : signed char {
272
  none = 0,
273
  not_found = -1,
274
  regular = 1,
275
  directory = 2,
276
  symlink = 3,
277
  block = 4,
278
  character = 5,
279
  fifo = 6,
280
  socket = 7,
281
  unknown = 8
282
};
283
284
enum class _LIBCPP_ENUM_VIS perms : unsigned {
285
  none = 0,
286
287
  owner_read = 0400,
288
  owner_write = 0200,
289
  owner_exec = 0100,
290
  owner_all = 0700,
291
292
  group_read = 040,
293
  group_write = 020,
294
  group_exec = 010,
295
  group_all = 070,
296
297
  others_read = 04,
298
  others_write = 02,
299
  others_exec = 01,
300
  others_all = 07,
301
302
  all = 0777,
303
304
  set_uid = 04000,
305
  set_gid = 02000,
306
  sticky_bit = 01000,
307
  mask = 07777,
308
  unknown = 0xFFFF,
309
};
310
311
_LIBCPP_INLINE_VISIBILITY
312
0
inline constexpr perms operator&(perms _LHS, perms _RHS) {
313
0
  return static_cast<perms>(static_cast<unsigned>(_LHS) &
314
0
                            static_cast<unsigned>(_RHS));
315
0
}
316
317
_LIBCPP_INLINE_VISIBILITY
318
0
inline constexpr perms operator|(perms _LHS, perms _RHS) {
319
0
  return static_cast<perms>(static_cast<unsigned>(_LHS) |
320
0
                            static_cast<unsigned>(_RHS));
321
0
}
322
323
_LIBCPP_INLINE_VISIBILITY
324
0
inline constexpr perms operator^(perms _LHS, perms _RHS) {
325
0
  return static_cast<perms>(static_cast<unsigned>(_LHS) ^
326
0
                            static_cast<unsigned>(_RHS));
327
0
}
328
329
_LIBCPP_INLINE_VISIBILITY
330
0
inline constexpr perms operator~(perms _LHS) {
331
0
  return static_cast<perms>(~static_cast<unsigned>(_LHS));
332
0
}
333
334
_LIBCPP_INLINE_VISIBILITY
335
0
inline perms& operator&=(perms& _LHS, perms _RHS) { return _LHS = _LHS & _RHS; }
336
337
_LIBCPP_INLINE_VISIBILITY
338
0
inline perms& operator|=(perms& _LHS, perms _RHS) { return _LHS = _LHS | _RHS; }
339
340
_LIBCPP_INLINE_VISIBILITY
341
0
inline perms& operator^=(perms& _LHS, perms _RHS) { return _LHS = _LHS ^ _RHS; }
342
343
enum class _LIBCPP_ENUM_VIS perm_options : unsigned char {
344
  replace = 1,
345
  add = 2,
346
  remove = 4,
347
  nofollow = 8
348
};
349
350
_LIBCPP_INLINE_VISIBILITY
351
0
inline constexpr perm_options operator&(perm_options _LHS, perm_options _RHS) {
352
0
  return static_cast<perm_options>(static_cast<unsigned>(_LHS) &
353
0
                                   static_cast<unsigned>(_RHS));
354
0
}
355
356
_LIBCPP_INLINE_VISIBILITY
357
0
inline constexpr perm_options operator|(perm_options _LHS, perm_options _RHS) {
358
0
  return static_cast<perm_options>(static_cast<unsigned>(_LHS) |
359
0
                                   static_cast<unsigned>(_RHS));
360
0
}
361
362
_LIBCPP_INLINE_VISIBILITY
363
0
inline constexpr perm_options operator^(perm_options _LHS, perm_options _RHS) {
364
0
  return static_cast<perm_options>(static_cast<unsigned>(_LHS) ^
365
0
                                   static_cast<unsigned>(_RHS));
366
0
}
367
368
_LIBCPP_INLINE_VISIBILITY
369
0
inline constexpr perm_options operator~(perm_options _LHS) {
370
0
  return static_cast<perm_options>(~static_cast<unsigned>(_LHS));
371
0
}
372
373
_LIBCPP_INLINE_VISIBILITY
374
0
inline perm_options& operator&=(perm_options& _LHS, perm_options _RHS) {
375
0
  return _LHS = _LHS & _RHS;
376
0
}
377
378
_LIBCPP_INLINE_VISIBILITY
379
0
inline perm_options& operator|=(perm_options& _LHS, perm_options _RHS) {
380
0
  return _LHS = _LHS | _RHS;
381
0
}
382
383
_LIBCPP_INLINE_VISIBILITY
384
0
inline perm_options& operator^=(perm_options& _LHS, perm_options _RHS) {
385
0
  return _LHS = _LHS ^ _RHS;
386
0
}
387
388
enum class _LIBCPP_ENUM_VIS copy_options : unsigned short {
389
  none = 0,
390
  skip_existing = 1,
391
  overwrite_existing = 2,
392
  update_existing = 4,
393
  recursive = 8,
394
  copy_symlinks = 16,
395
  skip_symlinks = 32,
396
  directories_only = 64,
397
  create_symlinks = 128,
398
  create_hard_links = 256,
399
  __in_recursive_copy = 512,
400
};
401
402
_LIBCPP_INLINE_VISIBILITY
403
0
inline constexpr copy_options operator&(copy_options _LHS, copy_options _RHS) {
404
0
  return static_cast<copy_options>(static_cast<unsigned short>(_LHS) &
405
0
                                   static_cast<unsigned short>(_RHS));
406
0
}
407
408
_LIBCPP_INLINE_VISIBILITY
409
0
inline constexpr copy_options operator|(copy_options _LHS, copy_options _RHS) {
410
0
  return static_cast<copy_options>(static_cast<unsigned short>(_LHS) |
411
0
                                   static_cast<unsigned short>(_RHS));
412
0
}
413
414
_LIBCPP_INLINE_VISIBILITY
415
0
inline constexpr copy_options operator^(copy_options _LHS, copy_options _RHS) {
416
0
  return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^
417
0
                                   static_cast<unsigned short>(_RHS));
418
0
}
419
420
_LIBCPP_INLINE_VISIBILITY
421
0
inline constexpr copy_options operator~(copy_options _LHS) {
422
0
  return static_cast<copy_options>(~static_cast<unsigned short>(_LHS));
423
0
}
424
425
_LIBCPP_INLINE_VISIBILITY
426
0
inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS) {
427
0
  return _LHS = _LHS & _RHS;
428
0
}
429
430
_LIBCPP_INLINE_VISIBILITY
431
0
inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS) {
432
0
  return _LHS = _LHS | _RHS;
433
0
}
434
435
_LIBCPP_INLINE_VISIBILITY
436
0
inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS) {
437
0
  return _LHS = _LHS ^ _RHS;
438
0
}
439
440
enum class _LIBCPP_ENUM_VIS directory_options : unsigned char {
441
  none = 0,
442
  follow_directory_symlink = 1,
443
  skip_permission_denied = 2
444
};
445
446
_LIBCPP_INLINE_VISIBILITY
447
inline constexpr directory_options operator&(directory_options _LHS,
448
0
                                             directory_options _RHS) {
449
0
  return static_cast<directory_options>(static_cast<unsigned char>(_LHS) &
450
0
                                        static_cast<unsigned char>(_RHS));
451
0
}
452
453
_LIBCPP_INLINE_VISIBILITY
454
inline constexpr directory_options operator|(directory_options _LHS,
455
0
                                             directory_options _RHS) {
456
0
  return static_cast<directory_options>(static_cast<unsigned char>(_LHS) |
457
0
                                        static_cast<unsigned char>(_RHS));
458
0
}
459
460
_LIBCPP_INLINE_VISIBILITY
461
inline constexpr directory_options operator^(directory_options _LHS,
462
0
                                             directory_options _RHS) {
463
0
  return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^
464
0
                                        static_cast<unsigned char>(_RHS));
465
0
}
466
467
_LIBCPP_INLINE_VISIBILITY
468
0
inline constexpr directory_options operator~(directory_options _LHS) {
469
0
  return static_cast<directory_options>(~static_cast<unsigned char>(_LHS));
470
0
}
471
472
_LIBCPP_INLINE_VISIBILITY
473
inline directory_options& operator&=(directory_options& _LHS,
474
0
                                     directory_options _RHS) {
475
0
  return _LHS = _LHS & _RHS;
476
0
}
477
478
_LIBCPP_INLINE_VISIBILITY
479
inline directory_options& operator|=(directory_options& _LHS,
480
0
                                     directory_options _RHS) {
481
0
  return _LHS = _LHS | _RHS;
482
0
}
483
484
_LIBCPP_INLINE_VISIBILITY
485
inline directory_options& operator^=(directory_options& _LHS,
486
0
                                     directory_options _RHS) {
487
0
  return _LHS = _LHS ^ _RHS;
488
0
}
489
490
class _LIBCPP_TYPE_VIS file_status {
491
public:
492
  // constructors
493
  _LIBCPP_INLINE_VISIBILITY
494
0
  file_status() noexcept : file_status(file_type::none) {}
Unexecuted instantiation: std::__1::__fs::filesystem::file_status::file_status()
Unexecuted instantiation: std::__1::__fs::filesystem::file_status::file_status()
495
  _LIBCPP_INLINE_VISIBILITY
496
  explicit file_status(file_type __ft, perms __prms = perms::unknown) noexcept
497
      : __ft_(__ft),
498
0
        __prms_(__prms) {}
499
500
  file_status(const file_status&) noexcept = default;
501
  file_status(file_status&&) noexcept = default;
502
503
  _LIBCPP_INLINE_VISIBILITY
504
0
  ~file_status() {}
505
506
  file_status& operator=(const file_status&) noexcept = default;
507
  file_status& operator=(file_status&&) noexcept = default;
508
509
  // observers
510
  _LIBCPP_INLINE_VISIBILITY
511
0
  file_type type() const noexcept { return __ft_; }
512
513
  _LIBCPP_INLINE_VISIBILITY
514
0
  perms permissions() const noexcept { return __prms_; }
515
516
  // modifiers
517
  _LIBCPP_INLINE_VISIBILITY
518
0
  void type(file_type __ft) noexcept { __ft_ = __ft; }
519
520
  _LIBCPP_INLINE_VISIBILITY
521
0
  void permissions(perms __p) noexcept { __prms_ = __p; }
522
523
private:
524
  file_type __ft_;
525
  perms __prms_;
526
};
527
528
class _LIBCPP_TYPE_VIS directory_entry;
529
530
template <class _Tp>
531
struct __can_convert_char {
532
  static const bool value = false;
533
};
534
template <class _Tp>
535
struct __can_convert_char<const _Tp> : public __can_convert_char<_Tp> {};
536
template <>
537
struct __can_convert_char<char> {
538
  static const bool value = true;
539
  using __char_type = char;
540
};
541
template <>
542
struct __can_convert_char<wchar_t> {
543
  static const bool value = true;
544
  using __char_type = wchar_t;
545
};
546
template <>
547
struct __can_convert_char<char16_t> {
548
  static const bool value = true;
549
  using __char_type = char16_t;
550
};
551
template <>
552
struct __can_convert_char<char32_t> {
553
  static const bool value = true;
554
  using __char_type = char32_t;
555
};
556
557
template <class _ECharT>
558
typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
559
0
__is_separator(_ECharT __e) {
560
0
  return __e == _ECharT('/');
561
0
}
562
563
struct _NullSentinal {};
564
565
template <class _Tp>
566
using _Void = void;
567
568
template <class _Tp, class = void>
569
struct __is_pathable_string : public false_type {};
570
571
template <class _ECharT, class _Traits, class _Alloc>
572
struct __is_pathable_string<
573
    basic_string<_ECharT, _Traits, _Alloc>,
574
    _Void<typename __can_convert_char<_ECharT>::__char_type> >
575
    : public __can_convert_char<_ECharT> {
576
  using _Str = basic_string<_ECharT, _Traits, _Alloc>;
577
  using _Base = __can_convert_char<_ECharT>;
578
0
  static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
579
0
  static _ECharT const* __range_end(_Str const& __s) {
580
0
    return __s.data() + __s.length();
581
0
  }
582
0
  static _ECharT __first_or_null(_Str const& __s) {
583
0
    return __s.empty() ? _ECharT{} : __s[0];
584
0
  }
585
};
586
587
template <class _ECharT, class _Traits>
588
struct __is_pathable_string<
589
    basic_string_view<_ECharT, _Traits>,
590
    _Void<typename __can_convert_char<_ECharT>::__char_type> >
591
    : public __can_convert_char<_ECharT> {
592
  using _Str = basic_string_view<_ECharT, _Traits>;
593
  using _Base = __can_convert_char<_ECharT>;
594
0
  static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
595
0
  static _ECharT const* __range_end(_Str const& __s) {
596
0
    return __s.data() + __s.length();
597
0
  }
598
0
  static _ECharT __first_or_null(_Str const& __s) {
599
0
    return __s.empty() ? _ECharT{} : __s[0];
600
0
  }
601
};
602
603
template <class _Source, class _DS = typename decay<_Source>::type,
604
          class _UnqualPtrType =
605
              typename remove_const<typename remove_pointer<_DS>::type>::type,
606
          bool _IsCharPtr = is_pointer<_DS>::value&&
607
              __can_convert_char<_UnqualPtrType>::value>
608
struct __is_pathable_char_array : false_type {};
609
610
template <class _Source, class _ECharT, class _UPtr>
611
struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
612
    : __can_convert_char<typename remove_const<_ECharT>::type> {
613
  using _Base = __can_convert_char<typename remove_const<_ECharT>::type>;
614
615
0
  static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char*, char*, char, true>::__range_begin(char const*)
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char const*, char const*, char, true>::__range_begin(char const*)
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char [1], char*, char, true>::__range_begin(char const*)
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char [2], char*, char, true>::__range_begin(char const*)
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char [3], char*, char, true>::__range_begin(char const*)
616
0
  static _ECharT const* __range_end(const _ECharT* __b) {
617
0
    using _Iter = const _ECharT*;
618
0
    const _ECharT __sentinal = _ECharT{};
619
0
    _Iter __e = __b;
620
0
    for (; *__e != __sentinal; ++__e)
621
0
      ;
622
0
    return __e;
623
0
  }
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char*, char*, char, true>::__range_end(char const*)
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char const*, char const*, char, true>::__range_end(char const*)
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char [1], char*, char, true>::__range_end(char const*)
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char [2], char*, char, true>::__range_end(char const*)
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char [3], char*, char, true>::__range_end(char const*)
624
625
0
  static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char [1], char*, char, true>::__first_or_null(char const*)
Unexecuted instantiation: std::__1::__fs::filesystem::__is_pathable_char_array<char [3], char*, char, true>::__first_or_null(char const*)
626
};
627
628
template <class _Iter, bool _IsIt = __is_cpp17_input_iterator<_Iter>::value,
629
          class = void>
630
struct __is_pathable_iter : false_type {};
631
632
template <class _Iter>
633
struct __is_pathable_iter<
634
    _Iter, true,
635
    _Void<typename __can_convert_char<
636
        typename iterator_traits<_Iter>::value_type>::__char_type> >
637
    : __can_convert_char<typename iterator_traits<_Iter>::value_type> {
638
  using _ECharT = typename iterator_traits<_Iter>::value_type;
639
  using _Base = __can_convert_char<_ECharT>;
640
641
  static _Iter __range_begin(_Iter __b) { return __b; }
642
  static _NullSentinal __range_end(_Iter) { return _NullSentinal{}; }
643
644
  static _ECharT __first_or_null(_Iter __b) { return *__b; }
645
};
646
647
template <class _Tp, bool _IsStringT = __is_pathable_string<_Tp>::value,
648
          bool _IsCharIterT = __is_pathable_char_array<_Tp>::value,
649
          bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value>
650
struct __is_pathable : false_type {
651
  static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false");
652
};
653
654
template <class _Tp>
655
struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {};
656
657
template <class _Tp>
658
struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {
659
};
660
661
template <class _Tp>
662
struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
663
664
template <class _ECharT>
665
struct _PathCVT {
666
  static_assert(__can_convert_char<_ECharT>::value,
667
                "Char type not convertible");
668
669
  typedef __narrow_to_utf8<sizeof(_ECharT) * __CHAR_BIT__> _Narrower;
670
671
  static void __append_range(string& __dest, _ECharT const* __b,
672
                             _ECharT const* __e) {
673
    _Narrower()(back_inserter(__dest), __b, __e);
674
  }
675
676
  template <class _Iter>
677
  static void __append_range(string& __dest, _Iter __b, _Iter __e) {
678
    static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
679
    if (__b == __e)
680
      return;
681
    basic_string<_ECharT> __tmp(__b, __e);
682
    _Narrower()(back_inserter(__dest), __tmp.data(),
683
                __tmp.data() + __tmp.length());
684
  }
685
686
  template <class _Iter>
687
  static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
688
    static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
689
    const _ECharT __sentinal = _ECharT{};
690
    if (*__b == __sentinal)
691
      return;
692
    basic_string<_ECharT> __tmp;
693
    for (; *__b != __sentinal; ++__b)
694
      __tmp.push_back(*__b);
695
    _Narrower()(back_inserter(__dest), __tmp.data(),
696
                __tmp.data() + __tmp.length());
697
  }
698
699
  template <class _Source>
700
  static void __append_source(string& __dest, _Source const& __s) {
701
    using _Traits = __is_pathable<_Source>;
702
    __append_range(__dest, _Traits::__range_begin(__s),
703
                   _Traits::__range_end(__s));
704
  }
705
};
706
707
template <>
708
struct _PathCVT<char> {
709
710
  template <class _Iter>
711
  static typename enable_if<__is_exactly_cpp17_input_iterator<_Iter>::value>::type
712
  __append_range(string& __dest, _Iter __b, _Iter __e) {
713
    for (; __b != __e; ++__b)
714
      __dest.push_back(*__b);
715
  }
716
717
  template <class _Iter>
718
  static typename enable_if<__is_cpp17_forward_iterator<_Iter>::value>::type
719
0
  __append_range(string& __dest, _Iter __b, _Iter __e) {
720
0
    __dest.__append_forward_unsafe(__b, __e);
721
0
  }
722
723
  template <class _Iter>
724
  static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
725
    const char __sentinal = char{};
726
    for (; *__b != __sentinal; ++__b)
727
      __dest.push_back(*__b);
728
  }
729
730
  template <class _Source>
731
0
  static void __append_source(string& __dest, _Source const& __s) {
732
0
    using _Traits = __is_pathable<_Source>;
733
0
    __append_range(__dest, _Traits::__range_begin(__s),
734
0
                   _Traits::__range_end(__s));
735
0
  }
Unexecuted instantiation: void std::__1::__fs::filesystem::_PathCVT<char>::__append_source<char*>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char* const&)
Unexecuted instantiation: void std::__1::__fs::filesystem::_PathCVT<char>::__append_source<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Unexecuted instantiation: void std::__1::__fs::filesystem::_PathCVT<char>::__append_source<char const*>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const* const&)
Unexecuted instantiation: void std::__1::__fs::filesystem::_PathCVT<char>::__append_source<char [1]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [1])
Unexecuted instantiation: void std::__1::__fs::filesystem::_PathCVT<char>::__append_source<std::__1::basic_string_view<char, std::__1::char_traits<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::basic_string_view<char, std::__1::char_traits<char> > const&)
Unexecuted instantiation: void std::__1::__fs::filesystem::_PathCVT<char>::__append_source<char [2]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [2])
Unexecuted instantiation: void std::__1::__fs::filesystem::_PathCVT<char>::__append_source<char [3]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, char const (&) [3])
736
};
737
738
class _LIBCPP_TYPE_VIS path {
739
  template <class _SourceOrIter, class _Tp = path&>
740
  using _EnableIfPathable =
741
      typename enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
742
743
  template <class _Tp>
744
  using _SourceChar = typename __is_pathable<_Tp>::__char_type;
745
746
  template <class _Tp>
747
  using _SourceCVT = _PathCVT<_SourceChar<_Tp> >;
748
749
public:
750
  typedef char value_type;
751
  typedef basic_string<value_type> string_type;
752
  typedef _VSTD::string_view __string_view;
753
  static constexpr value_type preferred_separator = '/';
754
755
  enum class _LIBCPP_ENUM_VIS format : unsigned char {
756
    auto_format,
757
    native_format,
758
    generic_format
759
  };
760
761
  // constructors and destructor
762
0
  _LIBCPP_INLINE_VISIBILITY path() noexcept {}
763
0
  _LIBCPP_INLINE_VISIBILITY path(const path& __p) : __pn_(__p.__pn_) {}
764
  _LIBCPP_INLINE_VISIBILITY path(path&& __p) noexcept
765
0
      : __pn_(_VSTD::move(__p.__pn_)) {}
766
767
  _LIBCPP_INLINE_VISIBILITY
768
  path(string_type&& __s, format = format::auto_format) noexcept
769
0
      : __pn_(_VSTD::move(__s)) {}
770
771
  template <class _Source, class = _EnableIfPathable<_Source, void> >
772
0
  path(const _Source& __src, format = format::auto_format) {
773
0
    _SourceCVT<_Source>::__append_source(__pn_, __src);
774
0
  }
Unexecuted instantiation: std::__1::__fs::filesystem::path::path<char*, void>(char* const&, std::__1::__fs::filesystem::path::format)
Unexecuted instantiation: std::__1::__fs::filesystem::path::path<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, void>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::__fs::filesystem::path::format)
Unexecuted instantiation: std::__1::__fs::filesystem::path::path<char const*, void>(char const* const&, std::__1::__fs::filesystem::path::format)
Unexecuted instantiation: std::__1::__fs::filesystem::path::path<char [1], void>(char const (&) [1], std::__1::__fs::filesystem::path::format)
Unexecuted instantiation: std::__1::__fs::filesystem::path::path<char [2], void>(char const (&) [2], std::__1::__fs::filesystem::path::format)
Unexecuted instantiation: std::__1::__fs::filesystem::path::path<std::__1::basic_string_view<char, std::__1::char_traits<char> >, void>(std::__1::basic_string_view<char, std::__1::char_traits<char> > const&, std::__1::__fs::filesystem::path::format)
775
776
  template <class _InputIt>
777
  path(_InputIt __first, _InputIt __last, format = format::auto_format) {
778
    typedef typename iterator_traits<_InputIt>::value_type _ItVal;
779
    _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
780
  }
781
782
  // TODO Implement locale conversions.
783
  template <class _Source, class = _EnableIfPathable<_Source, void> >
784
  path(const _Source& __src, const locale& __loc, format = format::auto_format);
785
  template <class _InputIt>
786
  path(_InputIt __first, _InputIt _last, const locale& __loc,
787
       format = format::auto_format);
788
789
  _LIBCPP_INLINE_VISIBILITY
790
0
  ~path() = default;
791
792
  // assignments
793
  _LIBCPP_INLINE_VISIBILITY
794
0
  path& operator=(const path& __p) {
795
0
    __pn_ = __p.__pn_;
796
0
    return *this;
797
0
  }
798
799
  _LIBCPP_INLINE_VISIBILITY
800
0
  path& operator=(path&& __p) noexcept {
801
0
    __pn_ = _VSTD::move(__p.__pn_);
802
0
    return *this;
803
0
  }
804
805
  template <class = void>
806
  _LIBCPP_INLINE_VISIBILITY path& operator=(string_type&& __s) noexcept {
807
    __pn_ = _VSTD::move(__s);
808
    return *this;
809
  }
810
811
  _LIBCPP_INLINE_VISIBILITY
812
0
  path& assign(string_type&& __s) noexcept {
813
0
    __pn_ = _VSTD::move(__s);
814
0
    return *this;
815
0
  }
816
817
  template <class _Source>
818
  _LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source>
819
  operator=(const _Source& __src) {
820
    return this->assign(__src);
821
  }
822
823
  template <class _Source>
824
0
  _EnableIfPathable<_Source> assign(const _Source& __src) {
825
0
    __pn_.clear();
826
0
    _SourceCVT<_Source>::__append_source(__pn_, __src);
827
0
    return *this;
828
0
  }
829
830
  template <class _InputIt>
831
  path& assign(_InputIt __first, _InputIt __last) {
832
    typedef typename iterator_traits<_InputIt>::value_type _ItVal;
833
    __pn_.clear();
834
    _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
835
    return *this;
836
  }
837
838
private:
839
  template <class _ECharT>
840
0
  static bool __source_is_absolute(_ECharT __first_or_null) {
841
0
    return __is_separator(__first_or_null);
842
0
  }
843
844
public:
845
  // appends
846
0
  path& operator/=(const path& __p) {
847
0
    if (__p.is_absolute()) {
848
0
      __pn_ = __p.__pn_;
849
0
      return *this;
850
0
    }
851
0
    if (has_filename())
852
0
      __pn_ += preferred_separator;
853
0
    __pn_ += __p.native();
854
0
    return *this;
855
0
  }
856
857
  // FIXME: Use _LIBCPP_DIAGNOSE_WARNING to produce a diagnostic when __src
858
  // is known at compile time to be "/' since the user almost certainly intended
859
  // to append a separator instead of overwriting the path with "/"
860
  template <class _Source>
861
  _LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source>
862
0
  operator/=(const _Source& __src) {
863
0
    return this->append(__src);
864
0
  }
Unexecuted instantiation: std::__1::enable_if<__is_pathable<std::__1::basic_string_view<char, std::__1::char_traits<char> > >::value, std::__1::__fs::filesystem::path&>::type std::__1::__fs::filesystem::path::operator/=<std::__1::basic_string_view<char, std::__1::char_traits<char> > >(std::__1::basic_string_view<char, std::__1::char_traits<char> > const&)
Unexecuted instantiation: std::__1::enable_if<__is_pathable<char [1]>::value, std::__1::__fs::filesystem::path&>::type std::__1::__fs::filesystem::path::operator/=<char [1]>(char const (&) [1])
Unexecuted instantiation: std::__1::enable_if<__is_pathable<char [3]>::value, std::__1::__fs::filesystem::path&>::type std::__1::__fs::filesystem::path::operator/=<char [3]>(char const (&) [3])
865
866
  template <class _Source>
867
0
  _EnableIfPathable<_Source> append(const _Source& __src) {
868
0
    using _Traits = __is_pathable<_Source>;
869
0
    using _CVT = _PathCVT<_SourceChar<_Source> >;
870
0
    if (__source_is_absolute(_Traits::__first_or_null(__src)))
871
0
      __pn_.clear();
872
0
    else if (has_filename())
873
0
      __pn_ += preferred_separator;
874
0
    _CVT::__append_source(__pn_, __src);
875
0
    return *this;
876
0
  }
Unexecuted instantiation: std::__1::enable_if<__is_pathable<std::__1::basic_string_view<char, std::__1::char_traits<char> > >::value, std::__1::__fs::filesystem::path&>::type std::__1::__fs::filesystem::path::append<std::__1::basic_string_view<char, std::__1::char_traits<char> > >(std::__1::basic_string_view<char, std::__1::char_traits<char> > const&)
Unexecuted instantiation: std::__1::enable_if<__is_pathable<char [1]>::value, std::__1::__fs::filesystem::path&>::type std::__1::__fs::filesystem::path::append<char [1]>(char const (&) [1])
Unexecuted instantiation: std::__1::enable_if<__is_pathable<char [3]>::value, std::__1::__fs::filesystem::path&>::type std::__1::__fs::filesystem::path::append<char [3]>(char const (&) [3])
Unexecuted instantiation: std::__1::enable_if<__is_pathable<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >::value, std::__1::__fs::filesystem::path&>::type std::__1::__fs::filesystem::path::append<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
877
878
  template <class _InputIt>
879
  path& append(_InputIt __first, _InputIt __last) {
880
    typedef typename iterator_traits<_InputIt>::value_type _ItVal;
881
    static_assert(__can_convert_char<_ItVal>::value, "Must convertible");
882
    using _CVT = _PathCVT<_ItVal>;
883
    if (__first != __last && __source_is_absolute(*__first))
884
      __pn_.clear();
885
    else if (has_filename())
886
      __pn_ += preferred_separator;
887
    _CVT::__append_range(__pn_, __first, __last);
888
    return *this;
889
  }
890
891
  // concatenation
892
  _LIBCPP_INLINE_VISIBILITY
893
0
  path& operator+=(const path& __x) {
894
0
    __pn_ += __x.__pn_;
895
0
    return *this;
896
0
  }
897
898
  _LIBCPP_INLINE_VISIBILITY
899
0
  path& operator+=(const string_type& __x) {
900
0
    __pn_ += __x;
901
0
    return *this;
902
0
  }
903
904
  _LIBCPP_INLINE_VISIBILITY
905
0
  path& operator+=(__string_view __x) {
906
0
    __pn_ += __x;
907
0
    return *this;
908
0
  }
909
910
  _LIBCPP_INLINE_VISIBILITY
911
0
  path& operator+=(const value_type* __x) {
912
0
    __pn_ += __x;
913
0
    return *this;
914
0
  }
915
916
  _LIBCPP_INLINE_VISIBILITY
917
0
  path& operator+=(value_type __x) {
918
0
    __pn_ += __x;
919
0
    return *this;
920
0
  }
921
922
  template <class _ECharT>
923
  typename enable_if<__can_convert_char<_ECharT>::value, path&>::type
924
  operator+=(_ECharT __x) {
925
    basic_string<_ECharT> __tmp;
926
    __tmp += __x;
927
    _PathCVT<_ECharT>::__append_source(__pn_, __tmp);
928
    return *this;
929
  }
930
931
  template <class _Source>
932
  _EnableIfPathable<_Source> operator+=(const _Source& __x) {
933
    return this->concat(__x);
934
  }
935
936
  template <class _Source>
937
  _EnableIfPathable<_Source> concat(const _Source& __x) {
938
    _SourceCVT<_Source>::__append_source(__pn_, __x);
939
    return *this;
940
  }
941
942
  template <class _InputIt>
943
  path& concat(_InputIt __first, _InputIt __last) {
944
    typedef typename iterator_traits<_InputIt>::value_type _ItVal;
945
    _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
946
    return *this;
947
  }
948
949
  // modifiers
950
  _LIBCPP_INLINE_VISIBILITY
951
0
  void clear() noexcept { __pn_.clear(); }
952
953
0
  path& make_preferred() { return *this; }
954
955
  _LIBCPP_INLINE_VISIBILITY
956
0
  path& remove_filename() {
957
0
    auto __fname = __filename();
958
0
    if (!__fname.empty())
959
0
      __pn_.erase(__fname.data() - __pn_.data());
960
0
    return *this;
961
0
  }
962
963
0
  path& replace_filename(const path& __replacement) {
964
0
    remove_filename();
965
0
    return (*this /= __replacement);
966
0
  }
967
968
  path& replace_extension(const path& __replacement = path());
969
970
  _LIBCPP_INLINE_VISIBILITY
971
0
  void swap(path& __rhs) noexcept { __pn_.swap(__rhs.__pn_); }
972
973
  // private helper to allow reserving memory in the path
974
  _LIBCPP_INLINE_VISIBILITY
975
0
  void __reserve(size_t __s) { __pn_.reserve(__s); }
976
977
  // native format observers
978
  _LIBCPP_INLINE_VISIBILITY
979
0
  const string_type& native() const noexcept { return __pn_; }
980
981
  _LIBCPP_INLINE_VISIBILITY
982
0
  const value_type* c_str() const noexcept { return __pn_.c_str(); }
983
984
0
  _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_; }
985
986
  template <class _ECharT, class _Traits = char_traits<_ECharT>,
987
            class _Allocator = allocator<_ECharT> >
988
  basic_string<_ECharT, _Traits, _Allocator>
989
0
  string(const _Allocator& __a = _Allocator()) const {
990
0
    using _CVT = __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__>;
991
0
    using _Str = basic_string<_ECharT, _Traits, _Allocator>;
992
0
    _Str __s(__a);
993
0
    __s.reserve(__pn_.size());
994
0
    _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
995
0
    return __s;
996
0
  }
Unexecuted instantiation: std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> > std::__1::__fs::filesystem::path::string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >(std::__1::allocator<wchar_t> const&) const
Unexecuted instantiation: std::__1::basic_string<char16_t, std::__1::char_traits<char16_t>, std::__1::allocator<char16_t> > std::__1::__fs::filesystem::path::string<char16_t, std::__1::char_traits<char16_t>, std::__1::allocator<char16_t> >(std::__1::allocator<char16_t> const&) const
Unexecuted instantiation: std::__1::basic_string<char32_t, std::__1::char_traits<char32_t>, std::__1::allocator<char32_t> > std::__1::__fs::filesystem::path::string<char32_t, std::__1::char_traits<char32_t>, std::__1::allocator<char32_t> >(std::__1::allocator<char32_t> const&) const
997
998
0
  _LIBCPP_INLINE_VISIBILITY std::string string() const { return __pn_; }
999
0
  _LIBCPP_INLINE_VISIBILITY std::wstring wstring() const {
1000
0
    return string<wchar_t>();
1001
0
  }
1002
0
  _LIBCPP_INLINE_VISIBILITY std::string u8string() const { return __pn_; }
1003
0
  _LIBCPP_INLINE_VISIBILITY std::u16string u16string() const {
1004
0
    return string<char16_t>();
1005
0
  }
1006
0
  _LIBCPP_INLINE_VISIBILITY std::u32string u32string() const {
1007
0
    return string<char32_t>();
1008
0
  }
1009
1010
  // generic format observers
1011
  template <class _ECharT, class _Traits = char_traits<_ECharT>,
1012
            class _Allocator = allocator<_ECharT> >
1013
  basic_string<_ECharT, _Traits, _Allocator>
1014
  generic_string(const _Allocator& __a = _Allocator()) const {
1015
    return string<_ECharT, _Traits, _Allocator>(__a);
1016
  }
1017
1018
0
  std::string generic_string() const { return __pn_; }
1019
0
  std::wstring generic_wstring() const { return string<wchar_t>(); }
1020
0
  std::string generic_u8string() const { return __pn_; }
1021
0
  std::u16string generic_u16string() const { return string<char16_t>(); }
1022
0
  std::u32string generic_u32string() const { return string<char32_t>(); }
1023
1024
private:
1025
  int __compare(__string_view) const;
1026
  __string_view __root_name() const;
1027
  __string_view __root_directory() const;
1028
  __string_view __root_path_raw() const;
1029
  __string_view __relative_path() const;
1030
  __string_view __parent_path() const;
1031
  __string_view __filename() const;
1032
  __string_view __stem() const;
1033
  __string_view __extension() const;
1034
1035
public:
1036
  // compare
1037
0
  _LIBCPP_INLINE_VISIBILITY int compare(const path& __p) const noexcept {
1038
0
    return __compare(__p.__pn_);
1039
0
  }
1040
0
  _LIBCPP_INLINE_VISIBILITY int compare(const string_type& __s) const {
1041
0
    return __compare(__s);
1042
0
  }
1043
0
  _LIBCPP_INLINE_VISIBILITY int compare(__string_view __s) const {
1044
0
    return __compare(__s);
1045
0
  }
1046
0
  _LIBCPP_INLINE_VISIBILITY int compare(const value_type* __s) const {
1047
0
    return __compare(__s);
1048
0
  }
1049
1050
  // decomposition
1051
0
  _LIBCPP_INLINE_VISIBILITY path root_name() const {
1052
0
    return string_type(__root_name());
1053
0
  }
1054
0
  _LIBCPP_INLINE_VISIBILITY path root_directory() const {
1055
0
    return string_type(__root_directory());
1056
0
  }
1057
0
  _LIBCPP_INLINE_VISIBILITY path root_path() const {
1058
0
    return root_name().append(string_type(__root_directory()));
1059
0
  }
1060
0
  _LIBCPP_INLINE_VISIBILITY path relative_path() const {
1061
0
    return string_type(__relative_path());
1062
0
  }
1063
0
  _LIBCPP_INLINE_VISIBILITY path parent_path() const {
1064
0
    return string_type(__parent_path());
1065
0
  }
1066
0
  _LIBCPP_INLINE_VISIBILITY path filename() const {
1067
0
    return string_type(__filename());
1068
0
  }
1069
0
  _LIBCPP_INLINE_VISIBILITY path stem() const { return string_type(__stem()); }
1070
0
  _LIBCPP_INLINE_VISIBILITY path extension() const {
1071
0
    return string_type(__extension());
1072
0
  }
1073
1074
  // query
1075
  _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY bool
1076
0
  empty() const noexcept {
1077
0
    return __pn_.empty();
1078
0
  }
1079
1080
0
  _LIBCPP_INLINE_VISIBILITY bool has_root_name() const {
1081
0
    return !__root_name().empty();
1082
0
  }
1083
0
  _LIBCPP_INLINE_VISIBILITY bool has_root_directory() const {
1084
0
    return !__root_directory().empty();
1085
0
  }
1086
0
  _LIBCPP_INLINE_VISIBILITY bool has_root_path() const {
1087
0
    return !__root_path_raw().empty();
1088
0
  }
1089
0
  _LIBCPP_INLINE_VISIBILITY bool has_relative_path() const {
1090
0
    return !__relative_path().empty();
1091
0
  }
1092
0
  _LIBCPP_INLINE_VISIBILITY bool has_parent_path() const {
1093
0
    return !__parent_path().empty();
1094
0
  }
1095
0
  _LIBCPP_INLINE_VISIBILITY bool has_filename() const {
1096
0
    return !__filename().empty();
1097
0
  }
1098
0
  _LIBCPP_INLINE_VISIBILITY bool has_stem() const { return !__stem().empty(); }
1099
0
  _LIBCPP_INLINE_VISIBILITY bool has_extension() const {
1100
0
    return !__extension().empty();
1101
0
  }
1102
1103
0
  _LIBCPP_INLINE_VISIBILITY bool is_absolute() const {
1104
0
    return has_root_directory();
1105
0
  }
1106
0
  _LIBCPP_INLINE_VISIBILITY bool is_relative() const { return !is_absolute(); }
1107
1108
  // relative paths
1109
  path lexically_normal() const;
1110
  path lexically_relative(const path& __base) const;
1111
1112
0
  _LIBCPP_INLINE_VISIBILITY path lexically_proximate(const path& __base) const {
1113
0
    path __result = this->lexically_relative(__base);
1114
0
    if (__result.native().empty())
1115
0
      return *this;
1116
0
    return __result;
1117
0
  }
1118
1119
  // iterators
1120
  class _LIBCPP_TYPE_VIS iterator;
1121
  typedef iterator const_iterator;
1122
1123
  iterator begin() const;
1124
  iterator end() const;
1125
1126
  template <class _CharT, class _Traits>
1127
  _LIBCPP_INLINE_VISIBILITY friend
1128
      typename enable_if<is_same<_CharT, char>::value &&
1129
                             is_same<_Traits, char_traits<char> >::value,
1130
                         basic_ostream<_CharT, _Traits>&>::type
1131
      operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
1132
    __os << std::__quoted(__p.native());
1133
    return __os;
1134
  }
1135
1136
  template <class _CharT, class _Traits>
1137
  _LIBCPP_INLINE_VISIBILITY friend
1138
      typename enable_if<!is_same<_CharT, char>::value ||
1139
                             !is_same<_Traits, char_traits<char> >::value,
1140
                         basic_ostream<_CharT, _Traits>&>::type
1141
      operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
1142
    __os << std::__quoted(__p.string<_CharT, _Traits>());
1143
    return __os;
1144
  }
1145
1146
  template <class _CharT, class _Traits>
1147
  _LIBCPP_INLINE_VISIBILITY friend basic_istream<_CharT, _Traits>&
1148
  operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) {
1149
    basic_string<_CharT, _Traits> __tmp;
1150
    __is >> __quoted(__tmp);
1151
    __p = __tmp;
1152
    return __is;
1153
  }
1154
1155
0
  friend _LIBCPP_INLINE_VISIBILITY bool operator==(const path& __lhs, const path& __rhs) noexcept {
1156
0
    return __lhs.compare(__rhs) == 0;
1157
0
  }
1158
0
  friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const path& __lhs, const path& __rhs) noexcept {
1159
0
    return __lhs.compare(__rhs) != 0;
1160
0
  }
1161
0
  friend _LIBCPP_INLINE_VISIBILITY bool operator<(const path& __lhs, const path& __rhs) noexcept {
1162
0
    return __lhs.compare(__rhs) < 0;
1163
0
  }
1164
0
  friend _LIBCPP_INLINE_VISIBILITY bool operator<=(const path& __lhs, const path& __rhs) noexcept {
1165
0
    return __lhs.compare(__rhs) <= 0;
1166
0
  }
1167
0
  friend _LIBCPP_INLINE_VISIBILITY bool operator>(const path& __lhs, const path& __rhs) noexcept {
1168
0
    return __lhs.compare(__rhs) > 0;
1169
0
  }
1170
0
  friend _LIBCPP_INLINE_VISIBILITY bool operator>=(const path& __lhs, const path& __rhs) noexcept {
1171
0
    return __lhs.compare(__rhs) >= 0;
1172
0
  }
1173
1174
  friend _LIBCPP_INLINE_VISIBILITY path operator/(const path& __lhs,
1175
0
                                                  const path& __rhs) {
1176
0
    path __result(__lhs);
1177
0
    __result /= __rhs;
1178
0
    return __result;
1179
0
  }
1180
private:
1181
  inline _LIBCPP_INLINE_VISIBILITY path&
1182
0
  __assign_view(__string_view const& __s) noexcept {
1183
0
    __pn_ = string_type(__s);
1184
0
    return *this;
1185
0
  }
1186
  string_type __pn_;
1187
};
1188
1189
0
inline _LIBCPP_INLINE_VISIBILITY void swap(path& __lhs, path& __rhs) noexcept {
1190
0
  __lhs.swap(__rhs);
1191
0
}
1192
1193
_LIBCPP_FUNC_VIS
1194
size_t hash_value(const path& __p) noexcept;
1195
1196
template <class _Source>
1197
_LIBCPP_INLINE_VISIBILITY
1198
    typename enable_if<__is_pathable<_Source>::value, path>::type
1199
    u8path(const _Source& __s) {
1200
  static_assert(
1201
      is_same<typename __is_pathable<_Source>::__char_type, char>::value,
1202
      "u8path(Source const&) requires Source have a character type of type "
1203
      "'char'");
1204
  return path(__s);
1205
}
1206
1207
template <class _InputIt>
1208
_LIBCPP_INLINE_VISIBILITY
1209
    typename enable_if<__is_pathable<_InputIt>::value, path>::type
1210
    u8path(_InputIt __f, _InputIt __l) {
1211
  static_assert(
1212
      is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
1213
      "u8path(Iter, Iter) requires Iter have a value_type of type 'char'");
1214
  return path(__f, __l);
1215
}
1216
1217
class _LIBCPP_TYPE_VIS path::iterator {
1218
public:
1219
  enum _ParserState : unsigned char {
1220
    _Singular,
1221
    _BeforeBegin,
1222
    _InRootName,
1223
    _InRootDir,
1224
    _InFilenames,
1225
    _InTrailingSep,
1226
    _AtEnd
1227
  };
1228
1229
public:
1230
  typedef bidirectional_iterator_tag iterator_category;
1231
1232
  typedef path value_type;
1233
  typedef std::ptrdiff_t difference_type;
1234
  typedef const path* pointer;
1235
  typedef const path& reference;
1236
1237
  typedef void
1238
      __stashing_iterator_tag; // See reverse_iterator and __is_stashing_iterator
1239
1240
public:
1241
  _LIBCPP_INLINE_VISIBILITY
1242
  iterator()
1243
      : __stashed_elem_(), __path_ptr_(nullptr), __entry_(),
1244
0
        __state_(_Singular) {}
1245
1246
  iterator(const iterator&) = default;
1247
0
  ~iterator() = default;
1248
1249
  iterator& operator=(const iterator&) = default;
1250
1251
  _LIBCPP_INLINE_VISIBILITY
1252
0
  reference operator*() const { return __stashed_elem_; }
1253
1254
  _LIBCPP_INLINE_VISIBILITY
1255
0
  pointer operator->() const { return &__stashed_elem_; }
1256
1257
  _LIBCPP_INLINE_VISIBILITY
1258
0
  iterator& operator++() {
1259
0
    _LIBCPP_ASSERT(__state_ != _Singular,
1260
0
                   "attempting to increment a singular iterator");
1261
0
    _LIBCPP_ASSERT(__state_ != _AtEnd,
1262
0
                   "attempting to increment the end iterator");
1263
0
    return __increment();
1264
0
  }
1265
1266
  _LIBCPP_INLINE_VISIBILITY
1267
0
  iterator operator++(int) {
1268
0
    iterator __it(*this);
1269
0
    this->operator++();
1270
0
    return __it;
1271
0
  }
1272
1273
  _LIBCPP_INLINE_VISIBILITY
1274
0
  iterator& operator--() {
1275
0
    _LIBCPP_ASSERT(__state_ != _Singular,
1276
0
                   "attempting to decrement a singular iterator");
1277
0
    _LIBCPP_ASSERT(__entry_.data() != __path_ptr_->native().data(),
1278
0
                   "attempting to decrement the begin iterator");
1279
0
    return __decrement();
1280
0
  }
1281
1282
  _LIBCPP_INLINE_VISIBILITY
1283
0
  iterator operator--(int) {
1284
0
    iterator __it(*this);
1285
0
    this->operator--();
1286
0
    return __it;
1287
0
  }
1288
1289
private:
1290
  friend class path;
1291
1292
  inline _LIBCPP_INLINE_VISIBILITY friend bool operator==(const iterator&,
1293
                                                          const iterator&);
1294
1295
  iterator& __increment();
1296
  iterator& __decrement();
1297
1298
  path __stashed_elem_;
1299
  const path* __path_ptr_;
1300
  path::__string_view __entry_;
1301
  _ParserState __state_;
1302
};
1303
1304
inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path::iterator& __lhs,
1305
0
                                                 const path::iterator& __rhs) {
1306
0
  return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
1307
0
         __lhs.__entry_.data() == __rhs.__entry_.data();
1308
0
}
1309
1310
inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs,
1311
0
                                                 const path::iterator& __rhs) {
1312
0
  return !(__lhs == __rhs);
1313
0
}
1314
1315
// TODO(ldionne): We need to pop the pragma and push it again after
1316
//                filesystem_error to work around PR41078.
1317
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
1318
1319
class _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
1320
public:
1321
  _LIBCPP_INLINE_VISIBILITY
1322
  filesystem_error(const string& __what, error_code __ec)
1323
      : system_error(__ec, __what),
1324
0
        __storage_(make_shared<_Storage>(path(), path())) {
1325
0
    __create_what(0);
1326
0
  }
1327
1328
  _LIBCPP_INLINE_VISIBILITY
1329
  filesystem_error(const string& __what, const path& __p1, error_code __ec)
1330
      : system_error(__ec, __what),
1331
0
        __storage_(make_shared<_Storage>(__p1, path())) {
1332
0
    __create_what(1);
1333
0
  }
1334
1335
  _LIBCPP_INLINE_VISIBILITY
1336
  filesystem_error(const string& __what, const path& __p1, const path& __p2,
1337
                   error_code __ec)
1338
      : system_error(__ec, __what),
1339
0
        __storage_(make_shared<_Storage>(__p1, __p2)) {
1340
0
    __create_what(2);
1341
0
  }
1342
1343
  _LIBCPP_INLINE_VISIBILITY
1344
0
  const path& path1() const noexcept { return __storage_->__p1_; }
1345
1346
  _LIBCPP_INLINE_VISIBILITY
1347
0
  const path& path2() const noexcept { return __storage_->__p2_; }
1348
1349
  ~filesystem_error() override; // key function
1350
1351
  _LIBCPP_INLINE_VISIBILITY
1352
0
  const char* what() const noexcept override {
1353
0
    return __storage_->__what_.c_str();
1354
0
  }
1355
1356
  void __create_what(int __num_paths);
1357
1358
private:
1359
  struct _LIBCPP_HIDDEN _Storage {
1360
    _LIBCPP_INLINE_VISIBILITY
1361
0
    _Storage(const path& __p1, const path& __p2) : __p1_(__p1), __p2_(__p2) {}
1362
1363
    path __p1_;
1364
    path __p2_;
1365
    string __what_;
1366
  };
1367
  shared_ptr<_Storage> __storage_;
1368
};
1369
1370
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
1371
1372
template <class... _Args>
1373
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
1374
#ifndef _LIBCPP_NO_EXCEPTIONS
1375
0
void __throw_filesystem_error(_Args&&... __args) {
1376
0
  throw filesystem_error(std::forward<_Args>(__args)...);
1377
0
}
Unexecuted instantiation: void std::__1::__fs::filesystem::__throw_filesystem_error<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::error_code const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&&, std::__1::error_code const&&&)
Unexecuted instantiation: void std::__1::__fs::filesystem::__throw_filesystem_error<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::__fs::filesystem::path const&, std::__1::error_code const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&&, std::__1::__fs::filesystem::path const&&&, std::__1::error_code const&&&)
Unexecuted instantiation: void std::__1::__fs::filesystem::__throw_filesystem_error<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, std::__1::__fs::filesystem::path const&, std::__1::__fs::filesystem::path const&, std::__1::error_code const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&&, std::__1::__fs::filesystem::path const&&&, std::__1::__fs::filesystem::path const&&&, std::__1::error_code const&&&)
Unexecuted instantiation: void std::__1::__fs::filesystem::__throw_filesystem_error<char const*&, std::__1::__fs::filesystem::path const&, std::__1::error_code const&>(char const*&&&, std::__1::__fs::filesystem::path const&&&, std::__1::error_code const&&&)
1378
#else
1379
void __throw_filesystem_error(_Args&&...) {
1380
  _VSTD::abort();
1381
}
1382
#endif
1383
1384
// operational functions
1385
1386
_LIBCPP_FUNC_VIS
1387
path __absolute(const path&, error_code* __ec = nullptr);
1388
_LIBCPP_FUNC_VIS
1389
path __canonical(const path&, error_code* __ec = nullptr);
1390
_LIBCPP_FUNC_VIS
1391
void __copy(const path& __from, const path& __to, copy_options __opt,
1392
            error_code* __ec = nullptr);
1393
_LIBCPP_FUNC_VIS
1394
bool __copy_file(const path& __from, const path& __to, copy_options __opt,
1395
                 error_code* __ec = nullptr);
1396
_LIBCPP_FUNC_VIS
1397
void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
1398
                    error_code* __ec = nullptr);
1399
_LIBCPP_FUNC_VIS
1400
bool __create_directories(const path& p, error_code* ec = nullptr);
1401
_LIBCPP_FUNC_VIS
1402
bool __create_directory(const path& p, error_code* ec = nullptr);
1403
_LIBCPP_FUNC_VIS
1404
bool __create_directory(const path& p, const path& attributes,
1405
                        error_code* ec = nullptr);
1406
_LIBCPP_FUNC_VIS
1407
void __create_directory_symlink(const path& __to, const path& __new_symlink,
1408
                                error_code* __ec = nullptr);
1409
_LIBCPP_FUNC_VIS
1410
void __create_hard_link(const path& __to, const path& __new_hard_link,
1411
                        error_code* __ec = nullptr);
1412
_LIBCPP_FUNC_VIS
1413
void __create_symlink(const path& __to, const path& __new_symlink,
1414
                      error_code* __ec = nullptr);
1415
_LIBCPP_FUNC_VIS
1416
path __current_path(error_code* __ec = nullptr);
1417
_LIBCPP_FUNC_VIS
1418
void __current_path(const path&, error_code* __ec = nullptr);
1419
_LIBCPP_FUNC_VIS
1420
bool __equivalent(const path&, const path&, error_code* __ec = nullptr);
1421
_LIBCPP_FUNC_VIS
1422
uintmax_t __file_size(const path&, error_code* __ec = nullptr);
1423
_LIBCPP_FUNC_VIS
1424
uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr);
1425
_LIBCPP_FUNC_VIS
1426
bool __fs_is_empty(const path& p, error_code* ec = nullptr);
1427
_LIBCPP_FUNC_VIS
1428
file_time_type __last_write_time(const path& p, error_code* ec = nullptr);
1429
_LIBCPP_FUNC_VIS
1430
void __last_write_time(const path& p, file_time_type new_time,
1431
                       error_code* ec = nullptr);
1432
_LIBCPP_FUNC_VIS
1433
void __permissions(const path&, perms, perm_options, error_code* = nullptr);
1434
_LIBCPP_FUNC_VIS
1435
path __read_symlink(const path& p, error_code* ec = nullptr);
1436
_LIBCPP_FUNC_VIS
1437
bool __remove(const path& p, error_code* ec = nullptr);
1438
_LIBCPP_FUNC_VIS
1439
uintmax_t __remove_all(const path& p, error_code* ec = nullptr);
1440
_LIBCPP_FUNC_VIS
1441
void __rename(const path& from, const path& to, error_code* ec = nullptr);
1442
_LIBCPP_FUNC_VIS
1443
void __resize_file(const path& p, uintmax_t size, error_code* ec = nullptr);
1444
_LIBCPP_FUNC_VIS
1445
space_info __space(const path&, error_code* __ec = nullptr);
1446
_LIBCPP_FUNC_VIS
1447
file_status __status(const path&, error_code* __ec = nullptr);
1448
_LIBCPP_FUNC_VIS
1449
file_status __symlink_status(const path&, error_code* __ec = nullptr);
1450
_LIBCPP_FUNC_VIS
1451
path __system_complete(const path&, error_code* __ec = nullptr);
1452
_LIBCPP_FUNC_VIS
1453
path __temp_directory_path(error_code* __ec = nullptr);
1454
_LIBCPP_FUNC_VIS
1455
path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
1456
1457
0
inline _LIBCPP_INLINE_VISIBILITY path current_path() {
1458
0
  return __current_path();
1459
0
}
1460
1461
0
inline _LIBCPP_INLINE_VISIBILITY path current_path(error_code& __ec) {
1462
0
  return __current_path(&__ec);
1463
0
}
1464
1465
0
inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p) {
1466
0
  __current_path(__p);
1467
0
}
1468
1469
inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p,
1470
0
                                                   error_code& __ec) noexcept {
1471
0
  __current_path(__p, &__ec);
1472
0
}
1473
1474
0
inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p) {
1475
0
  return __absolute(__p);
1476
0
}
1477
1478
inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p,
1479
0
                                               error_code& __ec) {
1480
0
  return __absolute(__p, &__ec);
1481
0
}
1482
1483
0
inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p) {
1484
0
  return __canonical(__p);
1485
0
}
1486
1487
inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p,
1488
0
                                                error_code& __ec) {
1489
0
  return __canonical(__p, &__ec);
1490
0
}
1491
1492
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from,
1493
0
                                           const path& __to) {
1494
0
  __copy(__from, __to, copy_options::none);
1495
0
}
1496
1497
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
1498
0
                                           error_code& __ec) {
1499
0
  __copy(__from, __to, copy_options::none, &__ec);
1500
0
}
1501
1502
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
1503
0
                                           copy_options __opt) {
1504
0
  __copy(__from, __to, __opt);
1505
0
}
1506
1507
inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
1508
                                           copy_options __opt,
1509
0
                                           error_code& __ec) {
1510
0
  __copy(__from, __to, __opt, &__ec);
1511
0
}
1512
1513
inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
1514
0
                                                const path& __to) {
1515
0
  return __copy_file(__from, __to, copy_options::none);
1516
0
}
1517
1518
inline _LIBCPP_INLINE_VISIBILITY bool
1519
0
copy_file(const path& __from, const path& __to, error_code& __ec) {
1520
0
  return __copy_file(__from, __to, copy_options::none, &__ec);
1521
0
}
1522
1523
inline _LIBCPP_INLINE_VISIBILITY bool
1524
0
copy_file(const path& __from, const path& __to, copy_options __opt) {
1525
0
  return __copy_file(__from, __to, __opt);
1526
0
}
1527
1528
inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
1529
                                                const path& __to,
1530
                                                copy_options __opt,
1531
0
                                                error_code& __ec) {
1532
0
  return __copy_file(__from, __to, __opt, &__ec);
1533
0
}
1534
1535
inline _LIBCPP_INLINE_VISIBILITY void copy_symlink(const path& __existing,
1536
0
                                                   const path& __new) {
1537
0
  __copy_symlink(__existing, __new);
1538
0
}
1539
1540
inline _LIBCPP_INLINE_VISIBILITY void
1541
0
copy_symlink(const path& __ext, const path& __new, error_code& __ec) noexcept {
1542
0
  __copy_symlink(__ext, __new, &__ec);
1543
0
}
1544
1545
0
inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p) {
1546
0
  return __create_directories(__p);
1547
0
}
1548
1549
inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p,
1550
0
                                                         error_code& __ec) {
1551
0
  return __create_directories(__p, &__ec);
1552
0
}
1553
1554
0
inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p) {
1555
0
  return __create_directory(__p);
1556
0
}
1557
1558
inline _LIBCPP_INLINE_VISIBILITY bool
1559
0
create_directory(const path& __p, error_code& __ec) noexcept {
1560
0
  return __create_directory(__p, &__ec);
1561
0
}
1562
1563
inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p,
1564
0
                                                       const path& __attrs) {
1565
0
  return __create_directory(__p, __attrs);
1566
0
}
1567
1568
inline _LIBCPP_INLINE_VISIBILITY bool
1569
create_directory(const path& __p, const path& __attrs,
1570
0
                 error_code& __ec) noexcept {
1571
0
  return __create_directory(__p, __attrs, &__ec);
1572
0
}
1573
1574
inline _LIBCPP_INLINE_VISIBILITY void
1575
0
create_directory_symlink(const path& __to, const path& __new) {
1576
0
  __create_directory_symlink(__to, __new);
1577
0
}
1578
1579
inline _LIBCPP_INLINE_VISIBILITY void
1580
create_directory_symlink(const path& __to, const path& __new,
1581
0
                         error_code& __ec) noexcept {
1582
0
  __create_directory_symlink(__to, __new, &__ec);
1583
0
}
1584
1585
inline _LIBCPP_INLINE_VISIBILITY void create_hard_link(const path& __to,
1586
0
                                                       const path& __new) {
1587
0
  __create_hard_link(__to, __new);
1588
0
}
1589
1590
inline _LIBCPP_INLINE_VISIBILITY void
1591
create_hard_link(const path& __to, const path& __new,
1592
0
                 error_code& __ec) noexcept {
1593
0
  __create_hard_link(__to, __new, &__ec);
1594
0
}
1595
1596
inline _LIBCPP_INLINE_VISIBILITY void create_symlink(const path& __to,
1597
0
                                                     const path& __new) {
1598
0
  __create_symlink(__to, __new);
1599
0
}
1600
1601
inline _LIBCPP_INLINE_VISIBILITY void
1602
0
create_symlink(const path& __to, const path& __new, error_code& __ec) noexcept {
1603
0
  return __create_symlink(__to, __new, &__ec);
1604
0
}
1605
1606
0
inline _LIBCPP_INLINE_VISIBILITY bool status_known(file_status __s) noexcept {
1607
0
  return __s.type() != file_type::none;
1608
0
}
1609
1610
0
inline _LIBCPP_INLINE_VISIBILITY bool exists(file_status __s) noexcept {
1611
0
  return status_known(__s) && __s.type() != file_type::not_found;
1612
0
}
1613
1614
0
inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p) {
1615
0
  return exists(__status(__p));
1616
0
}
1617
1618
inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p,
1619
0
                                             error_code& __ec) noexcept {
1620
0
  auto __s = __status(__p, &__ec);
1621
0
  if (status_known(__s))
1622
0
    __ec.clear();
1623
0
  return exists(__s);
1624
0
}
1625
1626
inline _LIBCPP_INLINE_VISIBILITY bool equivalent(const path& __p1,
1627
0
                                                 const path& __p2) {
1628
0
  return __equivalent(__p1, __p2);
1629
0
}
1630
1631
inline _LIBCPP_INLINE_VISIBILITY bool
1632
0
equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept {
1633
0
  return __equivalent(__p1, __p2, &__ec);
1634
0
}
1635
1636
0
inline _LIBCPP_INLINE_VISIBILITY uintmax_t file_size(const path& __p) {
1637
0
  return __file_size(__p);
1638
0
}
1639
1640
inline _LIBCPP_INLINE_VISIBILITY uintmax_t
1641
0
file_size(const path& __p, error_code& __ec) noexcept {
1642
0
  return __file_size(__p, &__ec);
1643
0
}
1644
1645
0
inline _LIBCPP_INLINE_VISIBILITY uintmax_t hard_link_count(const path& __p) {
1646
0
  return __hard_link_count(__p);
1647
0
}
1648
1649
inline _LIBCPP_INLINE_VISIBILITY uintmax_t
1650
0
hard_link_count(const path& __p, error_code& __ec) noexcept {
1651
0
  return __hard_link_count(__p, &__ec);
1652
0
}
1653
1654
0
inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(file_status __s) noexcept {
1655
0
  return __s.type() == file_type::block;
1656
0
}
1657
1658
0
inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p) {
1659
0
  return is_block_file(__status(__p));
1660
0
}
1661
1662
inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p,
1663
0
                                                    error_code& __ec) noexcept {
1664
0
  return is_block_file(__status(__p, &__ec));
1665
0
}
1666
1667
inline _LIBCPP_INLINE_VISIBILITY bool
1668
0
is_character_file(file_status __s) noexcept {
1669
0
  return __s.type() == file_type::character;
1670
0
}
1671
1672
0
inline _LIBCPP_INLINE_VISIBILITY bool is_character_file(const path& __p) {
1673
0
  return is_character_file(__status(__p));
1674
0
}
1675
1676
inline _LIBCPP_INLINE_VISIBILITY bool
1677
0
is_character_file(const path& __p, error_code& __ec) noexcept {
1678
0
  return is_character_file(__status(__p, &__ec));
1679
0
}
1680
1681
0
inline _LIBCPP_INLINE_VISIBILITY bool is_directory(file_status __s) noexcept {
1682
0
  return __s.type() == file_type::directory;
1683
0
}
1684
1685
0
inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p) {
1686
0
  return is_directory(__status(__p));
1687
0
}
1688
1689
inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p,
1690
0
                                                   error_code& __ec) noexcept {
1691
0
  return is_directory(__status(__p, &__ec));
1692
0
}
1693
1694
0
inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p) {
1695
0
  return __fs_is_empty(__p);
1696
0
}
1697
1698
inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p,
1699
0
                                               error_code& __ec) {
1700
0
  return __fs_is_empty(__p, &__ec);
1701
0
}
1702
1703
0
inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(file_status __s) noexcept {
1704
0
  return __s.type() == file_type::fifo;
1705
0
}
1706
0
inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p) {
1707
0
  return is_fifo(__status(__p));
1708
0
}
1709
1710
inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p,
1711
0
                                              error_code& __ec) noexcept {
1712
0
  return is_fifo(__status(__p, &__ec));
1713
0
}
1714
1715
inline _LIBCPP_INLINE_VISIBILITY bool
1716
0
is_regular_file(file_status __s) noexcept {
1717
0
  return __s.type() == file_type::regular;
1718
0
}
1719
1720
0
inline _LIBCPP_INLINE_VISIBILITY bool is_regular_file(const path& __p) {
1721
0
  return is_regular_file(__status(__p));
1722
0
}
1723
1724
inline _LIBCPP_INLINE_VISIBILITY bool
1725
0
is_regular_file(const path& __p, error_code& __ec) noexcept {
1726
0
  return is_regular_file(__status(__p, &__ec));
1727
0
}
1728
1729
0
inline _LIBCPP_INLINE_VISIBILITY bool is_socket(file_status __s) noexcept {
1730
0
  return __s.type() == file_type::socket;
1731
0
}
1732
1733
0
inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p) {
1734
0
  return is_socket(__status(__p));
1735
0
}
1736
1737
inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p,
1738
0
                                                error_code& __ec) noexcept {
1739
0
  return is_socket(__status(__p, &__ec));
1740
0
}
1741
1742
0
inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(file_status __s) noexcept {
1743
0
  return __s.type() == file_type::symlink;
1744
0
}
1745
1746
0
inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p) {
1747
0
  return is_symlink(__symlink_status(__p));
1748
0
}
1749
1750
inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p,
1751
0
                                                 error_code& __ec) noexcept {
1752
0
  return is_symlink(__symlink_status(__p, &__ec));
1753
0
}
1754
1755
0
inline _LIBCPP_INLINE_VISIBILITY bool is_other(file_status __s) noexcept {
1756
0
  return exists(__s) && !is_regular_file(__s) && !is_directory(__s) &&
1757
0
         !is_symlink(__s);
1758
0
}
1759
1760
0
inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p) {
1761
0
  return is_other(__status(__p));
1762
0
}
1763
1764
inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p,
1765
0
                                               error_code& __ec) noexcept {
1766
0
  return is_other(__status(__p, &__ec));
1767
0
}
1768
1769
inline _LIBCPP_INLINE_VISIBILITY file_time_type
1770
0
last_write_time(const path& __p) {
1771
0
  return __last_write_time(__p);
1772
0
}
1773
1774
inline _LIBCPP_INLINE_VISIBILITY file_time_type
1775
0
last_write_time(const path& __p, error_code& __ec) noexcept {
1776
0
  return __last_write_time(__p, &__ec);
1777
0
}
1778
1779
inline _LIBCPP_INLINE_VISIBILITY void last_write_time(const path& __p,
1780
0
                                                      file_time_type __t) {
1781
0
  __last_write_time(__p, __t);
1782
0
}
1783
1784
inline _LIBCPP_INLINE_VISIBILITY void
1785
last_write_time(const path& __p, file_time_type __t,
1786
0
                error_code& __ec) noexcept {
1787
0
  __last_write_time(__p, __t, &__ec);
1788
0
}
1789
1790
inline _LIBCPP_INLINE_VISIBILITY void
1791
permissions(const path& __p, perms __prms,
1792
0
            perm_options __opts = perm_options::replace) {
1793
0
  __permissions(__p, __prms, __opts);
1794
0
}
1795
1796
inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
1797
0
                                                  error_code& __ec) noexcept {
1798
0
  __permissions(__p, __prms, perm_options::replace, &__ec);
1799
0
}
1800
1801
inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
1802
                                                  perm_options __opts,
1803
0
                                                  error_code& __ec) {
1804
0
  __permissions(__p, __prms, __opts, &__ec);
1805
0
}
1806
1807
inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
1808
                                                const path& __base,
1809
0
                                                error_code& __ec) {
1810
0
  path __tmp = __weakly_canonical(__p, &__ec);
1811
0
  if (__ec)
1812
0
    return {};
1813
0
  path __tmp_base = __weakly_canonical(__base, &__ec);
1814
0
  if (__ec)
1815
0
    return {};
1816
0
  return __tmp.lexically_proximate(__tmp_base);
1817
0
}
1818
1819
inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
1820
0
                                                error_code& __ec) {
1821
0
  return proximate(__p, current_path(), __ec);
1822
0
}
1823
1824
inline _LIBCPP_INLINE_VISIBILITY path
1825
0
proximate(const path& __p, const path& __base = current_path()) {
1826
0
  return __weakly_canonical(__p).lexically_proximate(
1827
0
      __weakly_canonical(__base));
1828
0
}
1829
1830
0
inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p) {
1831
0
  return __read_symlink(__p);
1832
0
}
1833
1834
inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p,
1835
0
                                                   error_code& __ec) {
1836
0
  return __read_symlink(__p, &__ec);
1837
0
}
1838
1839
inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
1840
                                               const path& __base,
1841
0
                                               error_code& __ec) {
1842
0
  path __tmp = __weakly_canonical(__p, &__ec);
1843
0
  if (__ec)
1844
0
    return path();
1845
0
  path __tmpbase = __weakly_canonical(__base, &__ec);
1846
0
  if (__ec)
1847
0
    return path();
1848
0
  return __tmp.lexically_relative(__tmpbase);
1849
0
}
1850
1851
inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
1852
0
                                               error_code& __ec) {
1853
0
  return relative(__p, current_path(), __ec);
1854
0
}
1855
1856
inline _LIBCPP_INLINE_VISIBILITY path
1857
0
relative(const path& __p, const path& __base = current_path()) {
1858
0
  return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base));
1859
0
}
1860
1861
0
inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p) {
1862
0
  return __remove(__p);
1863
0
}
1864
1865
inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p,
1866
0
                                             error_code& __ec) noexcept {
1867
0
  return __remove(__p, &__ec);
1868
0
}
1869
1870
0
inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p) {
1871
0
  return __remove_all(__p);
1872
0
}
1873
1874
inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p,
1875
0
                                                      error_code& __ec) {
1876
0
  return __remove_all(__p, &__ec);
1877
0
}
1878
1879
inline _LIBCPP_INLINE_VISIBILITY void rename(const path& __from,
1880
0
                                             const path& __to) {
1881
0
  return __rename(__from, __to);
1882
0
}
1883
1884
inline _LIBCPP_INLINE_VISIBILITY void
1885
0
rename(const path& __from, const path& __to, error_code& __ec) noexcept {
1886
0
  return __rename(__from, __to, &__ec);
1887
0
}
1888
1889
inline _LIBCPP_INLINE_VISIBILITY void resize_file(const path& __p,
1890
0
                                                  uintmax_t __ns) {
1891
0
  return __resize_file(__p, __ns);
1892
0
}
1893
1894
inline _LIBCPP_INLINE_VISIBILITY void
1895
0
resize_file(const path& __p, uintmax_t __ns, error_code& __ec) noexcept {
1896
0
  return __resize_file(__p, __ns, &__ec);
1897
0
}
1898
1899
0
inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p) {
1900
0
  return __space(__p);
1901
0
}
1902
1903
inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p,
1904
0
                                                  error_code& __ec) noexcept {
1905
0
  return __space(__p, &__ec);
1906
0
}
1907
1908
0
inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p) {
1909
0
  return __status(__p);
1910
0
}
1911
1912
inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p,
1913
0
                                                    error_code& __ec) noexcept {
1914
0
  return __status(__p, &__ec);
1915
0
}
1916
1917
0
inline _LIBCPP_INLINE_VISIBILITY file_status symlink_status(const path& __p) {
1918
0
  return __symlink_status(__p);
1919
0
}
1920
1921
inline _LIBCPP_INLINE_VISIBILITY file_status
1922
0
symlink_status(const path& __p, error_code& __ec) noexcept {
1923
0
  return __symlink_status(__p, &__ec);
1924
0
}
1925
1926
0
inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path() {
1927
0
  return __temp_directory_path();
1928
0
}
1929
1930
0
inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path(error_code& __ec) {
1931
0
  return __temp_directory_path(&__ec);
1932
0
}
1933
1934
0
inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p) {
1935
0
  return __weakly_canonical(__p);
1936
0
}
1937
1938
inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p,
1939
0
                                                       error_code& __ec) {
1940
0
  return __weakly_canonical(__p, &__ec);
1941
0
}
1942
1943
class directory_iterator;
1944
class recursive_directory_iterator;
1945
class _LIBCPP_HIDDEN __dir_stream;
1946
1947
class directory_entry {
1948
  typedef _VSTD_FS::path _Path;
1949
1950
public:
1951
  // constructors and destructors
1952
0
  directory_entry() noexcept = default;
1953
  directory_entry(directory_entry const&) = default;
1954
0
  directory_entry(directory_entry&&) noexcept = default;
1955
1956
  _LIBCPP_INLINE_VISIBILITY
1957
0
  explicit directory_entry(_Path const& __p) : __p_(__p) {
1958
0
    error_code __ec;
1959
0
    __refresh(&__ec);
1960
0
  }
1961
1962
  _LIBCPP_INLINE_VISIBILITY
1963
0
  directory_entry(_Path const& __p, error_code& __ec) : __p_(__p) {
1964
0
    __refresh(&__ec);
1965
0
  }
1966
1967
0
  ~directory_entry() {}
1968
1969
  directory_entry& operator=(directory_entry const&) = default;
1970
  directory_entry& operator=(directory_entry&&) noexcept = default;
1971
1972
  _LIBCPP_INLINE_VISIBILITY
1973
0
  void assign(_Path const& __p) {
1974
0
    __p_ = __p;
1975
0
    error_code __ec;
1976
0
    __refresh(&__ec);
1977
0
  }
1978
1979
  _LIBCPP_INLINE_VISIBILITY
1980
0
  void assign(_Path const& __p, error_code& __ec) {
1981
0
    __p_ = __p;
1982
0
    __refresh(&__ec);
1983
0
  }
1984
1985
  _LIBCPP_INLINE_VISIBILITY
1986
0
  void replace_filename(_Path const& __p) {
1987
0
    __p_.replace_filename(__p);
1988
0
    error_code __ec;
1989
0
    __refresh(&__ec);
1990
0
  }
1991
1992
  _LIBCPP_INLINE_VISIBILITY
1993
0
  void replace_filename(_Path const& __p, error_code& __ec) {
1994
0
    __p_ = __p_.parent_path() / __p;
1995
0
    __refresh(&__ec);
1996
0
  }
1997
1998
  _LIBCPP_INLINE_VISIBILITY
1999
0
  void refresh() { __refresh(); }
2000
2001
  _LIBCPP_INLINE_VISIBILITY
2002
0
  void refresh(error_code& __ec) noexcept { __refresh(&__ec); }
2003
2004
  _LIBCPP_INLINE_VISIBILITY
2005
0
  _Path const& path() const noexcept { return __p_; }
2006
2007
  _LIBCPP_INLINE_VISIBILITY
2008
0
  operator const _Path&() const noexcept { return __p_; }
2009
2010
  _LIBCPP_INLINE_VISIBILITY
2011
0
  bool exists() const { return _VSTD_FS::exists(file_status{__get_ft()}); }
2012
2013
  _LIBCPP_INLINE_VISIBILITY
2014
0
  bool exists(error_code& __ec) const noexcept {
2015
0
    return _VSTD_FS::exists(file_status{__get_ft(&__ec)});
2016
0
  }
2017
2018
  _LIBCPP_INLINE_VISIBILITY
2019
0
  bool is_block_file() const { return __get_ft() == file_type::block; }
2020
2021
  _LIBCPP_INLINE_VISIBILITY
2022
0
  bool is_block_file(error_code& __ec) const noexcept {
2023
0
    return __get_ft(&__ec) == file_type::block;
2024
0
  }
2025
2026
  _LIBCPP_INLINE_VISIBILITY
2027
0
  bool is_character_file() const { return __get_ft() == file_type::character; }
2028
2029
  _LIBCPP_INLINE_VISIBILITY
2030
0
  bool is_character_file(error_code& __ec) const noexcept {
2031
0
    return __get_ft(&__ec) == file_type::character;
2032
0
  }
2033
2034
  _LIBCPP_INLINE_VISIBILITY
2035
0
  bool is_directory() const { return __get_ft() == file_type::directory; }
2036
2037
  _LIBCPP_INLINE_VISIBILITY
2038
0
  bool is_directory(error_code& __ec) const noexcept {
2039
0
    return __get_ft(&__ec) == file_type::directory;
2040
0
  }
2041
2042
  _LIBCPP_INLINE_VISIBILITY
2043
0
  bool is_fifo() const { return __get_ft() == file_type::fifo; }
2044
2045
  _LIBCPP_INLINE_VISIBILITY
2046
0
  bool is_fifo(error_code& __ec) const noexcept {
2047
0
    return __get_ft(&__ec) == file_type::fifo;
2048
0
  }
2049
2050
  _LIBCPP_INLINE_VISIBILITY
2051
0
  bool is_other() const { return _VSTD_FS::is_other(file_status{__get_ft()}); }
2052
2053
  _LIBCPP_INLINE_VISIBILITY
2054
0
  bool is_other(error_code& __ec) const noexcept {
2055
0
    return _VSTD_FS::is_other(file_status{__get_ft(&__ec)});
2056
0
  }
2057
2058
  _LIBCPP_INLINE_VISIBILITY
2059
0
  bool is_regular_file() const { return __get_ft() == file_type::regular; }
2060
2061
  _LIBCPP_INLINE_VISIBILITY
2062
0
  bool is_regular_file(error_code& __ec) const noexcept {
2063
0
    return __get_ft(&__ec) == file_type::regular;
2064
0
  }
2065
2066
  _LIBCPP_INLINE_VISIBILITY
2067
0
  bool is_socket() const { return __get_ft() == file_type::socket; }
2068
2069
  _LIBCPP_INLINE_VISIBILITY
2070
0
  bool is_socket(error_code& __ec) const noexcept {
2071
0
    return __get_ft(&__ec) == file_type::socket;
2072
0
  }
2073
2074
  _LIBCPP_INLINE_VISIBILITY
2075
0
  bool is_symlink() const { return __get_sym_ft() == file_type::symlink; }
2076
2077
  _LIBCPP_INLINE_VISIBILITY
2078
0
  bool is_symlink(error_code& __ec) const noexcept {
2079
0
    return __get_sym_ft(&__ec) == file_type::symlink;
2080
0
  }
2081
  _LIBCPP_INLINE_VISIBILITY
2082
0
  uintmax_t file_size() const { return __get_size(); }
2083
2084
  _LIBCPP_INLINE_VISIBILITY
2085
0
  uintmax_t file_size(error_code& __ec) const noexcept {
2086
0
    return __get_size(&__ec);
2087
0
  }
2088
2089
  _LIBCPP_INLINE_VISIBILITY
2090
0
  uintmax_t hard_link_count() const { return __get_nlink(); }
2091
2092
  _LIBCPP_INLINE_VISIBILITY
2093
0
  uintmax_t hard_link_count(error_code& __ec) const noexcept {
2094
0
    return __get_nlink(&__ec);
2095
0
  }
2096
2097
  _LIBCPP_INLINE_VISIBILITY
2098
0
  file_time_type last_write_time() const { return __get_write_time(); }
2099
2100
  _LIBCPP_INLINE_VISIBILITY
2101
0
  file_time_type last_write_time(error_code& __ec) const noexcept {
2102
0
    return __get_write_time(&__ec);
2103
0
  }
2104
2105
  _LIBCPP_INLINE_VISIBILITY
2106
0
  file_status status() const { return __get_status(); }
2107
2108
  _LIBCPP_INLINE_VISIBILITY
2109
0
  file_status status(error_code& __ec) const noexcept {
2110
0
    return __get_status(&__ec);
2111
0
  }
2112
2113
  _LIBCPP_INLINE_VISIBILITY
2114
0
  file_status symlink_status() const { return __get_symlink_status(); }
2115
2116
  _LIBCPP_INLINE_VISIBILITY
2117
0
  file_status symlink_status(error_code& __ec) const noexcept {
2118
0
    return __get_symlink_status(&__ec);
2119
0
  }
2120
2121
  _LIBCPP_INLINE_VISIBILITY
2122
0
  bool operator<(directory_entry const& __rhs) const noexcept {
2123
0
    return __p_ < __rhs.__p_;
2124
0
  }
2125
2126
  _LIBCPP_INLINE_VISIBILITY
2127
0
  bool operator==(directory_entry const& __rhs) const noexcept {
2128
0
    return __p_ == __rhs.__p_;
2129
0
  }
2130
2131
  _LIBCPP_INLINE_VISIBILITY
2132
0
  bool operator!=(directory_entry const& __rhs) const noexcept {
2133
0
    return __p_ != __rhs.__p_;
2134
0
  }
2135
2136
  _LIBCPP_INLINE_VISIBILITY
2137
0
  bool operator<=(directory_entry const& __rhs) const noexcept {
2138
0
    return __p_ <= __rhs.__p_;
2139
0
  }
2140
2141
  _LIBCPP_INLINE_VISIBILITY
2142
0
  bool operator>(directory_entry const& __rhs) const noexcept {
2143
0
    return __p_ > __rhs.__p_;
2144
0
  }
2145
2146
  _LIBCPP_INLINE_VISIBILITY
2147
0
  bool operator>=(directory_entry const& __rhs) const noexcept {
2148
0
    return __p_ >= __rhs.__p_;
2149
0
  }
2150
2151
private:
2152
  friend class directory_iterator;
2153
  friend class recursive_directory_iterator;
2154
  friend class __dir_stream;
2155
2156
  enum _CacheType : unsigned char {
2157
    _Empty,
2158
    _IterSymlink,
2159
    _IterNonSymlink,
2160
    _RefreshSymlink,
2161
    _RefreshSymlinkUnresolved,
2162
    _RefreshNonSymlink
2163
  };
2164
2165
  struct __cached_data {
2166
    uintmax_t __size_;
2167
    uintmax_t __nlink_;
2168
    file_time_type __write_time_;
2169
    perms __sym_perms_;
2170
    perms __non_sym_perms_;
2171
    file_type __type_;
2172
    _CacheType __cache_type_;
2173
2174
    _LIBCPP_INLINE_VISIBILITY
2175
0
    __cached_data() noexcept { __reset(); }
2176
2177
    _LIBCPP_INLINE_VISIBILITY
2178
0
    void __reset() {
2179
0
      __cache_type_ = _Empty;
2180
0
      __type_ = file_type::none;
2181
0
      __sym_perms_ = __non_sym_perms_ = perms::unknown;
2182
0
      __size_ = __nlink_ = uintmax_t(-1);
2183
0
      __write_time_ = file_time_type::min();
2184
0
    }
2185
  };
2186
2187
  _LIBCPP_INLINE_VISIBILITY
2188
0
  static __cached_data __create_iter_result(file_type __ft) {
2189
0
    __cached_data __data;
2190
0
    __data.__type_ = __ft;
2191
0
    __data.__cache_type_ = [&]() {
2192
0
      switch (__ft) {
2193
0
      case file_type::none:
2194
0
        return _Empty;
2195
0
      case file_type::symlink:
2196
0
        return _IterSymlink;
2197
0
      default:
2198
0
        return _IterNonSymlink;
2199
0
      }
2200
0
    }();
2201
0
    return __data;
2202
0
  }
2203
2204
  _LIBCPP_INLINE_VISIBILITY
2205
0
  void __assign_iter_entry(_Path&& __p, __cached_data __dt) {
2206
0
    __p_ = std::move(__p);
2207
0
    __data_ = __dt;
2208
0
  }
2209
2210
  _LIBCPP_FUNC_VIS
2211
  error_code __do_refresh() noexcept;
2212
2213
  _LIBCPP_INLINE_VISIBILITY
2214
0
  static bool __is_dne_error(error_code const& __ec) {
2215
0
    if (!__ec)
2216
0
      return true;
2217
0
    switch (static_cast<errc>(__ec.value())) {
2218
0
    case errc::no_such_file_or_directory:
2219
0
    case errc::not_a_directory:
2220
0
      return true;
2221
0
    default:
2222
0
      return false;
2223
0
    }
2224
0
  }
2225
2226
  _LIBCPP_INLINE_VISIBILITY
2227
  void __handle_error(const char* __msg, error_code* __dest_ec,
2228
0
                      error_code const& __ec, bool __allow_dne = false) const {
2229
0
    if (__dest_ec) {
2230
0
      *__dest_ec = __ec;
2231
0
      return;
2232
0
    }
2233
0
    if (__ec && (!__allow_dne || !__is_dne_error(__ec)))
2234
0
      __throw_filesystem_error(__msg, __p_, __ec);
2235
0
  }
2236
2237
  _LIBCPP_INLINE_VISIBILITY
2238
0
  void __refresh(error_code* __ec = nullptr) {
2239
0
    __handle_error("in directory_entry::refresh", __ec, __do_refresh(),
2240
0
                   /*allow_dne*/ true);
2241
0
  }
2242
2243
  _LIBCPP_INLINE_VISIBILITY
2244
0
  file_type __get_sym_ft(error_code* __ec = nullptr) const {
2245
0
    switch (__data_.__cache_type_) {
2246
0
    case _Empty:
2247
0
      return __symlink_status(__p_, __ec).type();
2248
0
    case _IterSymlink:
2249
0
    case _RefreshSymlink:
2250
0
    case _RefreshSymlinkUnresolved:
2251
0
      if (__ec)
2252
0
        __ec->clear();
2253
0
      return file_type::symlink;
2254
0
    case _IterNonSymlink:
2255
0
    case _RefreshNonSymlink:
2256
0
      file_status __st(__data_.__type_);
2257
0
      if (__ec && !_VSTD_FS::exists(__st))
2258
0
        *__ec = make_error_code(errc::no_such_file_or_directory);
2259
0
      else if (__ec)
2260
0
        __ec->clear();
2261
0
      return __data_.__type_;
2262
0
    }
2263
0
    _LIBCPP_UNREACHABLE();
2264
0
  }
2265
2266
  _LIBCPP_INLINE_VISIBILITY
2267
0
  file_type __get_ft(error_code* __ec = nullptr) const {
2268
0
    switch (__data_.__cache_type_) {
2269
0
    case _Empty:
2270
0
    case _IterSymlink:
2271
0
    case _RefreshSymlinkUnresolved:
2272
0
      return __status(__p_, __ec).type();
2273
0
    case _IterNonSymlink:
2274
0
    case _RefreshNonSymlink:
2275
0
    case _RefreshSymlink: {
2276
0
      file_status __st(__data_.__type_);
2277
0
      if (__ec && !_VSTD_FS::exists(__st))
2278
0
        *__ec = make_error_code(errc::no_such_file_or_directory);
2279
0
      else if (__ec)
2280
0
        __ec->clear();
2281
0
      return __data_.__type_;
2282
0
    }
2283
0
    }
2284
0
    _LIBCPP_UNREACHABLE();
2285
0
  }
2286
2287
  _LIBCPP_INLINE_VISIBILITY
2288
0
  file_status __get_status(error_code* __ec = nullptr) const {
2289
0
    switch (__data_.__cache_type_) {
2290
0
    case _Empty:
2291
0
    case _IterNonSymlink:
2292
0
    case _IterSymlink:
2293
0
    case _RefreshSymlinkUnresolved:
2294
0
      return __status(__p_, __ec);
2295
0
    case _RefreshNonSymlink:
2296
0
    case _RefreshSymlink:
2297
0
      return file_status(__get_ft(__ec), __data_.__non_sym_perms_);
2298
0
    }
2299
0
    _LIBCPP_UNREACHABLE();
2300
0
  }
2301
2302
  _LIBCPP_INLINE_VISIBILITY
2303
0
  file_status __get_symlink_status(error_code* __ec = nullptr) const {
2304
0
    switch (__data_.__cache_type_) {
2305
0
    case _Empty:
2306
0
    case _IterNonSymlink:
2307
0
    case _IterSymlink:
2308
0
      return __symlink_status(__p_, __ec);
2309
0
    case _RefreshNonSymlink:
2310
0
      return file_status(__get_sym_ft(__ec), __data_.__non_sym_perms_);
2311
0
    case _RefreshSymlink:
2312
0
    case _RefreshSymlinkUnresolved:
2313
0
      return file_status(__get_sym_ft(__ec), __data_.__sym_perms_);
2314
0
    }
2315
0
    _LIBCPP_UNREACHABLE();
2316
0
  }
2317
2318
  _LIBCPP_INLINE_VISIBILITY
2319
0
  uintmax_t __get_size(error_code* __ec = nullptr) const {
2320
0
    switch (__data_.__cache_type_) {
2321
0
    case _Empty:
2322
0
    case _IterNonSymlink:
2323
0
    case _IterSymlink:
2324
0
    case _RefreshSymlinkUnresolved:
2325
0
      return _VSTD_FS::__file_size(__p_, __ec);
2326
0
    case _RefreshSymlink:
2327
0
    case _RefreshNonSymlink: {
2328
0
      error_code __m_ec;
2329
0
      file_status __st(__get_ft(&__m_ec));
2330
0
      __handle_error("in directory_entry::file_size", __ec, __m_ec);
2331
0
      if (_VSTD_FS::exists(__st) && !_VSTD_FS::is_regular_file(__st)) {
2332
0
        errc __err_kind = _VSTD_FS::is_directory(__st) ? errc::is_a_directory
2333
0
                                                       : errc::not_supported;
2334
0
        __handle_error("in directory_entry::file_size", __ec,
2335
0
                       make_error_code(__err_kind));
2336
0
      }
2337
0
      return __data_.__size_;
2338
0
    }
2339
0
    }
2340
0
    _LIBCPP_UNREACHABLE();
2341
0
  }
2342
2343
  _LIBCPP_INLINE_VISIBILITY
2344
0
  uintmax_t __get_nlink(error_code* __ec = nullptr) const {
2345
0
    switch (__data_.__cache_type_) {
2346
0
    case _Empty:
2347
0
    case _IterNonSymlink:
2348
0
    case _IterSymlink:
2349
0
    case _RefreshSymlinkUnresolved:
2350
0
      return _VSTD_FS::__hard_link_count(__p_, __ec);
2351
0
    case _RefreshSymlink:
2352
0
    case _RefreshNonSymlink: {
2353
0
      error_code __m_ec;
2354
0
      (void)__get_ft(&__m_ec);
2355
0
      __handle_error("in directory_entry::hard_link_count", __ec, __m_ec);
2356
0
      return __data_.__nlink_;
2357
0
    }
2358
0
    }
2359
0
    _LIBCPP_UNREACHABLE();
2360
0
  }
2361
2362
  _LIBCPP_INLINE_VISIBILITY
2363
0
  file_time_type __get_write_time(error_code* __ec = nullptr) const {
2364
0
    switch (__data_.__cache_type_) {
2365
0
    case _Empty:
2366
0
    case _IterNonSymlink:
2367
0
    case _IterSymlink:
2368
0
    case _RefreshSymlinkUnresolved:
2369
0
      return _VSTD_FS::__last_write_time(__p_, __ec);
2370
0
    case _RefreshSymlink:
2371
0
    case _RefreshNonSymlink: {
2372
0
      error_code __m_ec;
2373
0
      file_status __st(__get_ft(&__m_ec));
2374
0
      __handle_error("in directory_entry::last_write_time", __ec, __m_ec);
2375
0
      if (_VSTD_FS::exists(__st) &&
2376
0
          __data_.__write_time_ == file_time_type::min())
2377
0
        __handle_error("in directory_entry::last_write_time", __ec,
2378
0
                       make_error_code(errc::value_too_large));
2379
0
      return __data_.__write_time_;
2380
0
    }
2381
0
    }
2382
0
    _LIBCPP_UNREACHABLE();
2383
0
  }
2384
2385
private:
2386
  _Path __p_;
2387
  __cached_data __data_;
2388
};
2389
2390
class __dir_element_proxy {
2391
public:
2392
0
  inline _LIBCPP_INLINE_VISIBILITY directory_entry operator*() {
2393
0
    return _VSTD::move(__elem_);
2394
0
  }
2395
2396
private:
2397
  friend class directory_iterator;
2398
  friend class recursive_directory_iterator;
2399
0
  explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
2400
  __dir_element_proxy(__dir_element_proxy&& __o)
2401
0
      : __elem_(_VSTD::move(__o.__elem_)) {}
2402
  directory_entry __elem_;
2403
};
2404
2405
class directory_iterator {
2406
public:
2407
  typedef directory_entry value_type;
2408
  typedef ptrdiff_t difference_type;
2409
  typedef value_type const* pointer;
2410
  typedef value_type const& reference;
2411
  typedef input_iterator_tag iterator_category;
2412
2413
public:
2414
  //ctor & dtor
2415
0
  directory_iterator() noexcept {}
2416
2417
  explicit directory_iterator(const path& __p)
2418
0
      : directory_iterator(__p, nullptr) {}
Unexecuted instantiation: std::__1::__fs::filesystem::directory_iterator::directory_iterator(std::__1::__fs::filesystem::path const&)
Unexecuted instantiation: std::__1::__fs::filesystem::directory_iterator::directory_iterator(std::__1::__fs::filesystem::path const&)
2419
2420
  directory_iterator(const path& __p, directory_options __opts)
2421
0
      : directory_iterator(__p, nullptr, __opts) {}
2422
2423
  directory_iterator(const path& __p, error_code& __ec)
2424
0
      : directory_iterator(__p, &__ec) {}
Unexecuted instantiation: std::__1::__fs::filesystem::directory_iterator::directory_iterator(std::__1::__fs::filesystem::path const&, std::__1::error_code&)
Unexecuted instantiation: std::__1::__fs::filesystem::directory_iterator::directory_iterator(std::__1::__fs::filesystem::path const&, std::__1::error_code&)
2425
2426
  directory_iterator(const path& __p, directory_options __opts,
2427
                     error_code& __ec)
2428
0
      : directory_iterator(__p, &__ec, __opts) {}
2429
2430
  directory_iterator(const directory_iterator&) = default;
2431
  directory_iterator(directory_iterator&&) = default;
2432
  directory_iterator& operator=(const directory_iterator&) = default;
2433
2434
0
  directory_iterator& operator=(directory_iterator&& __o) noexcept {
2435
0
    // non-default implementation provided to support self-move assign.
2436
0
    if (this != &__o) {
2437
0
      __imp_ = _VSTD::move(__o.__imp_);
2438
0
    }
2439
0
    return *this;
2440
0
  }
2441
2442
0
  ~directory_iterator() = default;
2443
2444
0
  const directory_entry& operator*() const {
2445
0
    _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
2446
0
    return __dereference();
2447
0
  }
2448
2449
0
  const directory_entry* operator->() const { return &**this; }
2450
2451
0
  directory_iterator& operator++() { return __increment(); }
2452
2453
0
  __dir_element_proxy operator++(int) {
2454
0
    __dir_element_proxy __p(**this);
2455
0
    __increment();
2456
0
    return __p;
2457
0
  }
2458
2459
0
  directory_iterator& increment(error_code& __ec) { return __increment(&__ec); }
2460
2461
private:
2462
  inline _LIBCPP_INLINE_VISIBILITY friend bool
2463
  operator==(const directory_iterator& __lhs,
2464
             const directory_iterator& __rhs) noexcept;
2465
2466
  // construct the dir_stream
2467
  _LIBCPP_FUNC_VIS
2468
  directory_iterator(const path&, error_code*,
2469
                     directory_options = directory_options::none);
2470
2471
  _LIBCPP_FUNC_VIS
2472
  directory_iterator& __increment(error_code* __ec = nullptr);
2473
2474
  _LIBCPP_FUNC_VIS
2475
  const directory_entry& __dereference() const;
2476
2477
private:
2478
  shared_ptr<__dir_stream> __imp_;
2479
};
2480
2481
inline _LIBCPP_INLINE_VISIBILITY bool
2482
operator==(const directory_iterator& __lhs,
2483
0
           const directory_iterator& __rhs) noexcept {
2484
0
  return __lhs.__imp_ == __rhs.__imp_;
2485
0
}
2486
2487
inline _LIBCPP_INLINE_VISIBILITY bool
2488
operator!=(const directory_iterator& __lhs,
2489
0
           const directory_iterator& __rhs) noexcept {
2490
0
  return !(__lhs == __rhs);
2491
0
}
2492
2493
// enable directory_iterator range-based for statements
2494
inline _LIBCPP_INLINE_VISIBILITY directory_iterator
2495
0
begin(directory_iterator __iter) noexcept {
2496
0
  return __iter;
2497
0
}
2498
2499
inline _LIBCPP_INLINE_VISIBILITY directory_iterator
2500
0
end(const directory_iterator&) noexcept {
2501
0
  return directory_iterator();
2502
0
}
2503
2504
class recursive_directory_iterator {
2505
public:
2506
  using value_type = directory_entry;
2507
  using difference_type = std::ptrdiff_t;
2508
  using pointer = directory_entry const*;
2509
  using reference = directory_entry const&;
2510
  using iterator_category = std::input_iterator_tag;
2511
2512
public:
2513
  // constructors and destructor
2514
  _LIBCPP_INLINE_VISIBILITY
2515
0
  recursive_directory_iterator() noexcept : __rec_(false) {}
2516
2517
  _LIBCPP_INLINE_VISIBILITY
2518
  explicit recursive_directory_iterator(
2519
      const path& __p, directory_options __xoptions = directory_options::none)
2520
0
      : recursive_directory_iterator(__p, __xoptions, nullptr) {}
2521
2522
  _LIBCPP_INLINE_VISIBILITY
2523
  recursive_directory_iterator(const path& __p, directory_options __xoptions,
2524
                               error_code& __ec)
2525
0
      : recursive_directory_iterator(__p, __xoptions, &__ec) {}
2526
2527
  _LIBCPP_INLINE_VISIBILITY
2528
  recursive_directory_iterator(const path& __p, error_code& __ec)
2529
0
      : recursive_directory_iterator(__p, directory_options::none, &__ec) {}
2530
2531
  recursive_directory_iterator(const recursive_directory_iterator&) = default;
2532
  recursive_directory_iterator(recursive_directory_iterator&&) = default;
2533
2534
  recursive_directory_iterator&
2535
  operator=(const recursive_directory_iterator&) = default;
2536
2537
  _LIBCPP_INLINE_VISIBILITY
2538
  recursive_directory_iterator&
2539
0
  operator=(recursive_directory_iterator&& __o) noexcept {
2540
0
    // non-default implementation provided to support self-move assign.
2541
0
    if (this != &__o) {
2542
0
      __imp_ = _VSTD::move(__o.__imp_);
2543
0
      __rec_ = __o.__rec_;
2544
0
    }
2545
0
    return *this;
2546
0
  }
2547
2548
  ~recursive_directory_iterator() = default;
2549
2550
  _LIBCPP_INLINE_VISIBILITY
2551
0
  const directory_entry& operator*() const { return __dereference(); }
2552
2553
  _LIBCPP_INLINE_VISIBILITY
2554
0
  const directory_entry* operator->() const { return &__dereference(); }
2555
2556
0
  recursive_directory_iterator& operator++() { return __increment(); }
2557
2558
  _LIBCPP_INLINE_VISIBILITY
2559
0
  __dir_element_proxy operator++(int) {
2560
0
    __dir_element_proxy __p(**this);
2561
0
    __increment();
2562
0
    return __p;
2563
0
  }
2564
2565
  _LIBCPP_INLINE_VISIBILITY
2566
0
  recursive_directory_iterator& increment(error_code& __ec) {
2567
0
    return __increment(&__ec);
2568
0
  }
2569
2570
  _LIBCPP_FUNC_VIS directory_options options() const;
2571
  _LIBCPP_FUNC_VIS int depth() const;
2572
2573
  _LIBCPP_INLINE_VISIBILITY
2574
0
  void pop() { __pop(); }
2575
2576
  _LIBCPP_INLINE_VISIBILITY
2577
0
  void pop(error_code& __ec) { __pop(&__ec); }
2578
2579
  _LIBCPP_INLINE_VISIBILITY
2580
0
  bool recursion_pending() const { return __rec_; }
2581
2582
  _LIBCPP_INLINE_VISIBILITY
2583
0
  void disable_recursion_pending() { __rec_ = false; }
2584
2585
private:
2586
  _LIBCPP_FUNC_VIS
2587
  recursive_directory_iterator(const path& __p, directory_options __opt,
2588
                               error_code* __ec);
2589
2590
  _LIBCPP_FUNC_VIS
2591
  const directory_entry& __dereference() const;
2592
2593
  _LIBCPP_FUNC_VIS
2594
  bool __try_recursion(error_code* __ec);
2595
2596
  _LIBCPP_FUNC_VIS
2597
  void __advance(error_code* __ec = nullptr);
2598
2599
  _LIBCPP_FUNC_VIS
2600
  recursive_directory_iterator& __increment(error_code* __ec = nullptr);
2601
2602
  _LIBCPP_FUNC_VIS
2603
  void __pop(error_code* __ec = nullptr);
2604
2605
  inline _LIBCPP_INLINE_VISIBILITY friend bool
2606
  operator==(const recursive_directory_iterator&,
2607
             const recursive_directory_iterator&) noexcept;
2608
2609
  struct _LIBCPP_HIDDEN __shared_imp;
2610
  shared_ptr<__shared_imp> __imp_;
2611
  bool __rec_;
2612
}; // class recursive_directory_iterator
2613
2614
inline _LIBCPP_INLINE_VISIBILITY bool
2615
operator==(const recursive_directory_iterator& __lhs,
2616
0
           const recursive_directory_iterator& __rhs) noexcept {
2617
0
  return __lhs.__imp_ == __rhs.__imp_;
2618
0
}
2619
2620
_LIBCPP_INLINE_VISIBILITY
2621
inline bool operator!=(const recursive_directory_iterator& __lhs,
2622
0
                       const recursive_directory_iterator& __rhs) noexcept {
2623
0
  return !(__lhs == __rhs);
2624
0
}
2625
// enable recursive_directory_iterator range-based for statements
2626
inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
2627
0
begin(recursive_directory_iterator __iter) noexcept {
2628
0
  return __iter;
2629
0
}
2630
2631
inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
2632
0
end(const recursive_directory_iterator&) noexcept {
2633
0
  return recursive_directory_iterator();
2634
0
}
2635
2636
_LIBCPP_AVAILABILITY_FILESYSTEM_POP
2637
2638
_LIBCPP_END_NAMESPACE_FILESYSTEM
2639
2640
#endif // !_LIBCPP_CXX03_LANG
2641
2642
_LIBCPP_POP_MACROS
2643
2644
#endif // _LIBCPP_FILESYSTEM