llvm-project

1
// -*- C++ -*-
2
//===----------------------------------------------------------------------===//
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

10
#ifndef _LIBCPP_FILESYSTEM
11
#define _LIBCPP_FILESYSTEM
12

13
/*
14
    filesystem synopsis
15

16
    namespace std::filesystem {
17

18
    // `class path` from http://eel.is/c++draft/fs.class.path.general#6
19
    class path {
20
      public:
21
        using value_type  = see below;
22
        using string_type = basic_string<value_type>;
23
        static constexpr value_type preferred_separator = see below;
24

25
        enum format;
26

27
        path() noexcept;
28
        path(const path& p);
29
        path(path&& p) noexcept;
30
        path(string_type&& source, format fmt = auto_format);
31
        template<class Source>
32
          path(const Source& source, format fmt = auto_format);
33
        template<class InputIterator>
34
          path(InputIterator first, InputIterator last, format fmt = auto_format);
35
        template<class Source>
36
          path(const Source& source, const locale& loc, format fmt = auto_format);
37
        template<class InputIterator>
38
          path(InputIterator first, InputIterator last, const locale& loc, format fmt = auto_format);
39
        ~path();
40

41
        path& operator=(const path& p);
42
        path& operator=(path&& p) noexcept;
43
        path& operator=(string_type&& source);
44
        path& assign(string_type&& source);
45
        template<class Source>
46
          path& operator=(const Source& source);
47
        template<class Source>
48
          path& assign(const Source& source);
49
        template<class InputIterator>
50
          path& assign(InputIterator first, InputIterator last);
51

52
        path& operator/=(const path& p);
53
        template<class Source>
54
          path& operator/=(const Source& source);
55
        template<class Source>
56
          path& append(const Source& source);
57
        template<class InputIterator>
58
          path& append(InputIterator first, InputIterator last);
59

60
        path& operator+=(const path& x);
61
        path& operator+=(const string_type& x);
62
        path& operator+=(basic_string_view<value_type> x);
63
        path& operator+=(const value_type* x);
64
        path& operator+=(value_type x);
65
        template<class Source>
66
          path& operator+=(const Source& x);
67
        template<class EcharT>
68
          path& operator+=(EcharT x);
69
        template<class Source>
70
          path& concat(const Source& x);
71
        template<class InputIterator>
72
          path& concat(InputIterator first, InputIterator last);
73

74
        void  clear() noexcept;
75
        path& make_preferred();
76
        path& remove_filename();
77
        path& replace_filename(const path& replacement);
78
        path& replace_extension(const path& replacement = path());
79
        void  swap(path& rhs) noexcept;
80

81
        friend bool operator==(const path& lhs, const path& rhs) noexcept;
82
        friend bool operator!=(const path& lhs, const path& rhs) noexcept;             // removed in C++20
83
        friend bool operator< (const path& lhs, const path& rhs) noexcept;             // removed in C++20
84
        friend bool operator<=(const path& lhs, const path& rhs) noexcept;             // removed in C++20
85
        friend bool operator> (const path& lhs, const path& rhs) noexcept;             // removed in C++20
86
        friend bool operator>=(const path& lhs, const path& rhs) noexcept;             // removed in C++20
87
        friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept; // C++20
88

89
        friend path operator/(const path& lhs, const path& rhs);
90

91
        const string_type& native() const noexcept;
92
        const value_type*  c_str() const noexcept;
93
        operator string_type() const;
94

95
        template<class EcharT, class traits = char_traits<EcharT>,
96
                 class Allocator = allocator<EcharT>>
97
          basic_string<EcharT, traits, Allocator>
98
            string(const Allocator& a = Allocator()) const;
99
        std::string    string() const;
100
        std::wstring   wstring() const;
101
        std::u8string  u8string() const;
102
        std::u16string u16string() const;
103
        std::u32string u32string() const;
104

105
        template<class EcharT, class traits = char_traits<EcharT>,
106
                 class Allocator = allocator<EcharT>>
107
          basic_string<EcharT, traits, Allocator>
108
            generic_string(const Allocator& a = Allocator()) const;
109
        std::string    generic_string() const;
110
        std::wstring   generic_wstring() const;
111
        std::u8string  generic_u8string() const;
112
        std::u16string generic_u16string() const;
113
        std::u32string generic_u32string() const;
114

115
        int compare(const path& p) const noexcept;
116
        int compare(const string_type& s) const;
117
        int compare(basic_string_view<value_type> s) const;
118
        int compare(const value_type* s) const;
119

120
        path root_name() const;
121
        path root_directory() const;
122
        path root_path() const;
123
        path relative_path() const;
124
        path parent_path() const;
125
        path filename() const;
126
        path stem() const;
127
        path extension() const;
128

129
        [[nodiscard]] bool empty() const noexcept;
130
        bool has_root_name() const;
131
        bool has_root_directory() const;
132
        bool has_root_path() const;
133
        bool has_relative_path() const;
134
        bool has_parent_path() const;
135
        bool has_filename() const;
136
        bool has_stem() const;
137
        bool has_extension() const;
138
        bool is_absolute() const;
139
        bool is_relative() const;
140

141
        path lexically_normal() const;
142
        path lexically_relative(const path& base) const;
143
        path lexically_proximate(const path& base) const;
144

145
        class iterator;
146
        using const_iterator = iterator;
147

148
        iterator begin() const;
149
        iterator end() const;
150

151
        template<class charT, class traits>
152
          friend basic_ostream<charT, traits>&
153
            operator<<(basic_ostream<charT, traits>& os, const path& p);
154
        template<class charT, class traits>
155
          friend basic_istream<charT, traits>&
156
            operator>>(basic_istream<charT, traits>& is, path& p);
157
    };
158

159
    void swap(path& lhs, path& rhs) noexcept;
160
    size_t hash_value(const path& p) noexcept;
161

162
    // [fs.path.hash], hash support
163
    template<> struct hash<filesystem::path>;
164

165
    template <class Source>
166
      path u8path(const Source& source);
167
    template <class InputIterator>
168
      path u8path(InputIterator first, InputIterator last);
169

170
    class filesystem_error;
171

172
    class directory_entry {
173
    public:
174
      directory_entry() noexcept = default;
175
      directory_entry(const directory_entry&) = default;
176
      directory_entry(directory_entry&&) noexcept = default;
177
      explicit directory_entry(const filesystem::path& p);
178
      directory_entry(const filesystem::path& p, error_code& ec);
179
      ~directory_entry();
180

181
      directory_entry& operator=(const directory_entry&) = default;
182
      directory_entry& operator=(directory_entry&&) noexcept = default;
183

184
      void assign(const filesystem::path& p);
185
      void assign(const filesystem::path& p, error_code& ec);
186
      void replace_filename(const filesystem::path& p);
187
      void replace_filename(const filesystem::path& p, error_code& ec);
188
      void refresh();
189
      void refresh(error_code& ec) noexcept;
190

191
      const filesystem::path& path() const noexcept;
192
      operator const filesystem::path&() const noexcept;
193
      bool exists() const;
194
      bool exists(error_code& ec) const noexcept;
195
      bool is_block_file() const;
196
      bool is_block_file(error_code& ec) const noexcept;
197
      bool is_character_file() const;
198
      bool is_character_file(error_code& ec) const noexcept;
199
      bool is_directory() const;
200
      bool is_directory(error_code& ec) const noexcept;
201
      bool is_fifo() const;
202
      bool is_fifo(error_code& ec) const noexcept;
203
      bool is_other() const;
204
      bool is_other(error_code& ec) const noexcept;
205
      bool is_regular_file() const;
206
      bool is_regular_file(error_code& ec) const noexcept;
207
      bool is_socket() const;
208
      bool is_socket(error_code& ec) const noexcept;
209
      bool is_symlink() const;
210
      bool is_symlink(error_code& ec) const noexcept;
211
      uintmax_t file_size() const;
212
      uintmax_t file_size(error_code& ec) const noexcept;
213
      uintmax_t hard_link_count() const;
214
      uintmax_t hard_link_count(error_code& ec) const noexcept;
215
      file_time_type last_write_time() const;
216
      file_time_type last_write_time(error_code& ec) const noexcept;
217
      file_status status() const;
218
      file_status status(error_code& ec) const noexcept;
219
      file_status symlink_status() const;
220
      file_status symlink_status(error_code& ec) const noexcept;
221

222
      bool operator==(const directory_entry& rhs) const noexcept;
223
      bool operator!=(const directory_entry& rhs) const noexcept;             // removed  in C++20
224
      bool operator< (const directory_entry& rhs) const noexcept;             // removed  in C++20
225
      bool operator<=(const directory_entry& rhs) const noexcept;             // removed  in C++20
226
      bool operator> (const directory_entry& rhs) const noexcept;             // removed  in C++20
227
      bool operator>=(const directory_entry& rhs) const noexcept;             // removed  in C++20
228
      strong_ordering operator<=>(const directory_entry& rhs) const noexcept; // since C++20
229

230
      template<class charT, class traits>
231
        friend basic_ostream<charT, traits>&
232
          operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);
233

234
    private:
235
      filesystem::path pathobject;        // exposition only
236
      friend class directory_iterator;    // exposition only
237
    };
238

239
  class directory_iterator {
240
  public:
241
    using iterator_category = input_iterator_tag;
242
    using value_type        = directory_entry;
243
    using difference_type   = ptrdiff_t;
244
    using pointer           = const directory_entry*;
245
    using reference         = const directory_entry&;
246

247
    // [fs.dir.itr.members], member functions
248
    directory_iterator() noexcept;
249
    explicit directory_iterator(const path& p);
250
    directory_iterator(const path& p, directory_options options);
251
    directory_iterator(const path& p, error_code& ec);
252
    directory_iterator(const path& p, directory_options options,
253
                       error_code& ec);
254
    directory_iterator(const directory_iterator& rhs);
255
    directory_iterator(directory_iterator&& rhs) noexcept;
256
    ~directory_iterator();
257

258
    directory_iterator& operator=(const directory_iterator& rhs);
259
    directory_iterator& operator=(directory_iterator&& rhs) noexcept;
260

261
    const directory_entry& operator*() const;
262
    const directory_entry* operator->() const;
263
    directory_iterator&    operator++();
264
    directory_iterator&    increment(error_code& ec);
265

266
    bool operator==(default_sentinel_t) const noexcept {          // since C++20
267
      return *this == directory_iterator();
268
    }
269

270
    // other members as required by [input.iterators], input iterators
271
  };
272

273
    // enable directory_iterator range-based for statements
274
    directory_iterator begin(directory_iterator iter) noexcept;
275
    directory_iterator end(directory_iterator) noexcept;
276

277
class recursive_directory_iterator {
278
  public:
279
    using iterator_category = input_iterator_tag;
280
    using value_type        = directory_entry;
281
    using difference_type   = ptrdiff_t;
282
    using pointer           = const directory_entry*;
283
    using reference         = const directory_entry&;
284

285
    // [fs.rec.dir.itr.members], constructors and destructor
286
    recursive_directory_iterator() noexcept;
287
    explicit recursive_directory_iterator(const path& p);
288
    recursive_directory_iterator(const path& p, directory_options options);
289
    recursive_directory_iterator(const path& p, directory_options options,
290
                                 error_code& ec);
291
    recursive_directory_iterator(const path& p, error_code& ec);
292
    recursive_directory_iterator(const recursive_directory_iterator& rhs);
293
    recursive_directory_iterator(recursive_directory_iterator&& rhs) noexcept;
294
    ~recursive_directory_iterator();
295

296
    // [fs.rec.dir.itr.members], observers
297
    directory_options  options() const;
298
    int                depth() const;
299
    bool               recursion_pending() const;
300

301
    const directory_entry& operator*() const;
302
    const directory_entry* operator->() const;
303

304
    // [fs.rec.dir.itr.members], modifiers
305
    recursive_directory_iterator&
306
      operator=(const recursive_directory_iterator& rhs);
307
    recursive_directory_iterator&
308
      operator=(recursive_directory_iterator&& rhs) noexcept;
309

310
    recursive_directory_iterator& operator++();
311
    recursive_directory_iterator& increment(error_code& ec);
312

313
    void pop();
314
    void pop(error_code& ec);
315
    void disable_recursion_pending();
316

317
    bool operator==(default_sentinel_t) const noexcept {          // since C++20
318
      return *this == recursive_directory_iterator();
319
    }
320

321
    // other members as required by [input.iterators], input iterators
322
  };
323

324
    // enable recursive_directory_iterator range-based for statements
325
    recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
326
    recursive_directory_iterator end(recursive_directory_iterator) noexcept;
327

328
  class file_status {
329
  public:
330
    // [fs.file.status.cons], constructors and destructor
331
    file_status() noexcept : file_status(file_type::none) {}
332
    explicit file_status(file_type ft,
333
                         perms prms = perms::unknown) noexcept;
334
    file_status(const file_status&) noexcept = default;
335
    file_status(file_status&&) noexcept = default;
336
    ~file_status();
337

338
    // assignments
339
    file_status& operator=(const file_status&) noexcept = default;
340
    file_status& operator=(file_status&&) noexcept = default;
341

342
    // [fs.file.status.mods], modifiers
343
    void       type(file_type ft) noexcept;
344
    void       permissions(perms prms) noexcept;
345

346
    // [fs.file.status.obs], observers
347
    file_type  type() const noexcept;
348
    perms      permissions() const noexcept;
349

350
    friend bool operator==(const file_status& lhs, const file_status& rhs) noexcept
351
      { return lhs.type() == rhs.type() && lhs.permissions() == rhs.permissions(); } // C++20
352
  };
353

354
    struct space_info
355
    {
356
      uintmax_t capacity;
357
      uintmax_t free;
358
      uintmax_t available;
359

360
      friend bool operator==(const space_info&, const space_info&) = default; // C++20
361
    };
362

363
    enum class file_type;
364
    enum class perms;
365
    enum class perm_options;
366
    enum class copy_options;
367
    enum class directory_options;
368

369
    typedef chrono::time_point<trivial-clock>  file_time_type;
370

371
    // operational functions
372

373
    path absolute(const path& p);
374
    path absolute(const path& p, error_code &ec);
375

376
    path canonical(const path& p);
377
    path canonical(const path& p, error_code& ec);
378

379
    void copy(const path& from, const path& to);
380
    void copy(const path& from, const path& to, error_code& ec);
381
    void copy(const path& from, const path& to, copy_options options);
382
    void copy(const path& from, const path& to, copy_options options,
383
                   error_code& ec);
384

385
    bool copy_file(const path& from, const path& to);
386
    bool copy_file(const path& from, const path& to, error_code& ec);
387
    bool copy_file(const path& from, const path& to, copy_options option);
388
    bool copy_file(const path& from, const path& to, copy_options option,
389
                           error_code& ec);
390

391
    void copy_symlink(const path& existing_symlink, const path& new_symlink);
392
    void copy_symlink(const path& existing_symlink, const path& new_symlink,
393
                              error_code& ec) noexcept;
394

395
    bool create_directories(const path& p);
396
    bool create_directories(const path& p, error_code& ec);
397

398
    bool create_directory(const path& p);
399
    bool create_directory(const path& p, error_code& ec) noexcept;
400

401
    bool create_directory(const path& p, const path& attributes);
402
    bool create_directory(const path& p, const path& attributes,
403
                                  error_code& ec) noexcept;
404

405
    void create_directory_symlink(const path& to, const path& new_symlink);
406
    void create_directory_symlink(const path& to, const path& new_symlink,
407
                                          error_code& ec) noexcept;
408

409
    void create_hard_link(const path& to, const path& new_hard_link);
410
    void create_hard_link(const path& to, const path& new_hard_link,
411
                                  error_code& ec) noexcept;
412

413
    void create_symlink(const path& to, const path& new_symlink);
414
    void create_symlink(const path& to, const path& new_symlink,
415
                                error_code& ec) noexcept;
416

417
    path current_path();
418
    path current_path(error_code& ec);
419
    void current_path(const path& p);
420
    void current_path(const path& p, error_code& ec) noexcept;
421

422
    bool exists(file_status s) noexcept;
423
    bool exists(const path& p);
424
    bool exists(const path& p, error_code& ec) noexcept;
425

426
    bool equivalent(const path& p1, const path& p2);
427
    bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
428

429
    uintmax_t    file_size(const path& p);
430
    uintmax_t    file_size(const path& p, error_code& ec) noexcept;
431

432
    uintmax_t    hard_link_count(const path& p);
433
    uintmax_t    hard_link_count(const path& p, error_code& ec) noexcept;
434

435
    bool is_block_file(file_status s) noexcept;
436
    bool is_block_file(const path& p);
437
    bool is_block_file(const path& p, error_code& ec) noexcept;
438

439
    bool is_character_file(file_status s) noexcept;
440
    bool is_character_file(const path& p);
441
    bool is_character_file(const path& p, error_code& ec) noexcept;
442

443
    bool is_directory(file_status s) noexcept;
444
    bool is_directory(const path& p);
445
    bool is_directory(const path& p, error_code& ec) noexcept;
446

447
    bool is_empty(const path& p);
448
    bool is_empty(const path& p, error_code& ec) noexcept;
449

450
    bool is_fifo(file_status s) noexcept;
451
    bool is_fifo(const path& p);
452
    bool is_fifo(const path& p, error_code& ec) noexcept;
453

454
    bool is_other(file_status s) noexcept;
455
    bool is_other(const path& p);
456
    bool is_other(const path& p, error_code& ec) noexcept;
457

458
    bool is_regular_file(file_status s) noexcept;
459
    bool is_regular_file(const path& p);
460
    bool is_regular_file(const path& p, error_code& ec) noexcept;
461

462
    bool is_socket(file_status s) noexcept;
463
    bool is_socket(const path& p);
464
    bool is_socket(const path& p, error_code& ec) noexcept;
465

466
    bool is_symlink(file_status s) noexcept;
467
    bool is_symlink(const path& p);
468
    bool is_symlink(const path& p, error_code& ec) noexcept;
469

470
    file_time_type  last_write_time(const path& p);
471
    file_time_type  last_write_time(const path& p, error_code& ec) noexcept;
472
    void last_write_time(const path& p, file_time_type new_time);
473
    void last_write_time(const path& p, file_time_type new_time,
474
                                 error_code& ec) noexcept;
475

476
    void permissions(const path& p, perms prms,
477
                     perm_options opts=perm_options::replace);
478
    void permissions(const path& p, perms prms, error_code& ec) noexcept;
479
    void permissions(const path& p, perms prms, perm_options opts,
480
                     error_code& ec);
481

482
    path proximate(const path& p, error_code& ec);
483
    path proximate(const path& p, const path& base = current_path());
484
    path proximate(const path& p, const path& base, error_code &ec);
485

486
    path read_symlink(const path& p);
487
    path read_symlink(const path& p, error_code& ec);
488

489
    path relative(const path& p, error_code& ec);
490
    path relative(const path& p, const path& base=current_path());
491
    path relative(const path& p, const path& base, error_code& ec);
492

493
    bool remove(const path& p);
494
    bool remove(const path& p, error_code& ec) noexcept;
495

496
    uintmax_t    remove_all(const path& p);
497
    uintmax_t    remove_all(const path& p, error_code& ec);
498

499
    void rename(const path& from, const path& to);
500
    void rename(const path& from, const path& to, error_code& ec) noexcept;
501

502
    void resize_file(const path& p, uintmax_t size);
503
    void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;
504

505
    space_info   space(const path& p);
506
    space_info   space(const path& p, error_code& ec) noexcept;
507

508
    file_status  status(const path& p);
509
    file_status  status(const path& p, error_code& ec) noexcept;
510

511
    bool status_known(file_status s) noexcept;
512

513
    file_status  symlink_status(const path& p);
514
    file_status  symlink_status(const path& p, error_code& ec) noexcept;
515

516
    path temp_directory_path();
517
    path temp_directory_path(error_code& ec);
518

519
    path weakly_canonical(path const& p);
520
    path weakly_canonical(path const& p, error_code& ec);
521

522
} // namespace std::filesystem
523

524
template <>
525
inline constexpr bool std::ranges::enable_borrowed_range<std::filesystem::directory_iterator> = true;
526
template <>
527
inline constexpr bool std::ranges::enable_borrowed_range<std::filesystem::recursive_directory_iterator> = true;
528

529
template <>
530
inline constexpr bool std::ranges::enable_view<std::filesystem::directory_iterator> = true;
531
template <>
532
inline constexpr bool std::ranges::enable_view<std::filesystem::recursive_directory_iterator> = true;
533

534
*/
535

536
#include <__config>
537
#include <__filesystem/copy_options.h>
538
#include <__filesystem/directory_entry.h>
539
#include <__filesystem/directory_iterator.h>
540
#include <__filesystem/directory_options.h>
541
#include <__filesystem/file_status.h>
542
#include <__filesystem/file_time_type.h>
543
#include <__filesystem/file_type.h>
544
#include <__filesystem/filesystem_error.h>
545
#include <__filesystem/operations.h>
546
#include <__filesystem/path.h>
547
#include <__filesystem/path_iterator.h>
548
#include <__filesystem/perm_options.h>
549
#include <__filesystem/perms.h>
550
#include <__filesystem/recursive_directory_iterator.h>
551
#include <__filesystem/space_info.h>
552
#include <__filesystem/u8path.h>
553
#include <version>
554

555
// standard-mandated includes
556

557
// [fs.filesystem.syn]
558
#include <compare>
559

560
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
561
#  pragma GCC system_header
562
#endif
563

564
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
565
#  include <concepts>
566
#  include <cstdlib>
567
#  include <cstring>
568
#  include <iosfwd>
569
#  include <new>
570
#  include <system_error>
571
#endif
572

573
#endif // _LIBCPP_FILESYSTEM
574