libstdc++
bits/fs_path.h
Go to the documentation of this file.
1 // Class filesystem::path -*- 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 include/bits/fs_path.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_PATH_H
31 #define _GLIBCXX_FS_PATH_H 1
32 
33 #if __cplusplus >= 201703L
34 
35 #include <type_traits>
36 #include <locale>
37 #include <iosfwd>
38 #include <iomanip>
39 #include <codecvt>
40 #include <string_view>
41 #include <system_error>
42 #include <bits/stl_algobase.h>
43 #include <bits/stl_pair.h>
44 #include <bits/locale_conv.h>
45 #include <ext/concurrence.h>
46 #include <bits/shared_ptr.h>
47 #include <bits/unique_ptr.h>
48 
49 #if __cplusplus > 201703L
50 # include <compare>
51 #endif
52 
53 #if defined(_WIN32) && !defined(__CYGWIN__)
54 # define _GLIBCXX_FILESYSTEM_IS_WINDOWS 1
55 #endif
56 
57 namespace std _GLIBCXX_VISIBILITY(default)
58 {
59 _GLIBCXX_BEGIN_NAMESPACE_VERSION
60 
61 namespace filesystem
62 {
63 _GLIBCXX_BEGIN_NAMESPACE_CXX11
64 
65  class path;
66 
67  /// @cond undocumented
68 namespace __detail
69 {
70  /// @addtogroup filesystem
71  /// @{
72  template<typename _CharT>
73  inline constexpr bool __is_encoded_char = false;
74  template<>
75  inline constexpr bool __is_encoded_char<char> = true;
76 #ifdef _GLIBCXX_USE_CHAR8_T
77  template<>
78  inline constexpr bool __is_encoded_char<char8_t> = true;
79 #endif
80 #if _GLIBCXX_USE_WCHAR_T
81  template<>
82  inline constexpr bool __is_encoded_char<wchar_t> = true;
83 #endif
84  template<>
85  inline constexpr bool __is_encoded_char<char16_t> = true;
86  template<>
87  inline constexpr bool __is_encoded_char<char32_t> = true;
88 
89 #if __cpp_concepts >= 201907L
90  template<typename _Iter>
91  using __safe_iterator_traits = std::iterator_traits<_Iter>;
92 #else
93  template<typename _Iter>
94  struct __safe_iterator_traits : std::iterator_traits<_Iter>
95  { };
96 
97  // Protect against ill-formed iterator_traits specializations in C++17
98  template<> struct __safe_iterator_traits<void*> { };
99  template<> struct __safe_iterator_traits<const void*> { };
100  template<> struct __safe_iterator_traits<volatile void*> { };
101  template<> struct __safe_iterator_traits<const volatile void*> { };
102 #endif
103 
104  template<typename _Iter_traits, typename = void>
105  inline constexpr bool __is_path_iter_src = false;
106 
107  template<typename _Iter_traits>
108  inline constexpr bool
109  __is_path_iter_src<_Iter_traits, void_t<typename _Iter_traits::value_type>>
110  = __is_encoded_char<typename _Iter_traits::value_type>;
111 
112  template<typename _Source>
113  inline constexpr bool __is_path_src
114  = __is_path_iter_src<iterator_traits<decay_t<_Source>>>;
115 
116  template<>
117  inline constexpr bool __is_path_src<path> = false;
118 
119  template<>
120  inline constexpr bool __is_path_src<volatile path> = false;
121 
122  template<>
123  inline constexpr bool __is_path_src<void*> = false;
124 
125  template<>
126  inline constexpr bool __is_path_src<const void*> = false;
127 
128  template<>
129  inline constexpr bool __is_path_src<volatile void*> = false;
130 
131  template<>
132  inline constexpr bool __is_path_src<const volatile void*> = false;
133 
134  template<typename _CharT, typename _Traits, typename _Alloc>
135  inline constexpr bool
136  __is_path_src<basic_string<_CharT, _Traits, _Alloc>>
137  = __is_encoded_char<_CharT>;
138 
139  template<typename _CharT, typename _Traits>
140  inline constexpr bool
141  __is_path_src<basic_string_view<_CharT, _Traits>>
142  = __is_encoded_char<_CharT>;
143 
144  // SFINAE constraint for Source parameters as required by [fs.path.req].
145  template<typename _Tp>
146  using _Path = enable_if_t<__is_path_src<_Tp>, path>;
147 
148  // SFINAE constraint for InputIterator parameters as required by [fs.req].
149  template<typename _Iter, typename _Tr = __safe_iterator_traits<_Iter>>
150  using _Path2 = enable_if_t<__is_path_iter_src<_Tr>, path>;
151 
152 #if __cpp_lib_concepts
153  template<typename _Iter>
154  constexpr bool __is_contiguous = std::contiguous_iterator<_Iter>;
155 #else
156  template<typename _Iter>
157  constexpr bool __is_contiguous = false;
158 #endif
159 
160  template<typename _Tp>
161  constexpr bool __is_contiguous<_Tp*> = true;
162 
163  template<typename _Tp, typename _Seq>
164  constexpr bool
165  __is_contiguous<__gnu_cxx::__normal_iterator<_Tp*, _Seq>> = true;
166 
167 #if !defined _GLIBCXX_FILESYSTEM_IS_WINDOWS && defined _GLIBCXX_USE_CHAR8_T
168  // For POSIX treat char8_t sequences as char without encoding conversions.
169  template<typename _EcharT>
170  using __unified_u8_t
171  = __conditional_t<is_same_v<_EcharT, char8_t>, char, _EcharT>;
172 #else
173  template<typename _EcharT>
174  using __unified_u8_t = _EcharT;
175 #endif
176 
177  // The __effective_range overloads convert a Source parameter into
178  // either a basic_string_view<C> or basic_string<C> containing the
179  // effective range of the Source, as defined in [fs.path.req].
180 
181  template<typename _CharT, typename _Traits, typename _Alloc>
182  inline basic_string_view<_CharT>
183  __effective_range(const basic_string<_CharT, _Traits, _Alloc>& __source)
184  noexcept
185  { return __source; }
186 
187  template<typename _CharT, typename _Traits>
188  inline basic_string_view<_CharT>
189  __effective_range(const basic_string_view<_CharT, _Traits>& __source)
190  noexcept
191  { return __source; }
192 
193  // Return the effective range of an NTCTS.
194  template<typename _Source>
195  auto
196  __effective_range(const _Source& __source)
197  {
198  // Remove a level of normal/safe iterator indirection, or decay an array.
199  using _Iter = decltype(std::__niter_base(__source));
200  using value_type = typename iterator_traits<_Iter>::value_type;
201 
202  if constexpr (__is_contiguous<_Iter>)
203  return basic_string_view<value_type>{&*__source};
204  else
205  {
206  // _Source is an input iterator that iterates over an NTCTS.
207  // Create a basic_string by reading until the null character.
208  basic_string<__unified_u8_t<value_type>> __str;
209  _Source __it = __source;
210  for (value_type __ch = *__it; __ch != value_type(); __ch = *++__it)
211  __str.push_back(__ch);
212  return __str;
213  }
214  }
215 
216  // The value type of a Source parameter's effective range.
217  template<typename _Source>
218  struct __source_value_type_impl
219  {
220  using type
221  = typename __safe_iterator_traits<decay_t<_Source>>::value_type;
222  };
223 
224  template<typename _CharT, typename _Traits, typename _Alloc>
225  struct __source_value_type_impl<basic_string<_CharT, _Traits, _Alloc>>
226  {
227  using type = _CharT;
228  };
229 
230  template<typename _CharT, typename _Traits>
231  struct __source_value_type_impl<basic_string_view<_CharT, _Traits>>
232  {
233  using type = _CharT;
234  };
235 
236  // The value type of a Source parameter's effective range.
237  template<typename _Source>
238  using __source_value_t = typename __source_value_type_impl<_Source>::type;
239 
240  // SFINAE helper to check that an effective range has value_type char,
241  // as required by path constructors taking a std::locale parameter.
242  // The type _Tp must have already been checked by _Path<Tp> or _Path2<_Tp>.
243  template<typename _Tp, typename _Val = __source_value_t<_Tp>>
244  using __value_type_is_char
246 
247  // As above, but also allows char8_t, as required by u8path
248  // C++20 [depr.fs.path.factory]
249  template<typename _Tp, typename _Val = __source_value_t<_Tp>>
250  using __value_type_is_char_or_char8_t
252 #ifdef _GLIBCXX_USE_CHAR8_T
253  || std::is_same_v<_Val, char8_t>
254 #endif
255  , _Val>;
256 
257  // Create a basic_string<C> or basic_string_view<C> from an iterator range.
258  template<typename _InputIterator>
259  inline auto
260  __string_from_range(_InputIterator __first, _InputIterator __last)
261  {
262  using _EcharT
264  static_assert(__is_encoded_char<_EcharT>); // C++17 [fs.req]/3
265 
266  if constexpr (__is_contiguous<_InputIterator>)
267  {
268  // For contiguous iterators we can just return a string view.
269  if (auto __len = __last - __first) [[__likely__]]
270  return basic_string_view<_EcharT>(&*__first, __len);
271  return basic_string_view<_EcharT>();
272  }
273  else
274  {
275  // Conversion requires contiguous characters, so create a string.
276  return basic_string<__unified_u8_t<_EcharT>>(__first, __last);
277  }
278  }
279 
280  /// @} group filesystem
281 } // namespace __detail
282  /// @endcond
283 
284  /// @addtogroup filesystem
285  /// @{
286 
287  /// A filesystem path
288  /**
289  * @ingroup filesystem
290  * @headerfile filesystem
291  * @since C++17
292  */
293  class path
294  {
295  public:
296 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
297  using value_type = wchar_t;
298  static constexpr value_type preferred_separator = L'\\';
299 #else
300 # ifdef _GLIBCXX_DOXYGEN
301  /// Windows uses wchar_t for path::value_type, POSIX uses char.
302  using value_type = __os_dependent__;
303 # else
304  using value_type = char;
305 # endif
306  static constexpr value_type preferred_separator = '/';
307 #endif
309 
310  /// path::format is ignored in this implementation
311  enum format : unsigned char { native_format, generic_format, auto_format };
312 
313  // constructors and destructor
314 
315  path() noexcept { }
316 
317  path(const path& __p) = default;
318 
319  path(path&& __p) noexcept
320  : _M_pathname(std::move(__p._M_pathname)),
321  _M_cmpts(std::move(__p._M_cmpts))
322  { __p.clear(); }
323 
324  path(string_type&& __source, format = auto_format)
325  : _M_pathname(std::move(__source))
326  { _M_split_cmpts(); }
327 
328  template<typename _Source,
329  typename _Require = __detail::_Path<_Source>>
330  path(_Source const& __source, format = auto_format)
331  : _M_pathname(_S_convert(__detail::__effective_range(__source)))
332  { _M_split_cmpts(); }
333 
334  template<typename _InputIterator,
335  typename _Require = __detail::_Path2<_InputIterator>>
336  path(_InputIterator __first, _InputIterator __last, format = auto_format)
337  : _M_pathname(_S_convert(__detail::__string_from_range(__first, __last)))
338  { _M_split_cmpts(); }
339 
340  template<typename _Source,
341  typename _Require = __detail::_Path<_Source>,
342  typename _Require2 = __detail::__value_type_is_char<_Source>>
343  path(_Source const& __src, const locale& __loc, format = auto_format)
344  : _M_pathname(_S_convert_loc(__detail::__effective_range(__src), __loc))
345  { _M_split_cmpts(); }
346 
347  template<typename _InputIterator,
348  typename _Require = __detail::_Path2<_InputIterator>,
349  typename _Req2 = __detail::__value_type_is_char<_InputIterator>>
350  path(_InputIterator __first, _InputIterator __last, const locale& __loc,
351  format = auto_format)
352  : _M_pathname(_S_convert_loc(__first, __last, __loc))
353  { _M_split_cmpts(); }
354 
355  ~path() = default;
356 
357  // assignments
358 
359  path& operator=(const path&);
360  path& operator=(path&&) noexcept;
361  path& operator=(string_type&& __source);
362  path& assign(string_type&& __source);
363 
364  template<typename _Source>
365  __detail::_Path<_Source>&
366  operator=(_Source const& __source)
367  { return *this = path(__source); }
368 
369  template<typename _Source>
370  __detail::_Path<_Source>&
371  assign(_Source const& __source)
372  { return *this = path(__source); }
373 
374  template<typename _InputIterator>
375  __detail::_Path2<_InputIterator>&
376  assign(_InputIterator __first, _InputIterator __last)
377  { return *this = path(__first, __last); }
378 
379  // appends
380 
381  path& operator/=(const path& __p);
382 
383  template<typename _Source>
384  __detail::_Path<_Source>&
385  operator/=(_Source const& __source)
386  {
387  _M_append(_S_convert(__detail::__effective_range(__source)));
388  return *this;
389  }
390 
391  template<typename _Source>
392  __detail::_Path<_Source>&
393  append(_Source const& __source)
394  {
395  _M_append(_S_convert(__detail::__effective_range(__source)));
396  return *this;
397  }
398 
399  template<typename _InputIterator>
400  __detail::_Path2<_InputIterator>&
401  append(_InputIterator __first, _InputIterator __last)
402  {
403  _M_append(_S_convert(__detail::__string_from_range(__first, __last)));
404  return *this;
405  }
406 
407  // concatenation
408 
409  path& operator+=(const path& __x);
410  path& operator+=(const string_type& __x);
411  path& operator+=(const value_type* __x);
412  path& operator+=(value_type __x);
413  path& operator+=(basic_string_view<value_type> __x);
414 
415  template<typename _Source>
416  __detail::_Path<_Source>&
417  operator+=(_Source const& __x) { return concat(__x); }
418 
419  template<typename _CharT>
420  __detail::_Path2<_CharT*>&
421  operator+=(_CharT __x);
422 
423  template<typename _Source>
424  __detail::_Path<_Source>&
425  concat(_Source const& __x)
426  {
427  _M_concat(_S_convert(__detail::__effective_range(__x)));
428  return *this;
429  }
430 
431  template<typename _InputIterator>
432  __detail::_Path2<_InputIterator>&
433  concat(_InputIterator __first, _InputIterator __last)
434  {
435  _M_concat(_S_convert(__detail::__string_from_range(__first, __last)));
436  return *this;
437  }
438 
439  // modifiers
440 
441  void clear() noexcept { _M_pathname.clear(); _M_split_cmpts(); }
442 
443  path& make_preferred();
444  path& remove_filename();
445  path& replace_filename(const path& __replacement);
446  path& replace_extension(const path& __replacement = path());
447 
448  void swap(path& __rhs) noexcept;
449 
450  // native format observers
451 
452  const string_type& native() const noexcept { return _M_pathname; }
453  const value_type* c_str() const noexcept { return _M_pathname.c_str(); }
454  operator string_type() const { return _M_pathname; }
455 
456  template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
457  typename _Allocator = std::allocator<_CharT>>
459  string(const _Allocator& __a = _Allocator()) const;
460 
461  std::string string() const;
462 #if _GLIBCXX_USE_WCHAR_T
463  std::wstring wstring() const;
464 #endif
465 #ifdef _GLIBCXX_USE_CHAR8_T
466  __attribute__((__abi_tag__("__u8")))
467  std::u8string u8string() const;
468 #else
469  std::string u8string() const;
470 #endif // _GLIBCXX_USE_CHAR8_T
471  std::u16string u16string() const;
472  std::u32string u32string() const;
473 
474  // generic format observers
475  template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
476  typename _Allocator = std::allocator<_CharT>>
478  generic_string(const _Allocator& __a = _Allocator()) const;
479 
480  std::string generic_string() const;
481 #if _GLIBCXX_USE_WCHAR_T
482  std::wstring generic_wstring() const;
483 #endif
484 #ifdef _GLIBCXX_USE_CHAR8_T
485  __attribute__((__abi_tag__("__u8")))
486  std::u8string generic_u8string() const;
487 #else
488  std::string generic_u8string() const;
489 #endif // _GLIBCXX_USE_CHAR8_T
490  std::u16string generic_u16string() const;
491  std::u32string generic_u32string() const;
492 
493  // compare
494 
495  int compare(const path& __p) const noexcept;
496  int compare(const string_type& __s) const noexcept;
497  int compare(const value_type* __s) const noexcept;
498  int compare(basic_string_view<value_type> __s) const noexcept;
499 
500  // decomposition
501 
502  path root_name() const;
503  path root_directory() const;
504  path root_path() const;
505  path relative_path() const;
506  path parent_path() const;
507  path filename() const;
508  path stem() const;
509  path extension() const;
510 
511  // query
512 
513  [[nodiscard]] bool empty() const noexcept { return _M_pathname.empty(); }
514  bool has_root_name() const noexcept;
515  bool has_root_directory() const noexcept;
516  bool has_root_path() const noexcept;
517  bool has_relative_path() const noexcept;
518  bool has_parent_path() const noexcept;
519  bool has_filename() const noexcept;
520  bool has_stem() const noexcept;
521  bool has_extension() const noexcept;
522  bool is_absolute() const noexcept;
523  bool is_relative() const noexcept { return !is_absolute(); }
524 
525  // generation
526  path lexically_normal() const;
527  path lexically_relative(const path& base) const;
528  path lexically_proximate(const path& base) const;
529 
530  // iterators
531  class iterator;
532  using const_iterator = iterator;
533 
534  iterator begin() const noexcept;
535  iterator end() const noexcept;
536 
537  /// Write a path to a stream
538  template<typename _CharT, typename _Traits>
539  friend std::basic_ostream<_CharT, _Traits>&
540  operator<<(std::basic_ostream<_CharT, _Traits>& __os, const path& __p)
541  {
542  __os << std::quoted(__p.string<_CharT, _Traits>());
543  return __os;
544  }
545 
546  /// Read a path from a stream
547  template<typename _CharT, typename _Traits>
550  {
552  if (__is >> std::quoted(__tmp))
553  __p = std::move(__tmp);
554  return __is;
555  }
556 
557  // non-member operators
558 
559  /// Compare paths
560  friend bool operator==(const path& __lhs, const path& __rhs) noexcept
561  { return path::_S_compare(__lhs, __rhs) == 0; }
562 
563 #if __cpp_lib_three_way_comparison
564  /// Compare paths
565  friend strong_ordering
566  operator<=>(const path& __lhs, const path& __rhs) noexcept
567  { return path::_S_compare(__lhs, __rhs) <=> 0; }
568 #else
569  /// Compare paths
570  friend bool operator!=(const path& __lhs, const path& __rhs) noexcept
571  { return !(__lhs == __rhs); }
572 
573  /// Compare paths
574  friend bool operator<(const path& __lhs, const path& __rhs) noexcept
575  { return __lhs.compare(__rhs) < 0; }
576 
577  /// Compare paths
578  friend bool operator<=(const path& __lhs, const path& __rhs) noexcept
579  { return !(__rhs < __lhs); }
580 
581  /// Compare paths
582  friend bool operator>(const path& __lhs, const path& __rhs) noexcept
583  { return __rhs < __lhs; }
584 
585  /// Compare paths
586  friend bool operator>=(const path& __lhs, const path& __rhs) noexcept
587  { return !(__lhs < __rhs); }
588 #endif
589 
590  /// Append one path to another
591  friend path operator/(const path& __lhs, const path& __rhs)
592  {
593  path __result(__lhs);
594  __result /= __rhs;
595  return __result;
596  }
597 
598  private:
599  enum class _Type : unsigned char {
600  _Multi = 0, _Root_name, _Root_dir, _Filename
601  };
602 
603  path(basic_string_view<value_type> __str, _Type __type);
604 
605  enum class _Split { _Stem, _Extension };
606 
607  void _M_append(basic_string_view<value_type>);
608  void _M_concat(basic_string_view<value_type>);
609 
610  pair<const string_type*, size_t> _M_find_extension() const noexcept;
611 
612  // path::_S_convert creates a basic_string<value_type> or
613  // basic_string_view<value_type> from a basic_string<C> or
614  // basic_string_view<C>, for an encoded character type C,
615  // performing the conversions required by [fs.path.type.cvt].
616  template<typename _Tp>
617  static auto
618  _S_convert(_Tp __str)
619  noexcept(is_same_v<typename _Tp::value_type, value_type>)
620  {
621  if constexpr (is_same_v<typename _Tp::value_type, value_type>)
622  return __str; // No conversion needed.
623 #if !defined _GLIBCXX_FILESYSTEM_IS_WINDOWS && defined _GLIBCXX_USE_CHAR8_T
624  else if constexpr (is_same_v<_Tp, std::u8string>)
625  // Calling _S_convert<char8_t> will return a u8string_view that
626  // refers to __str and would dangle after this function returns.
627  // Return a string_type instead, to avoid dangling.
628  return string_type(_S_convert(__str.data(),
629  __str.data() + __str.size()));
630 #endif
631  else
632  return _S_convert(__str.data(), __str.data() + __str.size());
633  }
634 
635  template<typename _EcharT>
636  static auto
637  _S_convert(const _EcharT* __first, const _EcharT* __last);
638 
639  // _S_convert_loc converts a range of char to string_type, using the
640  // supplied locale for encoding conversions.
641 
642  static string_type
643  _S_convert_loc(const char* __first, const char* __last,
644  const std::locale& __loc);
645 
646  template<typename _Iter>
647  static string_type
648  _S_convert_loc(_Iter __first, _Iter __last, const std::locale& __loc)
649  {
650  const auto __s = __detail::__string_from_range(__first, __last);
651  return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc);
652  }
653 
654  template<typename _Tp>
655  static string_type
656  _S_convert_loc(const _Tp& __s, const std::locale& __loc)
657  {
658  return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc);
659  }
660 
661  template<typename _CharT, typename _Traits, typename _Allocator>
662  static basic_string<_CharT, _Traits, _Allocator>
663  _S_str_convert(basic_string_view<value_type>, const _Allocator&);
664 
665  // Returns lhs.compare(rhs), but defined after path::iterator is complete.
666  __attribute__((__always_inline__))
667  static int
668  _S_compare(const path& __lhs, const path& __rhs) noexcept;
669 
670  void _M_split_cmpts();
671 
672  _Type _M_type() const noexcept { return _M_cmpts.type(); }
673 
674  string_type _M_pathname;
675 
676  struct _Cmpt;
677 
678  struct _List
679  {
680  using value_type = _Cmpt;
681  using iterator = value_type*;
682  using const_iterator = const value_type*;
683 
684  _List();
685  _List(const _List&);
686  _List(_List&&) = default;
687  _List& operator=(const _List&);
688  _List& operator=(_List&&) = default;
689  ~_List() = default;
690 
691  _Type type() const noexcept
692  { return _Type(reinterpret_cast<uintptr_t>(_M_impl.get()) & 0x3); }
693 
694  void type(_Type) noexcept;
695 
696  int size() const noexcept; // zero unless type() == _Type::_Multi
697  bool empty() const noexcept; // true unless type() == _Type::_Multi
698  void clear();
699  void swap(_List& __l) noexcept { _M_impl.swap(__l._M_impl); }
700  int capacity() const noexcept;
701  void reserve(int, bool); ///< @pre type() == _Type::_Multi
702 
703  // All the member functions below here have a precondition !empty()
704  // (and they should only be called from within the library).
705 
706  iterator begin() noexcept;
707  iterator end() noexcept;
708  const_iterator begin() const noexcept;
709  const_iterator end() const noexcept;
710 
711  value_type& front() noexcept;
712  value_type& back() noexcept;
713  const value_type& front() const noexcept;
714  const value_type& back() const noexcept;
715 
716  void pop_back();
717  void _M_erase_from(const_iterator __pos); // erases [__pos,end())
718 
719  struct _Impl;
720  struct _Impl_deleter
721  {
722  void operator()(_Impl*) const noexcept;
723  };
724  unique_ptr<_Impl, _Impl_deleter> _M_impl;
725  };
726  _List _M_cmpts;
727 
728  struct _Parser;
729 
730  template<typename _EcharT> struct _Codecvt;
731  };
732 
733  /// @{
734  /// @relates std::filesystem::path
735 
736  inline void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); }
737 
738  size_t hash_value(const path& __p) noexcept;
739 
740  /// @}
741 
742  /// Exception type thrown by the Filesystem library
743  /**
744  * @headerfile filesystem
745  * @since C++17
746  */
748  {
749  public:
750  filesystem_error(const string& __what_arg, error_code __ec);
751 
752  filesystem_error(const string& __what_arg, const path& __p1,
753  error_code __ec);
754 
755  filesystem_error(const string& __what_arg, const path& __p1,
756  const path& __p2, error_code __ec);
757 
758  filesystem_error(const filesystem_error&) = default;
759  filesystem_error& operator=(const filesystem_error&) = default;
760 
761  // No move constructor or assignment operator.
762  // Copy rvalues instead, so that _M_impl is not left empty.
763 
764  ~filesystem_error();
765 
766  const path& path1() const noexcept;
767  const path& path2() const noexcept;
768  const char* what() const noexcept;
769 
770  private:
771  struct _Impl;
772  std::__shared_ptr<const _Impl> _M_impl;
773  };
774 
775  /// @cond undocumented
776 namespace __detail
777 {
778  [[noreturn]] inline void
779  __throw_conversion_error()
780  {
781  _GLIBCXX_THROW_OR_ABORT(filesystem_error(
782  "Cannot convert character sequence",
783  std::make_error_code(errc::illegal_byte_sequence)));
784  }
785 
786 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
787  template<typename _Tp>
788  inline std::wstring
789  __wstr_from_utf8(const _Tp& __str)
790  {
791  static_assert(std::is_same_v<typename _Tp::value_type, char>);
792  std::wstring __wstr;
793  // XXX This assumes native wide encoding is UTF-16.
794  std::codecvt_utf8_utf16<wchar_t> __wcvt;
795  const auto __p = __str.data();
796  if (!__str_codecvt_in_all(__p, __p + __str.size(), __wstr, __wcvt))
797  __detail::__throw_conversion_error();
798  return __wstr;
799  }
800 #endif
801 
802 } // namespace __detail
803  /// @endcond
804 
805 
806  /** Create a path from a UTF-8-encoded sequence of char
807  *
808  * @relates std::filesystem::path
809  * @headerfile filesystem
810  * @since C++17
811  */
812  template<typename _InputIterator,
813  typename _Require = __detail::_Path2<_InputIterator>,
814  typename _CharT
815  = __detail::__value_type_is_char_or_char8_t<_InputIterator>>
816  _GLIBCXX20_DEPRECATED_SUGGEST("path(u8string(first, last))")
817  inline path
818  u8path(_InputIterator __first, _InputIterator __last)
819  {
820 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
821  if constexpr (is_same_v<_CharT, char>)
822  return path{ __detail::__wstr_from_utf8(
823  __detail::__string_from_range(__first, __last)) };
824  else
825  return path{ __first, __last }; // constructor handles char8_t
826 #else
827  // This assumes native normal encoding is UTF-8.
828  return path{ __first, __last };
829 #endif
830  }
831 
832  /** Create a path from a UTF-8-encoded sequence of char
833  *
834  * @relates std::filesystem::path
835  * @headerfile filesystem
836  * @since C++17
837  */
838  template<typename _Source,
839  typename _Require = __detail::_Path<_Source>,
840  typename _CharT = __detail::__value_type_is_char_or_char8_t<_Source>>
841  _GLIBCXX20_DEPRECATED_SUGGEST("path((const char8_t*)&*source)")
842  inline path
843  u8path(const _Source& __source)
844  {
845 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
846  if constexpr (is_same_v<_CharT, char>)
847  return path{ __detail::__wstr_from_utf8(
848  __detail::__effective_range(__source)) };
849  else
850  return path{ __source }; // constructor handles char8_t
851 #else
852  // This assumes native normal encoding is UTF-8.
853  return path{ __source };
854 #endif
855  }
856 
857  /// @cond undocumented
858 
859  struct path::_Cmpt : path
860  {
861  _Cmpt(basic_string_view<value_type> __s, _Type __t, size_t __pos);
862 
863  _Cmpt() : _M_pos(-1) { }
864 
865  size_t _M_pos;
866  };
867 
868  // path::_Codecvt<C> Performs conversions between C and path::string_type.
869  // The native encoding of char strings is the OS-dependent current
870  // encoding for pathnames. FIXME: We assume this is UTF-8 everywhere,
871  // but should use a Windows API to query it.
872 
873  // Converts between native pathname encoding and char16_t or char32_t.
874  template<typename _EcharT>
875  struct path::_Codecvt
876  // Need derived class here because std::codecvt has protected destructor.
877  : std::codecvt<_EcharT, char, mbstate_t>
878  { };
879 
880  // Converts between native pathname encoding and native wide encoding.
881  // The native encoding for wide strings is the execution wide-character
882  // set encoding. FIXME: We assume that this is either UTF-32 or UTF-16
883  // (depending on the width of wchar_t). That matches GCC's default,
884  // but can be changed with -fwide-exec-charset.
885  // We need a custom codecvt converting the native pathname encoding
886  // to/from the native wide encoding.
887  template<>
888  struct path::_Codecvt<wchar_t>
889  : __conditional_t<sizeof(wchar_t) == sizeof(char32_t),
890  std::codecvt_utf8<wchar_t>, // UTF-8 <-> UTF-32
891  std::codecvt_utf8_utf16<wchar_t>> // UTF-8 <-> UTF-16
892  { };
893 
894  template<typename _EcharT>
895  auto
896  path::_S_convert(const _EcharT* __f, const _EcharT* __l)
897  {
898  static_assert(__detail::__is_encoded_char<_EcharT>);
899 
900 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
901 # define _GLIBCXX_CONV_FROM_UTF8(S) __detail::__wstr_from_utf8(S)
902 #else
903 # define _GLIBCXX_CONV_FROM_UTF8(S) S
904 #endif
905 
906  if constexpr (is_same_v<_EcharT, value_type>)
907  return basic_string_view<value_type>(__f, __l - __f);
908 #ifdef _GLIBCXX_USE_CHAR8_T
909  else if constexpr (is_same_v<_EcharT, char8_t>)
910  {
911  string_view __str(reinterpret_cast<const char*>(__f), __l - __f);
912  return _GLIBCXX_CONV_FROM_UTF8(__str);
913  }
914 #endif
915 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
916  else if constexpr (is_same_v<_EcharT, char>)
917  {
918  std::wstring __wstr;
919  path::_Codecvt<wchar_t> __cvt;
920  if (__str_codecvt_in_all(__f, __l, __wstr, __cvt))
921  return __wstr;
922  }
923 #endif
924  else
925  {
926  path::_Codecvt<_EcharT> __cvt;
927  std::string __str;
928  if (__str_codecvt_out_all(__f, __l, __str, __cvt))
929  return _GLIBCXX_CONV_FROM_UTF8(__str);
930  }
931  __detail::__throw_conversion_error();
932  }
933 #undef _GLIBCXX_CONV_FROM_UTF8
934 
935  /// @endcond
936 
937  /// An iterator for the components of a path
938  /**
939  * @headerfile filesystem
940  * @since C++17
941  */
943  {
944  public:
945  using difference_type = std::ptrdiff_t;
946  using value_type = path;
947  using reference = const path&;
948  using pointer = const path*;
950 
951  iterator() noexcept : _M_path(nullptr), _M_cur(), _M_at_end() { }
952 
953  iterator(const iterator&) = default;
954  iterator& operator=(const iterator&) = default;
955 
956  reference operator*() const noexcept;
957  pointer operator->() const noexcept { return std::__addressof(**this); }
958 
959  iterator& operator++() noexcept;
960 
961  iterator operator++(int) noexcept
962  { auto __tmp = *this; ++*this; return __tmp; }
963 
964  iterator& operator--() noexcept;
965 
966  iterator operator--(int) noexcept
967  { auto __tmp = *this; --*this; return __tmp; }
968 
969  friend bool
970  operator==(const iterator& __lhs, const iterator& __rhs) noexcept
971  { return __lhs._M_equals(__rhs); }
972 
973  friend bool
974  operator!=(const iterator& __lhs, const iterator& __rhs) noexcept
975  { return !__lhs._M_equals(__rhs); }
976 
977  private:
978  friend class path;
979 
980  bool
981  _M_is_multi() const noexcept
982  { return _M_path->_M_type() == _Type::_Multi; }
983 
984  friend difference_type
985  __path_iter_distance(const iterator& __first, const iterator& __last)
986  noexcept
987  {
988  __glibcxx_assert(__first._M_path != nullptr);
989  __glibcxx_assert(__first._M_path == __last._M_path);
990  if (__first._M_is_multi())
991  return std::distance(__first._M_cur, __last._M_cur);
992  else if (__first._M_at_end == __last._M_at_end)
993  return 0;
994  else
995  return __first._M_at_end ? -1 : 1;
996  }
997 
998  friend void
999  __path_iter_advance(iterator& __i, difference_type __n) noexcept
1000  {
1001  if (__n == 1)
1002  ++__i;
1003  else if (__n == -1)
1004  --__i;
1005  else if (__n != 0)
1006  {
1007  __glibcxx_assert(__i._M_path != nullptr);
1008  __glibcxx_assert(__i._M_is_multi());
1009  // __glibcxx_assert(__i._M_path->_M_cmpts.end() - __i._M_cur >= __n);
1010  __i._M_cur += __n;
1011  }
1012  }
1013 
1014  iterator(const path* __path, path::_List::const_iterator __iter) noexcept
1015  : _M_path(__path), _M_cur(__iter), _M_at_end()
1016  { }
1017 
1018  iterator(const path* __path, bool __at_end) noexcept
1019  : _M_path(__path), _M_cur(), _M_at_end(__at_end)
1020  { }
1021 
1022  bool _M_equals(iterator) const noexcept;
1023 
1024  const path* _M_path;
1025  path::_List::const_iterator _M_cur;
1026  bool _M_at_end; // only used when type != _Multi
1027  };
1028 
1029 
1030  inline path&
1031  path::operator=(path&& __p) noexcept
1032  {
1033  if (&__p == this) [[__unlikely__]]
1034  return *this;
1035 
1036  _M_pathname = std::move(__p._M_pathname);
1037  _M_cmpts = std::move(__p._M_cmpts);
1038  __p.clear();
1039  return *this;
1040  }
1041 
1042  inline path&
1043  path::operator=(string_type&& __source)
1044  { return *this = path(std::move(__source)); }
1045 
1046  inline path&
1047  path::assign(string_type&& __source)
1048  { return *this = path(std::move(__source)); }
1049 
1050  inline path&
1051  path::operator+=(const string_type& __x)
1052  {
1053  _M_concat(__x);
1054  return *this;
1055  }
1056 
1057  inline path&
1058  path::operator+=(const value_type* __x)
1059  {
1060  _M_concat(__x);
1061  return *this;
1062  }
1063 
1064  inline path&
1065  path::operator+=(value_type __x)
1066  {
1067  _M_concat(basic_string_view<value_type>(&__x, 1));
1068  return *this;
1069  }
1070 
1071  inline path&
1072  path::operator+=(basic_string_view<value_type> __x)
1073  {
1074  _M_concat(__x);
1075  return *this;
1076  }
1077 
1078  template<typename _CharT>
1079  inline __detail::_Path2<_CharT*>&
1080  path::operator+=(const _CharT __x)
1081  {
1082  _M_concat(_S_convert(&__x, &__x + 1));
1083  return *this;
1084  }
1085 
1086  inline path&
1087  path::make_preferred()
1088  {
1089 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1090  auto __pos = _M_pathname.find(L'/');
1091  while (__pos != _M_pathname.npos)
1092  {
1093  _M_pathname[__pos] = preferred_separator;
1094  __pos = _M_pathname.find(L'/', __pos);
1095  }
1096 #endif
1097  return *this;
1098  }
1099 
1100  inline void path::swap(path& __rhs) noexcept
1101  {
1102  _M_pathname.swap(__rhs._M_pathname);
1103  _M_cmpts.swap(__rhs._M_cmpts);
1104  }
1105 
1106  /// @cond undocumented
1107  template<typename _CharT, typename _Traits, typename _Allocator>
1109  path::_S_str_convert(basic_string_view<value_type> __str,
1110  const _Allocator& __a)
1111  {
1112  static_assert(!is_same_v<_CharT, value_type>);
1113 
1114  using _WString = basic_string<_CharT, _Traits, _Allocator>;
1115 
1116  if (__str.size() == 0)
1117  return _WString(__a);
1118 
1119 #ifndef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1120  string_view __u8str = __str;
1121 #else
1122  // First convert native string from UTF-16 to to UTF-8.
1123  // XXX This assumes that the execution wide-character set is UTF-16.
1124  std::codecvt_utf8_utf16<value_type> __cvt;
1125 
1126  using _CharAlloc = __alloc_rebind<_Allocator, char>;
1127  using _String = basic_string<char, char_traits<char>, _CharAlloc>;
1128  _String __u8str{_CharAlloc{__a}};
1129  const value_type* __wfirst = __str.data();
1130  const value_type* __wlast = __wfirst + __str.size();
1131  if (!__str_codecvt_out_all(__wfirst, __wlast, __u8str, __cvt))
1132  __detail::__throw_conversion_error();
1133  if constexpr (is_same_v<_CharT, char>)
1134  return __u8str; // XXX assumes native ordinary encoding is UTF-8.
1135  else
1136 #endif
1137  {
1138  const char* __first = __u8str.data();
1139  const char* __last = __first + __u8str.size();
1140 
1141  // Convert UTF-8 string to requested format.
1142 #ifdef _GLIBCXX_USE_CHAR8_T
1143  if constexpr (is_same_v<_CharT, char8_t>)
1144  return _WString(__first, __last, __a);
1145  else
1146 #endif
1147  {
1148  // Convert UTF-8 to wide string.
1149  _WString __wstr(__a);
1150  path::_Codecvt<_CharT> __cvt;
1151  if (__str_codecvt_in_all(__first, __last, __wstr, __cvt))
1152  return __wstr;
1153  }
1154  }
1155  __detail::__throw_conversion_error();
1156  }
1157  /// @endcond
1158 
1159  template<typename _CharT, typename _Traits, typename _Allocator>
1160  inline basic_string<_CharT, _Traits, _Allocator>
1161  path::string(const _Allocator& __a) const
1162  {
1163  if constexpr (is_same_v<_CharT, value_type>)
1164  return { _M_pathname.c_str(), _M_pathname.length(), __a };
1165  else
1166  return _S_str_convert<_CharT, _Traits>(_M_pathname, __a);
1167  }
1168 
1169  inline std::string
1170  path::string() const { return string<char>(); }
1171 
1172 #if _GLIBCXX_USE_WCHAR_T
1173  inline std::wstring
1174  path::wstring() const { return string<wchar_t>(); }
1175 #endif
1176 
1177 #ifdef _GLIBCXX_USE_CHAR8_T
1178  inline std::u8string
1179  path::u8string() const { return string<char8_t>(); }
1180 #else
1181  inline std::string
1182  path::u8string() const
1183  {
1184 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1185  std::string __str;
1186  // convert from native wide encoding (assumed to be UTF-16) to UTF-8
1187  std::codecvt_utf8_utf16<value_type> __cvt;
1188  const value_type* __first = _M_pathname.data();
1189  const value_type* __last = __first + _M_pathname.size();
1190  if (__str_codecvt_out_all(__first, __last, __str, __cvt))
1191  return __str;
1192  __detail::__throw_conversion_error();
1193 #else
1194  return _M_pathname;
1195 #endif
1196  }
1197 #endif // _GLIBCXX_USE_CHAR8_T
1198 
1199  inline std::u16string
1200  path::u16string() const { return string<char16_t>(); }
1201 
1202  inline std::u32string
1203  path::u32string() const { return string<char32_t>(); }
1204 
1205  template<typename _CharT, typename _Traits, typename _Allocator>
1207  path::generic_string(const _Allocator& __a) const
1208  {
1209 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1210  const value_type __slash = L'/';
1211 #else
1212  const value_type __slash = '/';
1213 #endif
1214  using _Alloc2 = typename allocator_traits<_Allocator>::template
1215  rebind_alloc<value_type>;
1216  basic_string<value_type, char_traits<value_type>, _Alloc2> __str(__a);
1217 
1218  if (_M_type() == _Type::_Root_dir)
1219  __str.assign(1, __slash);
1220  else
1221  {
1222  __str.reserve(_M_pathname.size());
1223  bool __add_slash = false;
1224  for (auto& __elem : *this)
1225  {
1226 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1227  if (__elem._M_type() == _Type::_Root_dir)
1228  {
1229  __str += __slash;
1230  continue;
1231  }
1232 #endif
1233  if (__add_slash)
1234  __str += __slash;
1235  __str += basic_string_view<value_type>(__elem._M_pathname);
1236  __add_slash = __elem._M_type() == _Type::_Filename;
1237  }
1238  }
1239 
1240  if constexpr (is_same_v<_CharT, value_type>)
1241  return __str;
1242  else
1243  return _S_str_convert<_CharT, _Traits>(__str, __a);
1244  }
1245 
1246  inline std::string
1247  path::generic_string() const
1248  { return generic_string<char>(); }
1249 
1250 #if _GLIBCXX_USE_WCHAR_T
1251  inline std::wstring
1252  path::generic_wstring() const
1253  { return generic_string<wchar_t>(); }
1254 #endif
1255 
1256 #ifdef _GLIBCXX_USE_CHAR8_T
1257  inline std::u8string
1258  path::generic_u8string() const
1259  { return generic_string<char8_t>(); }
1260 #else
1261  inline std::string
1262  path::generic_u8string() const
1263  { return generic_string(); }
1264 #endif
1265 
1266  inline std::u16string
1267  path::generic_u16string() const
1268  { return generic_string<char16_t>(); }
1269 
1270  inline std::u32string
1271  path::generic_u32string() const
1272  { return generic_string<char32_t>(); }
1273 
1274  inline int
1275  path::compare(const string_type& __s) const noexcept
1276  { return compare(basic_string_view<value_type>(__s)); }
1277 
1278  inline int
1279  path::compare(const value_type* __s) const noexcept
1280  { return compare(basic_string_view<value_type>(__s)); }
1281 
1282  inline path
1283  path::filename() const
1284  {
1285  if (empty())
1286  return {};
1287  else if (_M_type() == _Type::_Filename)
1288  return *this;
1289  else if (_M_type() == _Type::_Multi)
1290  {
1291  if (_M_pathname.back() == preferred_separator)
1292  return {};
1293  auto __last = --end();
1294  if (__last->_M_type() == _Type::_Filename)
1295  return *__last;
1296  }
1297  return {};
1298  }
1299 
1300  inline path
1301  path::stem() const
1302  {
1303  auto ext = _M_find_extension();
1304  if (ext.first && ext.second != 0)
1305  return path{ext.first->substr(0, ext.second)};
1306  return {};
1307  }
1308 
1309  inline path
1310  path::extension() const
1311  {
1312  auto ext = _M_find_extension();
1313  if (ext.first && ext.second != string_type::npos)
1314  return path{ext.first->substr(ext.second)};
1315  return {};
1316  }
1317 
1318  inline bool
1319  path::has_stem() const noexcept
1320  {
1321  auto ext = _M_find_extension();
1322  return ext.first && ext.second != 0;
1323  }
1324 
1325  inline bool
1326  path::has_extension() const noexcept
1327  {
1328  auto ext = _M_find_extension();
1329  return ext.first && ext.second != string_type::npos;
1330  }
1331 
1332  inline bool
1333  path::is_absolute() const noexcept
1334  {
1335 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1336  return has_root_name() && has_root_directory();
1337 #else
1338  return has_root_directory();
1339 #endif
1340  }
1341 
1342  inline path::iterator
1343  path::begin() const noexcept
1344  {
1345  if (_M_type() == _Type::_Multi)
1346  return iterator(this, _M_cmpts.begin());
1347  return iterator(this, empty());
1348  }
1349 
1350  inline path::iterator
1351  path::end() const noexcept
1352  {
1353  if (_M_type() == _Type::_Multi)
1354  return iterator(this, _M_cmpts.end());
1355  return iterator(this, true);
1356  }
1357 
1358  inline path::iterator&
1359  path::iterator::operator++() noexcept
1360  {
1361  __glibcxx_assert(_M_path != nullptr);
1362  if (_M_is_multi())
1363  {
1364  __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1365  ++_M_cur;
1366  }
1367  else
1368  {
1369  __glibcxx_assert(!_M_at_end);
1370  _M_at_end = true;
1371  }
1372  return *this;
1373  }
1374 
1375  inline path::iterator&
1376  path::iterator::operator--() noexcept
1377  {
1378  __glibcxx_assert(_M_path != nullptr);
1379  if (_M_is_multi())
1380  {
1381  __glibcxx_assert(_M_cur != _M_path->_M_cmpts.begin());
1382  --_M_cur;
1383  }
1384  else
1385  {
1386  __glibcxx_assert(_M_at_end);
1387  _M_at_end = false;
1388  }
1389  return *this;
1390  }
1391 
1392  inline path::iterator::reference
1393  path::iterator::operator*() const noexcept
1394  {
1395  __glibcxx_assert(_M_path != nullptr);
1396  if (_M_is_multi())
1397  {
1398  __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1399  return *_M_cur;
1400  }
1401  return *_M_path;
1402  }
1403 
1404  inline bool
1405  path::iterator::_M_equals(iterator __rhs) const noexcept
1406  {
1407  if (_M_path != __rhs._M_path)
1408  return false;
1409  if (_M_path == nullptr)
1410  return true;
1411  if (_M_is_multi())
1412  return _M_cur == __rhs._M_cur;
1413  return _M_at_end == __rhs._M_at_end;
1414  }
1415 
1416  // Define this now that path and path::iterator are complete.
1417  // It needs to consider the string_view(Range&&) constructor during
1418  // overload resolution, which depends on whether range<path> is satisfied,
1419  // which depends on whether path::iterator is complete.
1420  inline int
1421  path::_S_compare(const path& __lhs, const path& __rhs) noexcept
1422  { return __lhs.compare(__rhs); }
1423 
1424  /// @} group filesystem
1425 _GLIBCXX_END_NAMESPACE_CXX11
1426 } // namespace filesystem
1427 
1428 /// @cond undocumented
1429 
1430 inline ptrdiff_t
1431 distance(filesystem::path::iterator __first, filesystem::path::iterator __last)
1432 noexcept
1433 { return __path_iter_distance(__first, __last); }
1434 
1435 template<typename _Distance>
1436  inline void
1437  advance(filesystem::path::iterator& __i, _Distance __n) noexcept
1438  { __path_iter_advance(__i, static_cast<ptrdiff_t>(__n)); }
1439 
1440 extern template class __shared_ptr<const filesystem::filesystem_error::_Impl>;
1441 
1442 /// @endcond
1443 
1444 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1445 // 3657. std::hash<std::filesystem::path> is not enabled
1446 template<>
1447  struct hash<filesystem::path>
1448  {
1449  size_t
1450  operator()(const filesystem::path& __p) const noexcept
1451  { return filesystem::hash_value(__p); }
1452  };
1453 
1454 _GLIBCXX_END_NAMESPACE_VERSION
1455 } // namespace std
1456 
1457 #endif // C++17
1458 
1459 #endif // _GLIBCXX_FS_PATH_H
std::filesystem::filesystem_error::what
const char * what() const noexcept
concurrence.h
iomanip
std::filesystem::path::operator!=
friend bool operator!=(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:570
stl_pair.h
std::enable_if_t
typename enable_if< _Cond, _Tp >::type enable_if_t
Alias template for enable_if.
Definition: type_traits:2610
std::size
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
Definition: range_access.h:264
std::locale
Container class for localization functionality.
Definition: locale_classes.h:62
std::basic_ostream
Template class basic_ostream.
Definition: iosfwd:88
std::quoted
auto quoted(const _CharT *__string, _CharT __delim=_CharT('"'), _CharT __escape = _CharT('\\'))
Manipulator for quoted strings.
Definition: iomanip:464
std::wstring
basic_string< wchar_t > wstring
A string of wchar_t.
Definition: stringfwd.h:80
type_traits
std::basic_string::c_str
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
Definition: cow_string.h:2215
std::filesystem::path::iterator
An iterator for the components of a path.
Definition: bits/fs_path.h:942
std::__addressof
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition: move.h:51
stl_algobase.h
std::u16string
basic_string< char16_t > u16string
A string of char16_t.
Definition: stringfwd.h:89
std::filesystem::path
A filesystem path.
Definition: bits/fs_path.h:293
std::filesystem::path::operator/
friend path operator/(const path &__lhs, const path &__rhs)
Append one path to another.
Definition: bits/fs_path.h:591
std::basic_string_view
A non-owning reference to a string.
Definition: string_view:106
std::codecvt
Primary class template codecvt.
Definition: codecvt.h:277
unique_ptr.h
std::filesystem::path::format
format
path::format is ignored in this implementation
Definition: bits/fs_path.h:311
std::operator*
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Definition: complex:395
std::system_error
An exception type that includes an error_code value.
Definition: system_error:556
std::u32string
basic_string< char32_t > u32string
A string of char32_t.
Definition: stringfwd.h:92
codecvt
std::make_error_code
error_code make_error_code(future_errc __errc) noexcept
Overload of make_error_code for future_errc.
Definition: future:94
std::basic_string< value_type >
system_error
std::iterator_traits
Traits class for iterators.
Definition: cpp_type_traits.h:470
std::basic_string::empty
bool empty() const noexcept
Definition: cow_string.h:1035
std::basic_string::clear
void clear() noexcept
Definition: cow_string.h:1013
std::bidirectional_iterator_tag
Bidirectional iterators support a superset of forward iterator operations.
Definition: stl_iterator_base_types.h:103
string_view
std::basic_istream
Template class basic_istream.
Definition: iosfwd:85
std::filesystem::path::operator>=
friend bool operator>=(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:586
std::string
basic_string< char > string
A string of char.
Definition: stringfwd.h:72
std::filesystem::path::operator<
friend bool operator<(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:574
std::filesystem::filesystem_error
Exception type thrown by the Filesystem library.
Definition: bits/fs_path.h:747
std::filesystem::path::operator>
friend bool operator>(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:582
std::filesystem::path::operator>>
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, path &__p)
Read a path from a stream.
Definition: bits/fs_path.h:549
std::distance
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
Definition: stl_iterator_base_funcs.h:148
locale_conv.h
std::advance
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
Definition: stl_iterator_base_funcs.h:220
std::filesystem::path::operator==
friend bool operator==(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:560
std::basic_string::reserve
void reserve(size_type __res_arg)
Attempt to preallocate enough memory for specified number of characters.
Definition: cow_string.h:3487
std::basic_string< value_type >::npos
static const size_type npos
Value returned by various member functions when they fail.
Definition: cow_string.h:330
std
ISO C++ entities toplevel namespace is std.
iosfwd
std::move
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition: move.h:97
compare
std::filesystem::path::operator<=
friend bool operator<=(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:578
std::error_code
Definition: system_error:223
std::basic_string::assign
basic_string & assign(const basic_string &__str)
Set value to contents of another string.
Definition: cow_string.h:3225
std::basic_string::data
const _CharT * data() const noexcept
Return const pointer to contents.
Definition: cow_string.h:2227
locale