xref: /openbsd/gnu/llvm/libcxx/include/filesystem (revision 4bdff4be) 
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    template <class Source>
163      path u8path(const Source& source);
164    template <class InputIterator>
165      path u8path(InputIterator first, InputIterator last);
166
167    class filesystem_error;
168
169    class directory_entry {
170    public:
171      directory_entry() noexcept = default;
172      directory_entry(const directory_entry&) = default;
173      directory_entry(directory_entry&&) noexcept = default;
174      explicit directory_entry(const filesystem::path& p);
175      directory_entry(const filesystem::path& p, error_code& ec);
176      ~directory_entry();
177
178      directory_entry& operator=(const directory_entry&) = default;
179      directory_entry& operator=(directory_entry&&) noexcept = default;
180
181      void assign(const filesystem::path& p);
182      void assign(const filesystem::path& p, error_code& ec);
183      void replace_filename(const filesystem::path& p);
184      void replace_filename(const filesystem::path& p, error_code& ec);
185      void refresh();
186      void refresh(error_code& ec) noexcept;
187
188      const filesystem::path& path() const noexcept;
189      operator const filesystem::path&() const noexcept;
190      bool exists() const;
191      bool exists(error_code& ec) const noexcept;
192      bool is_block_file() const;
193      bool is_block_file(error_code& ec) const noexcept;
194      bool is_character_file() const;
195      bool is_character_file(error_code& ec) const noexcept;
196      bool is_directory() const;
197      bool is_directory(error_code& ec) const noexcept;
198      bool is_fifo() const;
199      bool is_fifo(error_code& ec) const noexcept;
200      bool is_other() const;
201      bool is_other(error_code& ec) const noexcept;
202      bool is_regular_file() const;
203      bool is_regular_file(error_code& ec) const noexcept;
204      bool is_socket() const;
205      bool is_socket(error_code& ec) const noexcept;
206      bool is_symlink() const;
207      bool is_symlink(error_code& ec) const noexcept;
208      uintmax_t file_size() const;
209      uintmax_t file_size(error_code& ec) const noexcept;
210      uintmax_t hard_link_count() const;
211      uintmax_t hard_link_count(error_code& ec) const noexcept;
212      file_time_type last_write_time() const;
213      file_time_type last_write_time(error_code& ec) const noexcept;
214      file_status status() const;
215      file_status status(error_code& ec) const noexcept;
216      file_status symlink_status() const;
217      file_status symlink_status(error_code& ec) const noexcept;
218
219      bool operator==(const directory_entry& rhs) const noexcept;
220      bool operator!=(const directory_entry& rhs) const noexcept;             // removed  in C++20
221      bool operator< (const directory_entry& rhs) const noexcept;             // removed  in C++20
222      bool operator<=(const directory_entry& rhs) const noexcept;             // removed  in C++20
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      strong_ordering operator<=>(const directory_entry& rhs) const noexcept; // since C++20
226
227      template<class charT, class traits>
228        friend basic_ostream<charT, traits>&
229          operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);
230
231    private:
232      filesystem::path pathobject;        // exposition only
233      friend class directory_iterator;    // exposition only
234    };
235
236    class directory_iterator;
237
238    // enable directory_iterator range-based for statements
239    directory_iterator begin(directory_iterator iter) noexcept;
240    directory_iterator end(directory_iterator) noexcept;
241
242    class recursive_directory_iterator;
243
244    // enable recursive_directory_iterator range-based for statements
245    recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
246    recursive_directory_iterator end(recursive_directory_iterator) noexcept;
247
248    class file_status;
249
250    struct space_info
251    {
252      uintmax_t capacity;
253      uintmax_t free;
254      uintmax_t available;
255
256      friend bool operator==(const space_info&, const space_info&) = default; // C++20
257    };
258
259    enum class file_type;
260    enum class perms;
261    enum class perm_options;
262    enum class copy_options;
263    enum class directory_options;
264
265    typedef chrono::time_point<trivial-clock>  file_time_type;
266
267    // operational functions
268
269    path absolute(const path& p);
270    path absolute(const path& p, error_code &ec);
271
272    path canonical(const path& p);
273    path canonical(const path& p, error_code& ec);
274
275    void copy(const path& from, const path& to);
276    void copy(const path& from, const path& to, error_code& ec);
277    void copy(const path& from, const path& to, copy_options options);
278    void copy(const path& from, const path& to, copy_options options,
279                   error_code& ec);
280
281    bool copy_file(const path& from, const path& to);
282    bool copy_file(const path& from, const path& to, error_code& ec);
283    bool copy_file(const path& from, const path& to, copy_options option);
284    bool copy_file(const path& from, const path& to, copy_options option,
285                           error_code& ec);
286
287    void copy_symlink(const path& existing_symlink, const path& new_symlink);
288    void copy_symlink(const path& existing_symlink, const path& new_symlink,
289                              error_code& ec) noexcept;
290
291    bool create_directories(const path& p);
292    bool create_directories(const path& p, error_code& ec);
293
294    bool create_directory(const path& p);
295    bool create_directory(const path& p, error_code& ec) noexcept;
296
297    bool create_directory(const path& p, const path& attributes);
298    bool create_directory(const path& p, const path& attributes,
299                                  error_code& ec) noexcept;
300
301    void create_directory_symlink(const path& to, const path& new_symlink);
302    void create_directory_symlink(const path& to, const path& new_symlink,
303                                          error_code& ec) noexcept;
304
305    void create_hard_link(const path& to, const path& new_hard_link);
306    void create_hard_link(const path& to, const path& new_hard_link,
307                                  error_code& ec) noexcept;
308
309    void create_symlink(const path& to, const path& new_symlink);
310    void create_symlink(const path& to, const path& new_symlink,
311                                error_code& ec) noexcept;
312
313    path current_path();
314    path current_path(error_code& ec);
315    void current_path(const path& p);
316    void current_path(const path& p, error_code& ec) noexcept;
317
318    bool exists(file_status s) noexcept;
319    bool exists(const path& p);
320    bool exists(const path& p, error_code& ec) noexcept;
321
322    bool equivalent(const path& p1, const path& p2);
323    bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
324
325    uintmax_t    file_size(const path& p);
326    uintmax_t    file_size(const path& p, error_code& ec) noexcept;
327
328    uintmax_t    hard_link_count(const path& p);
329    uintmax_t    hard_link_count(const path& p, error_code& ec) noexcept;
330
331    bool is_block_file(file_status s) noexcept;
332    bool is_block_file(const path& p);
333    bool is_block_file(const path& p, error_code& ec) noexcept;
334
335    bool is_character_file(file_status s) noexcept;
336    bool is_character_file(const path& p);
337    bool is_character_file(const path& p, error_code& ec) noexcept;
338
339    bool is_directory(file_status s) noexcept;
340    bool is_directory(const path& p);
341    bool is_directory(const path& p, error_code& ec) noexcept;
342
343    bool is_empty(const path& p);
344    bool is_empty(const path& p, error_code& ec) noexcept;
345
346    bool is_fifo(file_status s) noexcept;
347    bool is_fifo(const path& p);
348    bool is_fifo(const path& p, error_code& ec) noexcept;
349
350    bool is_other(file_status s) noexcept;
351    bool is_other(const path& p);
352    bool is_other(const path& p, error_code& ec) noexcept;
353
354    bool is_regular_file(file_status s) noexcept;
355    bool is_regular_file(const path& p);
356    bool is_regular_file(const path& p, error_code& ec) noexcept;
357
358    bool is_socket(file_status s) noexcept;
359    bool is_socket(const path& p);
360    bool is_socket(const path& p, error_code& ec) noexcept;
361
362    bool is_symlink(file_status s) noexcept;
363    bool is_symlink(const path& p);
364    bool is_symlink(const path& p, error_code& ec) noexcept;
365
366    file_time_type  last_write_time(const path& p);
367    file_time_type  last_write_time(const path& p, error_code& ec) noexcept;
368    void last_write_time(const path& p, file_time_type new_time);
369    void last_write_time(const path& p, file_time_type new_time,
370                                 error_code& ec) noexcept;
371
372    void permissions(const path& p, perms prms,
373                     perm_options opts=perm_options::replace);
374    void permissions(const path& p, perms prms, error_code& ec) noexcept;
375    void permissions(const path& p, perms prms, perm_options opts,
376                     error_code& ec);
377
378    path proximate(const path& p, error_code& ec);
379    path proximate(const path& p, const path& base = current_path());
380    path proximate(const path& p, const path& base, error_code &ec);
381
382    path read_symlink(const path& p);
383    path read_symlink(const path& p, error_code& ec);
384
385    path relative(const path& p, error_code& ec);
386    path relative(const path& p, const path& base=current_path());
387    path relative(const path& p, const path& base, error_code& ec);
388
389    bool remove(const path& p);
390    bool remove(const path& p, error_code& ec) noexcept;
391
392    uintmax_t    remove_all(const path& p);
393    uintmax_t    remove_all(const path& p, error_code& ec);
394
395    void rename(const path& from, const path& to);
396    void rename(const path& from, const path& to, error_code& ec) noexcept;
397
398    void resize_file(const path& p, uintmax_t size);
399    void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;
400
401    space_info   space(const path& p);
402    space_info   space(const path& p, error_code& ec) noexcept;
403
404    file_status  status(const path& p);
405    file_status  status(const path& p, error_code& ec) noexcept;
406
407    bool status_known(file_status s) noexcept;
408
409    file_status  symlink_status(const path& p);
410    file_status  symlink_status(const path& p, error_code& ec) noexcept;
411
412    path temp_directory_path();
413    path temp_directory_path(error_code& ec);
414
415    path weakly_canonical(path const& p);
416    path weakly_canonical(path const& p, error_code& ec);
417
418} // namespace std::filesystem
419
420template <>
421inline constexpr bool std::ranges::enable_borrowed_range<std::filesystem::directory_iterator> = true;
422template <>
423inline constexpr bool std::ranges::enable_borrowed_range<std::filesystem::recursive_directory_iterator> = true;
424
425template <>
426inline constexpr bool std::ranges::enable_view<std::filesystem::directory_iterator> = true;
427template <>
428inline constexpr bool std::ranges::enable_view<std::filesystem::recursive_directory_iterator> = true;
429
430*/
431
432#include <__assert> // all public C++ headers provide the assertion handler
433#include <__config>
434#include <__filesystem/copy_options.h>
435#include <__filesystem/directory_entry.h>
436#include <__filesystem/directory_iterator.h>
437#include <__filesystem/directory_options.h>
438#include <__filesystem/file_status.h>
439#include <__filesystem/file_time_type.h>
440#include <__filesystem/file_type.h>
441#include <__filesystem/filesystem_error.h>
442#include <__filesystem/operations.h>
443#include <__filesystem/path.h>
444#include <__filesystem/path_iterator.h>
445#include <__filesystem/perm_options.h>
446#include <__filesystem/perms.h>
447#include <__filesystem/recursive_directory_iterator.h>
448#include <__filesystem/space_info.h>
449#include <__filesystem/u8path.h>
450#include <version>
451
452// standard-mandated includes
453
454// [fs.filesystem.syn]
455#include <compare>
456
457#if defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
458# error "The <filesystem> library is not supported since libc++ has been configured without support for a filesystem."
459#endif
460
461#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
462#  pragma GCC system_header
463#endif
464
465#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
466#  include <concepts>
467#endif
468
469#endif // _LIBCPP_FILESYSTEM
470