1 // Filesystem declarations -*- C++ -*-
2
3 // Copyright (C) 2014-2023 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24
25 /** @file experimental/bits/fs_fwd.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{experimental/filesystem}
28 */
29
30 #ifndef _GLIBCXX_EXPERIMENTAL_FS_FWD_H
31 #define _GLIBCXX_EXPERIMENTAL_FS_FWD_H 1
32
33 #if __cplusplus < 201103L
34 # include <bits/c++0x_warning.h>
35 #else
36
37 #include <system_error>
38 #include <cstdint>
39 #include <bits/chrono.h>
40
41 namespace std _GLIBCXX_VISIBILITY(default)
42 {
43 _GLIBCXX_BEGIN_NAMESPACE_VERSION
44
45 namespace experimental
46 {
47 namespace filesystem
48 {
49 inline namespace v1
50 {
51 #if _GLIBCXX_USE_CXX11_ABI
52 inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
53 #endif
54
55 /**
56 * @defgroup filesystem-ts Filesystem TS
57 * @ingroup experimental
58 *
59 * Utilities for performing operations on file systems and their components,
60 * such as paths, regular files, and directories.
61 *
62 * ISO/IEC TS 18822:2015 C++ File System Technical Specification
63 *
64 * @since C++11
65 *
66 * @remark Link using `-lstdc++fs` to use these types and functions.
67 *
68 * @{
69 */
70
71 class file_status;
72 _GLIBCXX_BEGIN_NAMESPACE_CXX11
73 class path;
74 class filesystem_error;
75 class directory_entry;
76 class directory_iterator;
77 class recursive_directory_iterator;
78 _GLIBCXX_END_NAMESPACE_CXX11
79
80 /// Information about free space on a disk
81 struct space_info
82 {
83 uintmax_t capacity;
84 uintmax_t free;
85 uintmax_t available;
86 };
87
88 /// Enumerated type representing the type of a file
89 enum class file_type : signed char {
90 none = 0, not_found = -1, regular = 1, directory = 2, symlink = 3,
91 block = 4, character = 5, fifo = 6, socket = 7, unknown = 8
92 };
93
94 /// Bitmask type controlling effects of `filesystem::copy`
95 enum class copy_options : unsigned short {
96 none = 0,
97 skip_existing = 1, overwrite_existing = 2, update_existing = 4,
98 recursive = 8,
99 copy_symlinks = 16, skip_symlinks = 32,
100 directories_only = 64, create_symlinks = 128, create_hard_links = 256
101 };
102
103 /// @{
104 /// @relates copy_options
105 constexpr copy_options
106 operator&(copy_options __x, copy_options __y) noexcept
107 {
108 using __utype = typename std::underlying_type<copy_options>::type;
109 return static_cast<copy_options>(
110 static_cast<__utype>(__x) & static_cast<__utype>(__y));
111 }
112
113 constexpr copy_options
114 operator|(copy_options __x, copy_options __y) noexcept
115 {
116 using __utype = typename std::underlying_type<copy_options>::type;
117 return static_cast<copy_options>(
118 static_cast<__utype>(__x) | static_cast<__utype>(__y));
119 }
120
121 constexpr copy_options
122 operator^(copy_options __x, copy_options __y) noexcept
123 {
124 using __utype = typename std::underlying_type<copy_options>::type;
125 return static_cast<copy_options>(
126 static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
127 }
128
129 constexpr copy_options
130 operator~(copy_options __x) noexcept
131 {
132 using __utype = typename std::underlying_type<copy_options>::type;
133 return static_cast<copy_options>(~static_cast<__utype>(__x));
134 }
135
136 inline copy_options&
137 operator&=(copy_options& __x, copy_options __y) noexcept
138 { return __x = __x & __y; }
139
140 inline copy_options&
141 operator|=(copy_options& __x, copy_options __y) noexcept
142 { return __x = __x | __y; }
143
144 inline copy_options&
145 operator^=(copy_options& __x, copy_options __y) noexcept
146 { return __x = __x ^ __y; }
147 /// @}
148
149 /// Bitmask type representing file access permissions
150 enum class perms : unsigned {
151 none = 0,
152 owner_read = 0400,
153 owner_write = 0200,
154 owner_exec = 0100,
155 owner_all = 0700,
156 group_read = 040,
157 group_write = 020,
158 group_exec = 010,
159 group_all = 070,
160 others_read = 04,
161 others_write = 02,
162 others_exec = 01,
163 others_all = 07,
164 all = 0777,
165 set_uid = 04000,
166 set_gid = 02000,
167 sticky_bit = 01000,
168 mask = 07777,
169 unknown = 0xFFFF,
170 add_perms = 0x10000,
171 remove_perms = 0x20000,
172 symlink_nofollow = 0x40000
173 };
174
175 /// @{
176 /// @relates std::experimental::filesystem::perms
177 constexpr perms
178 operator&(perms __x, perms __y) noexcept
179 {
180 using __utype = typename std::underlying_type<perms>::type;
181 return static_cast<perms>(
182 static_cast<__utype>(__x) & static_cast<__utype>(__y));
183 }
184
185 constexpr perms
186 operator|(perms __x, perms __y) noexcept
187 {
188 using __utype = typename std::underlying_type<perms>::type;
189 return static_cast<perms>(
190 static_cast<__utype>(__x) | static_cast<__utype>(__y));
191 }
192
193 constexpr perms
194 operator^(perms __x, perms __y) noexcept
195 {
196 using __utype = typename std::underlying_type<perms>::type;
197 return static_cast<perms>(
198 static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
199 }
200
201 constexpr perms
202 operator~(perms __x) noexcept
203 {
204 using __utype = typename std::underlying_type<perms>::type;
205 return static_cast<perms>(~static_cast<__utype>(__x));
206 }
207
208 inline perms&
209 operator&=(perms& __x, perms __y) noexcept
210 { return __x = __x & __y; }
211
212 inline perms&
213 operator|=(perms& __x, perms __y) noexcept
214 { return __x = __x | __y; }
215
216 inline perms&
217 operator^=(perms& __x, perms __y) noexcept
218 { return __x = __x ^ __y; }
219 /// @}
220
221 /// Bitmask type controlling directory iteration
222 enum class directory_options : unsigned char {
223 none = 0, follow_directory_symlink = 1, skip_permission_denied = 2
224 };
225
226 /// @{
227 /// @relates directory_options
228 constexpr directory_options
229 operator&(directory_options __x, directory_options __y) noexcept
230 {
231 using __utype = typename std::underlying_type<directory_options>::type;
232 return static_cast<directory_options>(
233 static_cast<__utype>(__x) & static_cast<__utype>(__y));
234 }
235
236 constexpr directory_options
237 operator|(directory_options __x, directory_options __y) noexcept
238 {
239 using __utype = typename std::underlying_type<directory_options>::type;
240 return static_cast<directory_options>(
241 static_cast<__utype>(__x) | static_cast<__utype>(__y));
242 }
243
244 constexpr directory_options
245 operator^(directory_options __x, directory_options __y) noexcept
246 {
247 using __utype = typename std::underlying_type<directory_options>::type;
248 return static_cast<directory_options>(
249 static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
250 }
251
252 constexpr directory_options
253 operator~(directory_options __x) noexcept
254 {
255 using __utype = typename std::underlying_type<directory_options>::type;
256 return static_cast<directory_options>(~static_cast<__utype>(__x));
257 }
258
259 inline directory_options&
260 operator&=(directory_options& __x, directory_options __y) noexcept
261 { return __x = __x & __y; }
262
263 inline directory_options&
264 operator|=(directory_options& __x, directory_options __y) noexcept
265 { return __x = __x | __y; }
266
267 inline directory_options&
268 operator^=(directory_options& __x, directory_options __y) noexcept
269 { return __x = __x ^ __y; }
270 /// @}
271
272 /// The type used for file timestamps
273 using file_time_type = std::chrono::system_clock::time_point;
274
275 // operational functions
276
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&) noexcept;
280
281 bool copy_file(const path& __from, const path& __to, copy_options __option);
282 bool copy_file(const path& __from, const path& __to, copy_options __option,
283 error_code&);
284
285 path current_path();
286
287 file_status status(const path&);
288 file_status status(const path&, error_code&) noexcept;
289
290 bool status_known(file_status) noexcept;
291
292 file_status symlink_status(const path&);
293 file_status symlink_status(const path&, error_code&) noexcept;
294
295 bool is_regular_file(file_status) noexcept;
296 bool is_symlink(file_status) noexcept;
297
298 /// @} group filesystem-ts
299 } // namespace v1
300 } // namespace filesystem
301 } // namespace experimental
302
303 _GLIBCXX_END_NAMESPACE_VERSION
304 } // namespace std
305
306 #endif // C++11
307
308 #endif // _GLIBCXX_EXPERIMENTAL_FS_FWD_H