[thirdparty/gcc.git] / libstdc++-v3 / include / bits / fs_fwd.h

// Filesystem declarations -*- C++ -*-

// Copyright (C) 2014-2019 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file include/bits/fs_fwd.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{filesystem}
 */

#ifndef _GLIBCXX_FS_FWD_H
#define _GLIBCXX_FS_FWD_H 1

#if __cplusplus >= 201703L

#include <system_error>
#include <cstdint>
#include <chrono>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

namespace filesystem
{
#if _GLIBCXX_USE_CXX11_ABI
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
#endif

  /**
   * @defgroup filesystem Filesystem
   *
   * Utilities for performing operations on file systems and their components,
   * such as paths, regular files, and directories.
   *
   * @{
   */

  class file_status;
_GLIBCXX_BEGIN_NAMESPACE_CXX11
  class path;
  class filesystem_error;
  class directory_entry;
  class directory_iterator;
  class recursive_directory_iterator;
_GLIBCXX_END_NAMESPACE_CXX11

  struct space_info
  {
    uintmax_t capacity;
    uintmax_t free;
    uintmax_t available;
  };

  enum class file_type : signed char {
      none = 0, not_found = -1, regular = 1, directory = 2, symlink = 3,
      block = 4, character = 5, fifo = 6, socket = 7, unknown = 8
  };

  /// Bitmask type
  enum class copy_options : unsigned short {
      none = 0,
      skip_existing = 1, overwrite_existing = 2, update_existing = 4,
      recursive = 8,
      copy_symlinks = 16, skip_symlinks = 32,
      directories_only = 64, create_symlinks = 128, create_hard_links = 256
  };

  constexpr copy_options
  operator&(copy_options __x, copy_options __y) noexcept
  {
    using __utype = typename std::underlying_type<copy_options>::type;
    return static_cast<copy_options>(
	static_cast<__utype>(__x) & static_cast<__utype>(__y));
  }

  constexpr copy_options
  operator|(copy_options __x, copy_options __y) noexcept
  {
    using __utype = typename std::underlying_type<copy_options>::type;
    return static_cast<copy_options>(
	static_cast<__utype>(__x) | static_cast<__utype>(__y));
  }

  constexpr copy_options
  operator^(copy_options __x, copy_options __y) noexcept
  {
    using __utype = typename std::underlying_type<copy_options>::type;
    return static_cast<copy_options>(
	static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
  }

  constexpr copy_options
  operator~(copy_options __x) noexcept
  {
    using __utype = typename std::underlying_type<copy_options>::type;
    return static_cast<copy_options>(~static_cast<__utype>(__x));
  }

  inline copy_options&
  operator&=(copy_options& __x, copy_options __y) noexcept
  { return __x = __x & __y; }

  inline copy_options&
  operator|=(copy_options& __x, copy_options __y) noexcept
  { return __x = __x | __y; }

  inline copy_options&
  operator^=(copy_options& __x, copy_options __y) noexcept
  { return __x = __x ^ __y; }


  /// Bitmask type
  enum class perms : unsigned {
      none		=  0,
      owner_read	=  0400,
      owner_write	=  0200,
      owner_exec	=  0100,
      owner_all		=  0700,
      group_read	=   040,
      group_write	=   020,
      group_exec	=   010,
      group_all		=   070,
      others_read	=    04,
      others_write	=    02,
      others_exec	=    01,
      others_all	=    07,
      all		=  0777,
      set_uid		= 04000,
      set_gid		= 02000,
      sticky_bit	= 01000,
      mask		= 07777,
      unknown		=  0xFFFF,
  };

  constexpr perms
  operator&(perms __x, perms __y) noexcept
  {
    using __utype = typename std::underlying_type<perms>::type;
    return static_cast<perms>(
	static_cast<__utype>(__x) & static_cast<__utype>(__y));
  }

  constexpr perms
  operator|(perms __x, perms __y) noexcept
  {
    using __utype = typename std::underlying_type<perms>::type;
    return static_cast<perms>(
	static_cast<__utype>(__x) | static_cast<__utype>(__y));
  }

  constexpr perms
  operator^(perms __x, perms __y) noexcept
  {
    using __utype = typename std::underlying_type<perms>::type;
    return static_cast<perms>(
	static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
  }

  constexpr perms
  operator~(perms __x) noexcept
  {
    using __utype = typename std::underlying_type<perms>::type;
    return static_cast<perms>(~static_cast<__utype>(__x));
  }

  inline perms&
  operator&=(perms& __x, perms __y) noexcept
  { return __x = __x & __y; }

  inline perms&
  operator|=(perms& __x, perms __y) noexcept
  { return __x = __x | __y; }

  inline perms&
  operator^=(perms& __x, perms __y) noexcept
  { return __x = __x ^ __y; }

  /// Bitmask type
  enum class perm_options : unsigned {
      replace	= 0x1,
      add	= 0x2,
      remove	= 0x4,
      nofollow	= 0x8
  };

  constexpr perm_options
  operator&(perm_options __x, perm_options __y) noexcept
  {
    using __utype = typename std::underlying_type<perm_options>::type;
    return static_cast<perm_options>(
	static_cast<__utype>(__x) & static_cast<__utype>(__y));
  }

  constexpr perm_options
  operator|(perm_options __x, perm_options __y) noexcept
  {
    using __utype = typename std::underlying_type<perm_options>::type;
    return static_cast<perm_options>(
	static_cast<__utype>(__x) | static_cast<__utype>(__y));
  }

  constexpr perm_options
  operator^(perm_options __x, perm_options __y) noexcept
  {
    using __utype = typename std::underlying_type<perm_options>::type;
    return static_cast<perm_options>(
	static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
  }

  constexpr perm_options
  operator~(perm_options __x) noexcept
  {
    using __utype = typename std::underlying_type<perm_options>::type;
    return static_cast<perm_options>(~static_cast<__utype>(__x));
  }

  inline perm_options&
  operator&=(perm_options& __x, perm_options __y) noexcept
  { return __x = __x & __y; }

  inline perm_options&
  operator|=(perm_options& __x, perm_options __y) noexcept
  { return __x = __x | __y; }

  inline perm_options&
  operator^=(perm_options& __x, perm_options __y) noexcept
  { return __x = __x ^ __y; }

  // Bitmask type
  enum class directory_options : unsigned char {
      none = 0, follow_directory_symlink = 1, skip_permission_denied = 2
  };

  constexpr directory_options
  operator&(directory_options __x, directory_options __y) noexcept
  {
    using __utype = typename std::underlying_type<directory_options>::type;
    return static_cast<directory_options>(
	static_cast<__utype>(__x) & static_cast<__utype>(__y));
  }

  constexpr directory_options
  operator|(directory_options __x, directory_options __y) noexcept
  {
    using __utype = typename std::underlying_type<directory_options>::type;
    return static_cast<directory_options>(
	static_cast<__utype>(__x) | static_cast<__utype>(__y));
  }

  constexpr directory_options
  operator^(directory_options __x, directory_options __y) noexcept
  {
    using __utype = typename std::underlying_type<directory_options>::type;
    return static_cast<directory_options>(
	static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
  }

  constexpr directory_options
  operator~(directory_options __x) noexcept
  {
    using __utype = typename std::underlying_type<directory_options>::type;
    return static_cast<directory_options>(~static_cast<__utype>(__x));
  }

  inline directory_options&
  operator&=(directory_options& __x, directory_options __y) noexcept
  { return __x = __x & __y; }

  inline directory_options&
  operator|=(directory_options& __x, directory_options __y) noexcept
  { return __x = __x | __y; }

  inline directory_options&
  operator^=(directory_options& __x, directory_options __y) noexcept
  { return __x = __x ^ __y; }

  using file_time_type = std::chrono::system_clock::time_point;

  // operational functions

  void copy(const path& __from, const path& __to, copy_options __options);
  void copy(const path& __from, const path& __to, copy_options __options,
	    error_code&);

  bool copy_file(const path& __from, const path& __to, copy_options __option);
  bool copy_file(const path& __from, const path& __to, copy_options __option,
		 error_code&);

  path current_path();

  bool exists(file_status) noexcept;

  bool is_other(file_status) noexcept;

  uintmax_t file_size(const path&);
  uintmax_t file_size(const path&, error_code&) noexcept;
  uintmax_t hard_link_count(const path&);
  uintmax_t hard_link_count(const path&, error_code&) noexcept;
  file_time_type last_write_time(const path&);
  file_time_type last_write_time(const path&, error_code&) noexcept;

  void permissions(const path&, perms, perm_options, error_code&) noexcept;

  path proximate(const path& __p, const path& __base, error_code& __ec);
  path proximate(const path& __p, const path& __base, error_code& __ec);

  path relative(const path& __p, const path& __base, error_code& __ec);

  file_status status(const path&);
  file_status status(const path&, error_code&) noexcept;

  bool status_known(file_status) noexcept;

  file_status symlink_status(const path&);
  file_status symlink_status(const path&, error_code&) noexcept;

  bool is_regular_file(file_status) noexcept;
  bool is_symlink(file_status) noexcept;

  // @} group filesystem
} // namespace filesystem

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++17

#endif // _GLIBCXX_FS_FWD_H
Commit	Line	Data
641cb5a6 JW	1	// Filesystem declarations -- C++ --
641cb5a6 JW	2
a5544970	3	// Copyright (C) 2014-2019 Free Software Foundation, Inc.
641cb5a6 JW	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 include/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{filesystem}
	28	*/
	29
	30	#ifndef _GLIBCXX_FS_FWD_H
	31	#define _GLIBCXX_FS_FWD_H 1
	32
	33	#if __cplusplus >= 201703L
	34
	35	#include <system_error>
	36	#include <cstdint>
	37	#include <chrono>
	38
	39	namespace std _GLIBCXX_VISIBILITY(default)
	40	{
	41	_GLIBCXX_BEGIN_NAMESPACE_VERSION
	42
	43	namespace filesystem
	44	{
	45	#if _GLIBCXX_USE_CXX11_ABI
	46	inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
	47	#endif
	48
	49	/**
	50	* @defgroup filesystem Filesystem
	51	*
	52	* Utilities for performing operations on file systems and their components,
	53	* such as paths, regular files, and directories.
	54	*
	55	* @{
	56	*/
	57
	58	class file_status;
	59	_GLIBCXX_BEGIN_NAMESPACE_CXX11
	60	class path;
	61	class filesystem_error;
	62	class directory_entry;
	63	class directory_iterator;
	64	class recursive_directory_iterator;
	65	_GLIBCXX_END_NAMESPACE_CXX11
	66
	67	struct space_info
68	{
69	uintmax_t capacity;
70	uintmax_t free;
71	uintmax_t available;
72	};
73
74	enum class file_type : signed char {
75	none = 0, not_found = -1, regular = 1, directory = 2, symlink = 3,
76	block = 4, character = 5, fifo = 6, socket = 7, unknown = 8
77	};
78
79	/// Bitmask type
80	enum class copy_options : unsigned short {
81	none = 0,
82	skip_existing = 1, overwrite_existing = 2, update_existing = 4,
83	recursive = 8,
84	copy_symlinks = 16, skip_symlinks = 32,
85	directories_only = 64, create_symlinks = 128, create_hard_links = 256
86	};
87
88	constexpr copy_options
89	operator&(copy_options __x, copy_options __y) noexcept
90	{
91	using __utype = typename std::underlying_type<copy_options>::type;
92	return static_cast<copy_options>(
93	static_cast<__utype>(__x) & static_cast<__utype>(__y));
94	}
95
96	constexpr copy_options
97	operator\|(copy_options __x, copy_options __y) noexcept
98	{
99	using __utype = typename std::underlying_type<copy_options>::type;
100	return static_cast<copy_options>(
101	static_cast<__utype>(__x) \| static_cast<__utype>(__y));
102	}
103
104	constexpr copy_options
105	operator^(copy_options __x, copy_options __y) noexcept
106	{
107	using __utype = typename std::underlying_type<copy_options>::type;
108	return static_cast<copy_options>(
109	static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
110	}
111
112	constexpr copy_options
113	operator~(copy_options __x) noexcept
114	{
115	using __utype = typename std::underlying_type<copy_options>::type;
116	return static_cast<copy_options>(~static_cast<__utype>(__x));
117	}
118
119	inline copy_options&
120	operator&=(copy_options& __x, copy_options __y) noexcept
121	{ return __x = __x & __y; }
122
123	inline copy_options&
124	operator\|=(copy_options& __x, copy_options __y) noexcept
125	{ return __x = __x \| __y; }
126
127	inline copy_options&
128	operator^=(copy_options& __x, copy_options __y) noexcept
129	{ return __x = __x ^ __y; }
130
131
132	/// Bitmask type
133	enum class perms : unsigned {
134	none = 0,
135	owner_read = 0400,
136	owner_write = 0200,
137	owner_exec = 0100,
138	owner_all = 0700,
139	group_read = 040,
140	group_write = 020,
141	group_exec = 010,
142	group_all = 070,
143	others_read = 04,
144	others_write = 02,
145	others_exec = 01,
146	others_all = 07,
147	all = 0777,
148	set_uid = 04000,
149	set_gid = 02000,
150	sticky_bit = 01000,
151	mask = 07777,
152	unknown = 0xFFFF,
153	};
154
155	constexpr perms
156	operator&(perms __x, perms __y) noexcept
157	{
158	using __utype = typename std::underlying_type<perms>::type;
159	return static_cast<perms>(
160	static_cast<__utype>(__x) & static_cast<__utype>(__y));
161	}
162
163	constexpr perms
164	operator\|(perms __x, perms __y) noexcept
165	{
166	using __utype = typename std::underlying_type<perms>::type;
167	return static_cast<perms>(
168	static_cast<__utype>(__x) \| static_cast<__utype>(__y));
169	}
170
171	constexpr perms
172	operator^(perms __x, perms __y) noexcept
173	{
174	using __utype = typename std::underlying_type<perms>::type;
175	return static_cast<perms>(
176	static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
177	}
178
179	constexpr perms
180	operator~(perms __x) noexcept
181	{
182	using __utype = typename std::underlying_type<perms>::type;
183	return static_cast<perms>(~static_cast<__utype>(__x));
184	}
185
186	inline perms&
187	operator&=(perms& __x, perms __y) noexcept
188	{ return __x = __x & __y; }
189
190	inline perms&
191	operator\|=(perms& __x, perms __y) noexcept
192	{ return __x = __x \| __y; }
193
194	inline perms&
195	operator^=(perms& __x, perms __y) noexcept
196	{ return __x = __x ^ __y; }
197
198	/// Bitmask type
199	enum class perm_options : unsigned {
200	replace = 0x1,
201	add = 0x2,
202	remove = 0x4,
203	nofollow = 0x8
204	};
205
206	constexpr perm_options
207	operator&(perm_options __x, perm_options __y) noexcept
208	{
209	using __utype = typename std::underlying_type<perm_options>::type;
210	return static_cast<perm_options>(
211	static_cast<__utype>(__x) & static_cast<__utype>(__y));
212	}
213
214	constexpr perm_options
215	operator\|(perm_options __x, perm_options __y) noexcept
216	{
217	using __utype = typename std::underlying_type<perm_options>::type;
218	return static_cast<perm_options>(
219	static_cast<__utype>(__x) \| static_cast<__utype>(__y));
220	}
221
222	constexpr perm_options
223	operator^(perm_options __x, perm_options __y) noexcept
224	{
225	using __utype = typename std::underlying_type<perm_options>::type;
226	return static_cast<perm_options>(
227	static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
228	}
229
230	constexpr perm_options
231	operator~(perm_options __x) noexcept
232	{
233	using __utype = typename std::underlying_type<perm_options>::type;
234	return static_cast<perm_options>(~static_cast<__utype>(__x));
235	}
236
237	inline perm_options&
238	operator&=(perm_options& __x, perm_options __y) noexcept
239	{ return __x = __x & __y; }
240
241	inline perm_options&
242	operator\|=(perm_options& __x, perm_options __y) noexcept
243	{ return __x = __x \| __y; }
244
245	inline perm_options&
246	operator^=(perm_options& __x, perm_options __y) noexcept
247	{ return __x = __x ^ __y; }
248
249	// Bitmask type
250	enum class directory_options : unsigned char {
251	none = 0, follow_directory_symlink = 1, skip_permission_denied = 2
252	};
253
254	constexpr directory_options
255	operator&(directory_options __x, directory_options __y) noexcept
256	{
257	using __utype = typename std::underlying_type<directory_options>::type;
258	return static_cast<directory_options>(
259	static_cast<__utype>(__x) & static_cast<__utype>(__y));
260	}
261
262	constexpr directory_options
263	operator\|(directory_options __x, directory_options __y) noexcept
264	{
265	using __utype = typename std::underlying_type<directory_options>::type;
266	return static_cast<directory_options>(
267	static_cast<__utype>(__x) \| static_cast<__utype>(__y));
268	}
269
270	constexpr directory_options
271	operator^(directory_options __x, directory_options __y) noexcept
272	{
273	using __utype = typename std::underlying_type<directory_options>::type;
274	return static_cast<directory_options>(
275	static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
276	}
277
278	constexpr directory_options
279	operator~(directory_options __x) noexcept
280	{
281	using __utype = typename std::underlying_type<directory_options>::type;
282	return static_cast<directory_options>(~static_cast<__utype>(__x));
283	}
284
285	inline directory_options&
286	operator&=(directory_options& __x, directory_options __y) noexcept
287	{ return __x = __x & __y; }
288
289	inline directory_options&
290	operator\|=(directory_options& __x, directory_options __y) noexcept
291	{ return __x = __x \| __y; }
292
293	inline directory_options&
294	operator^=(directory_options& __x, directory_options __y) noexcept
295	{ return __x = __x ^ __y; }
296
297	using file_time_type = std::chrono::system_clock::time_point;
298
299	// operational functions
300
301	void copy(const path& __from, const path& __to, copy_options __options);
302	void copy(const path& __from, const path& __to, copy_options __options,
0382bcfc	303	error_code&);
641cb5a6 JW	304
	305	bool copy_file(const path& __from, const path& __to, copy_options __option);
	306	bool copy_file(const path& __from, const path& __to, copy_options __option,
0382bcfc	307	error_code&);
641cb5a6 JW	308
	309	path current_path();
	310
	311	bool exists(file_status) noexcept;
	312
	313	bool is_other(file_status) noexcept;
	314
	315	uintmax_t file_size(const path&);
	316	uintmax_t file_size(const path&, error_code&) noexcept;
	317	uintmax_t hard_link_count(const path&);
	318	uintmax_t hard_link_count(const path&, error_code&) noexcept;
	319	file_time_type last_write_time(const path&);
	320	file_time_type last_write_time(const path&, error_code&) noexcept;
	321
0382bcfc	322	void permissions(const path&, perms, perm_options, error_code&) noexcept;
641cb5a6 JW	323
	324	path proximate(const path& __p, const path& __base, error_code& __ec);
	325	path proximate(const path& __p, const path& __base, error_code& __ec);
	326
	327	path relative(const path& __p, const path& __base, error_code& __ec);
	328
	329	file_status status(const path&);
	330	file_status status(const path&, error_code&) noexcept;
	331
	332	bool status_known(file_status) noexcept;
	333
	334	file_status symlink_status(const path&);
	335	file_status symlink_status(const path&, error_code&) noexcept;
	336
	337	bool is_regular_file(file_status) noexcept;
	338	bool is_symlink(file_status) noexcept;
	339
	340	// @} group filesystem
	341	} // namespace filesystem
	342
	343	_GLIBCXX_END_NAMESPACE_VERSION
	344	} // namespace std
	345
	346	#endif // C++17
	347
	348	#endif // _GLIBCXX_FS_FWD_H