libstdc++
bits/fs_path.h
Go to the documentation of this file.
1 // Class filesystem::path -*- C++ -*-
2 
3 // Copyright (C) 2014-2021 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 # include <algorithm>
56 #endif
57 
58 namespace std _GLIBCXX_VISIBILITY(default)
59 {
60 _GLIBCXX_BEGIN_NAMESPACE_VERSION
61 
62 namespace filesystem
63 {
64 _GLIBCXX_BEGIN_NAMESPACE_CXX11
65 
66  class path;
67 
68  /// @cond undocumented
69 namespace __detail
70 {
71  /// @addtogroup filesystem
72  /// @{
73  template<typename _CharT>
74  inline constexpr bool __is_encoded_char = false;
75  template<>
76  inline constexpr bool __is_encoded_char<char> = true;
77 #ifdef _GLIBCXX_USE_CHAR8_T
78  template<>
79  inline constexpr bool __is_encoded_char<char8_t> = true;
80 #endif
81 #if _GLIBCXX_USE_WCHAR_T
82  template<>
83  inline constexpr bool __is_encoded_char<wchar_t> = true;
84 #endif
85  template<>
86  inline constexpr bool __is_encoded_char<char16_t> = true;
87  template<>
88  inline constexpr bool __is_encoded_char<char32_t> = true;
89 
90 #if __cpp_concepts >= 201907L
91  template<typename _Iter>
92  using __safe_iterator_traits = std::iterator_traits<_Iter>;
93 #else
94  template<typename _Iter>
95  struct __safe_iterator_traits : std::iterator_traits<_Iter>
96  { };
97 
98  // Protect against ill-formed iterator_traits specializations in C++17
99  template<> struct __safe_iterator_traits<void*> { };
100  template<> struct __safe_iterator_traits<const void*> { };
101  template<> struct __safe_iterator_traits<volatile void*> { };
102  template<> struct __safe_iterator_traits<const volatile void*> { };
103 #endif
104 
105  template<typename _Iter_traits, typename = void>
106  struct __is_path_iter_src
107  : false_type
108  { };
109 
110  template<typename _Iter_traits>
111  struct __is_path_iter_src<_Iter_traits,
112  void_t<typename _Iter_traits::value_type>>
113  : bool_constant<__is_encoded_char<typename _Iter_traits::value_type>>
114  { };
115 
116  template<typename _Source>
117  inline constexpr bool __is_path_src
118  = __is_path_iter_src<iterator_traits<decay_t<_Source>>>::value;
119 
120  template<>
121  inline constexpr bool __is_path_src<path> = false;
122 
123  template<>
124  inline constexpr bool __is_path_src<volatile path> = false;
125 
126  template<>
127  inline constexpr bool __is_path_src<void*> = false;
128 
129  template<>
130  inline constexpr bool __is_path_src<const void*> = false;
131 
132  template<>
133  inline constexpr bool __is_path_src<volatile void*> = false;
134 
135  template<>
136  inline constexpr bool __is_path_src<const volatile void*> = false;
137 
138  template<typename _CharT, typename _Traits, typename _Alloc>
139  inline constexpr bool
140  __is_path_src<basic_string<_CharT, _Traits, _Alloc>>
141  = __is_encoded_char<_CharT>;
142 
143  template<typename _CharT, typename _Traits>
144  inline constexpr bool
145  __is_path_src<basic_string_view<_CharT, _Traits>>
146  = __is_encoded_char<_CharT>;
147 
148  // SFINAE constraint for Source parameters as required by [fs.path.req].
149  template<typename _Tp>
150  using _Path = enable_if_t<__is_path_src<_Tp>, path>;
151 
152  // SFINAE constraint for InputIterator parameters as required by [fs.req].
153  template<typename _Iter, typename _Tr = __safe_iterator_traits<_Iter>>
154  using _Path2 = enable_if_t<__is_path_iter_src<_Tr>::value, path>;
155 
156 #if __cpp_lib_concepts
157  template<typename _Iter>
158  constexpr bool __is_contiguous = std::contiguous_iterator<_Iter>;
159 #else
160  template<typename _Iter>
161  constexpr bool __is_contiguous = false;
162 #endif
163 
164  template<typename _Tp>
165  constexpr bool __is_contiguous<_Tp*> = true;
166 
167  template<typename _Tp, typename _Seq>
168  constexpr bool
169  __is_contiguous<__gnu_cxx::__normal_iterator<_Tp*, _Seq>> = true;
170 
171 #if !defined _GLIBCXX_FILESYSTEM_IS_WINDOWS && defined _GLIBCXX_USE_CHAR8_T
172  // For POSIX treat char8_t sequences as char without encoding conversions.
173  template<typename _EcharT>
174  using __unified_u8_t
175  = __conditional_t<is_same_v<_EcharT, char8_t>, char, _EcharT>;
176 #else
177  template<typename _EcharT>
178  using __unified_u8_t = _EcharT;
179 #endif
180 
181  // The __effective_range overloads convert a Source parameter into
182  // either a basic_string_view<C> or basic_string<C> containing the
183  // effective range of the Source, as defined in [fs.path.req].
184 
185  template<typename _CharT, typename _Traits, typename _Alloc>
186  inline basic_string_view<_CharT>
187  __effective_range(const basic_string<_CharT, _Traits, _Alloc>& __source)
188  noexcept
189  { return __source; }
190 
191  template<typename _CharT, typename _Traits>
192  inline basic_string_view<_CharT>
193  __effective_range(const basic_string_view<_CharT, _Traits>& __source)
194  noexcept
195  { return __source; }
196 
197  // Return the effective range of an NTCTS.
198  template<typename _Source>
199  auto
200  __effective_range(const _Source& __source)
201  {
202  // Remove a level of normal/safe iterator indirection, or decay an array.
203  using _Iter = decltype(std::__niter_base(__source));
204  using value_type = typename iterator_traits<_Iter>::value_type;
205 
206  if constexpr (__is_contiguous<_Iter>)
207  return basic_string_view<value_type>{&*__source};
208  else
209  {
210  // _Source is an input iterator that iterates over an NTCTS.
211  // Create a basic_string by reading until the null character.
212  basic_string<__unified_u8_t<value_type>> __str;
213  _Source __it = __source;
214  for (value_type __ch = *__it; __ch != value_type(); __ch = *++__it)
215  __str.push_back(__ch);
216  return __str;
217  }
218  }
219 
220  // The value type of a Source parameter's effective range.
221  template<typename _Source>
222  struct __source_value_type_impl
223  {
224  using type
225  = typename __safe_iterator_traits<decay_t<_Source>>::value_type;
226  };
227 
228  template<typename _CharT, typename _Traits, typename _Alloc>
229  struct __source_value_type_impl<basic_string<_CharT, _Traits, _Alloc>>
230  {
231  using type = _CharT;
232  };
233 
234  template<typename _CharT, typename _Traits>
235  struct __source_value_type_impl<basic_string_view<_CharT, _Traits>>
236  {
237  using type = _CharT;
238  };
239 
240  // The value type of a Source parameter's effective range.
241  template<typename _Source>
242  using __source_value_t = typename __source_value_type_impl<_Source>::type;
243 
244  // SFINAE helper to check that an effective range has value_type char,
245  // as required by path constructors taking a std::locale parameter.
246  // The type _Tp must have already been checked by _Path<Tp> or _Path2<_Tp>.
247  template<typename _Tp, typename _Val = __source_value_t<_Tp>>
248  using __value_type_is_char
250 
251  // As above, but also allows char8_t, as required by u8path
252  // C++20 [depr.fs.path.factory]
253  template<typename _Tp, typename _Val = __source_value_t<_Tp>>
254  using __value_type_is_char_or_char8_t
256 #ifdef _GLIBCXX_USE_CHAR8_T
257  || std::is_same_v<_Val, char8_t>
258 #endif
259  , _Val>;
260 
261  // Create a basic_string<C> or basic_string_view<C> from an iterator range.
262  template<typename _InputIterator>
263  inline auto
264  __string_from_range(_InputIterator __first, _InputIterator __last)
265  {
266  using _EcharT
268  static_assert(__is_encoded_char<_EcharT>); // C++17 [fs.req]/3
269 
270  if constexpr (__is_contiguous<_InputIterator>)
271  {
272  // For contiguous iterators we can just return a string view.
273  if (auto __len = __last - __first) [[__likely__]]
274  return basic_string_view<_EcharT>(&*__first, __len);
275  return basic_string_view<_EcharT>();
276  }
277  else
278  {
279  // Conversion requires contiguous characters, so create a string.
280  return basic_string<__unified_u8_t<_EcharT>>(__first, __last);
281  }
282  }
283 
284  /// @} group filesystem
285 } // namespace __detail
286  /// @endcond
287 
288  /// @addtogroup filesystem
289  /// @{
290 
291  /// A filesystem path
292  /// @ingroup filesystem
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  : _M_pathname(__str)
605  {
606  __glibcxx_assert(__type != _Type::_Multi);
607  _M_cmpts.type(__type);
608  }
609 
610  enum class _Split { _Stem, _Extension };
611 
612  void _M_append(basic_string_view<value_type>);
613  void _M_concat(basic_string_view<value_type>);
614 
615  pair<const string_type*, size_t> _M_find_extension() const noexcept;
616 
617  // path::_S_convert creates a basic_string<value_type> or
618  // basic_string_view<value_type> from a basic_string<C> or
619  // basic_string_view<C>, for an encoded character type C,
620  // performing the conversions required by [fs.path.type.cvt].
621  template<typename _Tp>
622  static auto
623  _S_convert(_Tp __str)
624  noexcept(is_same_v<typename _Tp::value_type, value_type>)
625  {
626  if constexpr (is_same_v<typename _Tp::value_type, value_type>)
627  return __str; // No conversion needed.
628 #if !defined _GLIBCXX_FILESYSTEM_IS_WINDOWS && defined _GLIBCXX_USE_CHAR8_T
629  else if constexpr (is_same_v<_Tp, std::u8string>)
630  // Calling _S_convert<char8_t> will return a u8string_view that
631  // refers to __str and would dangle after this function returns.
632  // Return a string_type instead, to avoid dangling.
633  return string_type(_S_convert(__str.data(),
634  __str.data() + __str.size()));
635 #endif
636  else
637  return _S_convert(__str.data(), __str.data() + __str.size());
638  }
639 
640  template<typename _EcharT>
641  static auto
642  _S_convert(const _EcharT* __first, const _EcharT* __last);
643 
644  // _S_convert_loc converts a range of char to string_type, using the
645  // supplied locale for encoding conversions.
646 
647  static string_type
648  _S_convert_loc(const char* __first, const char* __last,
649  const std::locale& __loc);
650 
651  template<typename _Iter>
652  static string_type
653  _S_convert_loc(_Iter __first, _Iter __last, const std::locale& __loc)
654  {
655  const auto __s = __detail::__string_from_range(__first, __last);
656  return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc);
657  }
658 
659  template<typename _Tp>
660  static string_type
661  _S_convert_loc(const _Tp& __s, const std::locale& __loc)
662  {
663  return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc);
664  }
665 
666  template<typename _CharT, typename _Traits, typename _Allocator>
667  static basic_string<_CharT, _Traits, _Allocator>
668  _S_str_convert(basic_string_view<value_type>, const _Allocator&);
669 
670  // Returns lhs.compare(rhs), but defined after path::iterator is complete.
671  __attribute__((__always_inline__))
672  static int
673  _S_compare(const path& __lhs, const path& __rhs) noexcept;
674 
675  void _M_split_cmpts();
676 
677  _Type _M_type() const noexcept { return _M_cmpts.type(); }
678 
679  string_type _M_pathname;
680 
681  struct _Cmpt;
682 
683  struct _List
684  {
685  using value_type = _Cmpt;
686  using iterator = value_type*;
687  using const_iterator = const value_type*;
688 
689  _List();
690  _List(const _List&);
691  _List(_List&&) = default;
692  _List& operator=(const _List&);
693  _List& operator=(_List&&) = default;
694  ~_List() = default;
695 
696  _Type type() const noexcept
697  { return _Type(reinterpret_cast<uintptr_t>(_M_impl.get()) & 0x3); }
698 
699  void type(_Type) noexcept;
700 
701  int size() const noexcept; // zero unless type() == _Type::_Multi
702  bool empty() const noexcept; // true unless type() == _Type::_Multi
703  void clear();
704  void swap(_List& __l) noexcept { _M_impl.swap(__l._M_impl); }
705  int capacity() const noexcept;
706  void reserve(int, bool); ///< @pre type() == _Type::_Multi
707 
708  // All the member functions below here have a precondition !empty()
709  // (and they should only be called from within the library).
710 
711  iterator begin() noexcept;
712  iterator end() noexcept;
713  const_iterator begin() const noexcept;
714  const_iterator end() const noexcept;
715 
716  value_type& front() noexcept;
717  value_type& back() noexcept;
718  const value_type& front() const noexcept;
719  const value_type& back() const noexcept;
720 
721  void pop_back();
722  void _M_erase_from(const_iterator __pos); // erases [__pos,end())
723 
724  struct _Impl;
725  struct _Impl_deleter
726  {
727  void operator()(_Impl*) const noexcept;
728  };
729  unique_ptr<_Impl, _Impl_deleter> _M_impl;
730  };
731  _List _M_cmpts;
732 
733  struct _Parser;
734  };
735 
736  /// @{
737  /// @relates std::filesystem::path
738 
739  inline void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); }
740 
741  size_t hash_value(const path& __p) noexcept;
742 
743  /// @}
744 
745  /// Exception type thrown by the Filesystem library
747  {
748  public:
749  filesystem_error(const string& __what_arg, error_code __ec);
750 
751  filesystem_error(const string& __what_arg, const path& __p1,
752  error_code __ec);
753 
754  filesystem_error(const string& __what_arg, const path& __p1,
755  const path& __p2, error_code __ec);
756 
757  filesystem_error(const filesystem_error&) = default;
758  filesystem_error& operator=(const filesystem_error&) = default;
759 
760  // No move constructor or assignment operator.
761  // Copy rvalues instead, so that _M_impl is not left empty.
762 
763  ~filesystem_error();
764 
765  const path& path1() const noexcept;
766  const path& path2() const noexcept;
767  const char* what() const noexcept;
768 
769  private:
770  struct _Impl;
771  std::__shared_ptr<const _Impl> _M_impl;
772  };
773 
774  /// @cond undocumented
775 namespace __detail
776 {
777  [[noreturn]] inline void
778  __throw_conversion_error()
779  {
780  _GLIBCXX_THROW_OR_ABORT(filesystem_error(
781  "Cannot convert character sequence",
782  std::make_error_code(errc::illegal_byte_sequence)));
783  }
784 
785 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
786  template<typename _Tp>
787  inline std::wstring
788  __wstr_from_utf8(const _Tp& __str)
789  {
790  static_assert(std::is_same_v<typename _Tp::value_type, char>);
791  std::wstring __wstr;
792  // XXX This assumes native wide encoding is UTF-16.
793  std::codecvt_utf8_utf16<wchar_t> __wcvt;
794  const auto __p = __str.data();
795  if (!__str_codecvt_in_all(__p, __p + __str.size(), __wstr, __wcvt))
796  __detail::__throw_conversion_error();
797  return __wstr;
798  }
799 #endif
800 
801 } // namespace __detail
802  /// @endcond
803 
804 
805  /** Create a path from a UTF-8-encoded sequence of char
806  *
807  * @relates std::filesystem::path
808  */
809  template<typename _InputIterator,
810  typename _Require = __detail::_Path2<_InputIterator>,
811  typename _CharT
812  = __detail::__value_type_is_char_or_char8_t<_InputIterator>>
813  inline path
814  u8path(_InputIterator __first, _InputIterator __last)
815  {
816 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
817  if constexpr (is_same_v<_CharT, char>)
818  return path{ __detail::__wstr_from_utf8(
819  __detail::__string_from_range(__first, __last)) };
820  else
821  return path{ __first, __last }; // constructor handles char8_t
822 #else
823  // This assumes native normal encoding is UTF-8.
824  return path{ __first, __last };
825 #endif
826  }
827 
828  /** Create a path from a UTF-8-encoded sequence of char
829  *
830  * @relates std::filesystem::path
831  */
832  template<typename _Source,
833  typename _Require = __detail::_Path<_Source>,
834  typename _CharT = __detail::__value_type_is_char_or_char8_t<_Source>>
835  inline path
836  u8path(const _Source& __source)
837  {
838 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
839  if constexpr (is_same_v<_CharT, char>)
840  return path{ __detail::__wstr_from_utf8(
841  __detail::__effective_range(__source)) };
842  else
843  return path{ __source }; // constructor handles char8_t
844 #else
845  // This assumes native normal encoding is UTF-8.
846  return path{ __source };
847 #endif
848  }
849 
850  /// @cond undocumented
851 
852  struct path::_Cmpt : path
853  {
854  _Cmpt(basic_string_view<value_type> __s, _Type __t, size_t __pos)
855  : path(__s, __t), _M_pos(__pos) { }
856 
857  _Cmpt() : _M_pos(-1) { }
858 
859  size_t _M_pos;
860  };
861 
862  template<typename _EcharT>
863  auto
864  path::_S_convert(const _EcharT* __f, const _EcharT* __l)
865  {
866  static_assert(__detail::__is_encoded_char<_EcharT>);
867 
868  if constexpr (is_same_v<_EcharT, value_type>)
869  return basic_string_view<value_type>(__f, __l - __f);
870 #if !defined _GLIBCXX_FILESYSTEM_IS_WINDOWS && defined _GLIBCXX_USE_CHAR8_T
871  else if constexpr (is_same_v<_EcharT, char8_t>)
872  // For POSIX converting from char8_t to char is also 'noconv'
873  return string_view(reinterpret_cast<const char*>(__f), __l - __f);
874 #endif
875  else
876  {
877 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
878  std::wstring __wstr;
879  if constexpr (is_same_v<_EcharT, char>)
880  {
881  struct _UCvt : std::codecvt<wchar_t, char, std::mbstate_t>
882  { } __cvt;
883  if (__str_codecvt_in_all(__f, __l, __wstr, __cvt))
884  return __wstr;
885  }
886 #ifdef _GLIBCXX_USE_CHAR8_T
887  else if constexpr (is_same_v<_EcharT, char8_t>)
888  {
889  const auto __f2 = reinterpret_cast<const char*>(__f);
890  return __detail::__wstr_from_utf8(string_view(__f2, __l - __f));
891  }
892 #endif
893  else // char16_t or char32_t
894  {
895  struct _UCvt : std::codecvt<_EcharT, char, std::mbstate_t>
896  { } __cvt;
897  std::string __str;
898  if (__str_codecvt_out_all(__f, __l, __str, __cvt))
899  return __detail::__wstr_from_utf8(__str);
900  }
901 #else // ! windows
902  struct _UCvt : std::codecvt<_EcharT, char, std::mbstate_t>
903  { } __cvt;
904  std::string __str;
905  if (__str_codecvt_out_all(__f, __l, __str, __cvt))
906  return __str;
907 #endif
908  __detail::__throw_conversion_error();
909  }
910  }
911 
912  /// @endcond
913 
914  /// An iterator for the components of a path
916  {
917  public:
918  using difference_type = std::ptrdiff_t;
919  using value_type = path;
920  using reference = const path&;
921  using pointer = const path*;
923 
924  iterator() noexcept : _M_path(nullptr), _M_cur(), _M_at_end() { }
925 
926  iterator(const iterator&) = default;
927  iterator& operator=(const iterator&) = default;
928 
929  reference operator*() const noexcept;
930  pointer operator->() const noexcept { return std::__addressof(**this); }
931 
932  iterator& operator++() noexcept;
933 
934  iterator operator++(int) noexcept
935  { auto __tmp = *this; ++*this; return __tmp; }
936 
937  iterator& operator--() noexcept;
938 
939  iterator operator--(int) noexcept
940  { auto __tmp = *this; --*this; return __tmp; }
941 
942  friend bool
943  operator==(const iterator& __lhs, const iterator& __rhs) noexcept
944  { return __lhs._M_equals(__rhs); }
945 
946  friend bool
947  operator!=(const iterator& __lhs, const iterator& __rhs) noexcept
948  { return !__lhs._M_equals(__rhs); }
949 
950  private:
951  friend class path;
952 
953  bool
954  _M_is_multi() const noexcept
955  { return _M_path->_M_type() == _Type::_Multi; }
956 
957  friend difference_type
958  __path_iter_distance(const iterator& __first, const iterator& __last)
959  noexcept
960  {
961  __glibcxx_assert(__first._M_path != nullptr);
962  __glibcxx_assert(__first._M_path == __last._M_path);
963  if (__first._M_is_multi())
964  return std::distance(__first._M_cur, __last._M_cur);
965  else if (__first._M_at_end == __last._M_at_end)
966  return 0;
967  else
968  return __first._M_at_end ? -1 : 1;
969  }
970 
971  friend void
972  __path_iter_advance(iterator& __i, difference_type __n) noexcept
973  {
974  if (__n == 1)
975  ++__i;
976  else if (__n == -1)
977  --__i;
978  else if (__n != 0)
979  {
980  __glibcxx_assert(__i._M_path != nullptr);
981  __glibcxx_assert(__i._M_is_multi());
982  // __glibcxx_assert(__i._M_path->_M_cmpts.end() - __i._M_cur >= __n);
983  __i._M_cur += __n;
984  }
985  }
986 
987  iterator(const path* __path, path::_List::const_iterator __iter) noexcept
988  : _M_path(__path), _M_cur(__iter), _M_at_end()
989  { }
990 
991  iterator(const path* __path, bool __at_end) noexcept
992  : _M_path(__path), _M_cur(), _M_at_end(__at_end)
993  { }
994 
995  bool _M_equals(iterator) const noexcept;
996 
997  const path* _M_path;
998  path::_List::const_iterator _M_cur;
999  bool _M_at_end; // only used when type != _Multi
1000  };
1001 
1002 
1003  inline path&
1004  path::operator=(path&& __p) noexcept
1005  {
1006  if (&__p == this) [[__unlikely__]]
1007  return *this;
1008 
1009  _M_pathname = std::move(__p._M_pathname);
1010  _M_cmpts = std::move(__p._M_cmpts);
1011  __p.clear();
1012  return *this;
1013  }
1014 
1015  inline path&
1016  path::operator=(string_type&& __source)
1017  { return *this = path(std::move(__source)); }
1018 
1019  inline path&
1020  path::assign(string_type&& __source)
1021  { return *this = path(std::move(__source)); }
1022 
1023  inline path&
1024  path::operator+=(const string_type& __x)
1025  {
1026  _M_concat(__x);
1027  return *this;
1028  }
1029 
1030  inline path&
1031  path::operator+=(const value_type* __x)
1032  {
1033  _M_concat(__x);
1034  return *this;
1035  }
1036 
1037  inline path&
1038  path::operator+=(value_type __x)
1039  {
1040  _M_concat(basic_string_view<value_type>(&__x, 1));
1041  return *this;
1042  }
1043 
1044  inline path&
1045  path::operator+=(basic_string_view<value_type> __x)
1046  {
1047  _M_concat(__x);
1048  return *this;
1049  }
1050 
1051  template<typename _CharT>
1052  inline __detail::_Path2<_CharT*>&
1053  path::operator+=(const _CharT __x)
1054  {
1055  _M_concat(_S_convert(&__x, &__x + 1));
1056  return *this;
1057  }
1058 
1059  inline path&
1060  path::make_preferred()
1061  {
1062 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1063  std::replace(_M_pathname.begin(), _M_pathname.end(), L'/',
1064  preferred_separator);
1065 #endif
1066  return *this;
1067  }
1068 
1069  inline void path::swap(path& __rhs) noexcept
1070  {
1071  _M_pathname.swap(__rhs._M_pathname);
1072  _M_cmpts.swap(__rhs._M_cmpts);
1073  }
1074 
1075  /// @cond undocumented
1076  template<typename _CharT, typename _Traits, typename _Allocator>
1078  path::_S_str_convert(basic_string_view<value_type> __str,
1079  const _Allocator& __a)
1080  {
1081  static_assert(!is_same_v<_CharT, value_type>);
1082 
1083  using _WString = basic_string<_CharT, _Traits, _Allocator>;
1084 
1085  if (__str.size() == 0)
1086  return _WString(__a);
1087 
1088 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1089  // First convert native string from UTF-16 to to UTF-8.
1090  // XXX This assumes that the execution wide-character set is UTF-16.
1091  std::codecvt_utf8_utf16<value_type> __cvt;
1092 
1093  using _CharAlloc = __alloc_rebind<_Allocator, char>;
1094  using _String = basic_string<char, char_traits<char>, _CharAlloc>;
1095  _String __u8str{_CharAlloc{__a}};
1096  const value_type* __wfirst = __str.data();
1097  const value_type* __wlast = __wfirst + __str.size();
1098  if (__str_codecvt_out_all(__wfirst, __wlast, __u8str, __cvt)) {
1099  if constexpr (is_same_v<_CharT, char>)
1100  return __u8str; // XXX assumes native ordinary encoding is UTF-8.
1101  else {
1102 
1103  const char* __first = __u8str.data();
1104  const char* __last = __first + __u8str.size();
1105 #else
1106  const value_type* __first = __str.data();
1107  const value_type* __last = __first + __str.size();
1108 #endif
1109 
1110  // Convert UTF-8 string to requested format.
1111 #ifdef _GLIBCXX_USE_CHAR8_T
1112  if constexpr (is_same_v<_CharT, char8_t>)
1113  return _WString(__first, __last, __a);
1114  else
1115 #endif
1116  {
1117  // Convert UTF-8 to wide string.
1118  _WString __wstr(__a);
1119  struct _UCvt : std::codecvt<_CharT, char, std::mbstate_t> { } __cvt;
1120  if (__str_codecvt_in_all(__first, __last, __wstr, __cvt))
1121  return __wstr;
1122  }
1123 
1124 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1125  } }
1126 #endif
1127  __detail::__throw_conversion_error();
1128  }
1129  /// @endcond
1130 
1131  template<typename _CharT, typename _Traits, typename _Allocator>
1132  inline basic_string<_CharT, _Traits, _Allocator>
1133  path::string(const _Allocator& __a) const
1134  {
1135  if constexpr (is_same_v<_CharT, value_type>)
1136  return { _M_pathname.c_str(), _M_pathname.length(), __a };
1137  else
1138  return _S_str_convert<_CharT, _Traits>(_M_pathname, __a);
1139  }
1140 
1141  inline std::string
1142  path::string() const { return string<char>(); }
1143 
1144 #if _GLIBCXX_USE_WCHAR_T
1145  inline std::wstring
1146  path::wstring() const { return string<wchar_t>(); }
1147 #endif
1148 
1149 #ifdef _GLIBCXX_USE_CHAR8_T
1150  inline std::u8string
1151  path::u8string() const { return string<char8_t>(); }
1152 #else
1153  inline std::string
1154  path::u8string() const
1155  {
1156 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1157  std::string __str;
1158  // convert from native wide encoding (assumed to be UTF-16) to UTF-8
1159  std::codecvt_utf8_utf16<value_type> __cvt;
1160  const value_type* __first = _M_pathname.data();
1161  const value_type* __last = __first + _M_pathname.size();
1162  if (__str_codecvt_out_all(__first, __last, __str, __cvt))
1163  return __str;
1164  __detail::__throw_conversion_error();
1165 #else
1166  return _M_pathname;
1167 #endif
1168  }
1169 #endif // _GLIBCXX_USE_CHAR8_T
1170 
1171  inline std::u16string
1172  path::u16string() const { return string<char16_t>(); }
1173 
1174  inline std::u32string
1175  path::u32string() const { return string<char32_t>(); }
1176 
1177  template<typename _CharT, typename _Traits, typename _Allocator>
1179  path::generic_string(const _Allocator& __a) const
1180  {
1181 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1182  const value_type __slash = L'/';
1183 #else
1184  const value_type __slash = '/';
1185 #endif
1186  using _Alloc2 = typename allocator_traits<_Allocator>::template
1187  rebind_alloc<value_type>;
1188  basic_string<value_type, char_traits<value_type>, _Alloc2> __str(__a);
1189 
1190  if (_M_type() == _Type::_Root_dir)
1191  __str.assign(1, __slash);
1192  else
1193  {
1194  __str.reserve(_M_pathname.size());
1195  bool __add_slash = false;
1196  for (auto& __elem : *this)
1197  {
1198 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1199  if (__elem._M_type() == _Type::_Root_dir)
1200  {
1201  __str += __slash;
1202  continue;
1203  }
1204 #endif
1205  if (__add_slash)
1206  __str += __slash;
1207  __str += basic_string_view<value_type>(__elem._M_pathname);
1208  __add_slash = __elem._M_type() == _Type::_Filename;
1209  }
1210  }
1211 
1212  if constexpr (is_same_v<_CharT, value_type>)
1213  return __str;
1214  else
1215  return _S_str_convert<_CharT, _Traits>(__str, __a);
1216  }
1217 
1218  inline std::string
1219  path::generic_string() const
1220  { return generic_string<char>(); }
1221 
1222 #if _GLIBCXX_USE_WCHAR_T
1223  inline std::wstring
1224  path::generic_wstring() const
1225  { return generic_string<wchar_t>(); }
1226 #endif
1227 
1228 #ifdef _GLIBCXX_USE_CHAR8_T
1229  inline std::u8string
1230  path::generic_u8string() const
1231  { return generic_string<char8_t>(); }
1232 #else
1233  inline std::string
1234  path::generic_u8string() const
1235  { return generic_string(); }
1236 #endif
1237 
1238  inline std::u16string
1239  path::generic_u16string() const
1240  { return generic_string<char16_t>(); }
1241 
1242  inline std::u32string
1243  path::generic_u32string() const
1244  { return generic_string<char32_t>(); }
1245 
1246  inline int
1247  path::compare(const string_type& __s) const noexcept
1248  { return compare(basic_string_view<value_type>(__s)); }
1249 
1250  inline int
1251  path::compare(const value_type* __s) const noexcept
1252  { return compare(basic_string_view<value_type>(__s)); }
1253 
1254  inline path
1255  path::filename() const
1256  {
1257  if (empty())
1258  return {};
1259  else if (_M_type() == _Type::_Filename)
1260  return *this;
1261  else if (_M_type() == _Type::_Multi)
1262  {
1263  if (_M_pathname.back() == preferred_separator)
1264  return {};
1265  auto& __last = *--end();
1266  if (__last._M_type() == _Type::_Filename)
1267  return __last;
1268  }
1269  return {};
1270  }
1271 
1272  inline path
1273  path::stem() const
1274  {
1275  auto ext = _M_find_extension();
1276  if (ext.first && ext.second != 0)
1277  return path{ext.first->substr(0, ext.second)};
1278  return {};
1279  }
1280 
1281  inline path
1282  path::extension() const
1283  {
1284  auto ext = _M_find_extension();
1285  if (ext.first && ext.second != string_type::npos)
1286  return path{ext.first->substr(ext.second)};
1287  return {};
1288  }
1289 
1290  inline bool
1291  path::has_stem() const noexcept
1292  {
1293  auto ext = _M_find_extension();
1294  return ext.first && ext.second != 0;
1295  }
1296 
1297  inline bool
1298  path::has_extension() const noexcept
1299  {
1300  auto ext = _M_find_extension();
1301  return ext.first && ext.second != string_type::npos;
1302  }
1303 
1304  inline bool
1305  path::is_absolute() const noexcept
1306  {
1307 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1308  return has_root_name() && has_root_directory();
1309 #else
1310  return has_root_directory();
1311 #endif
1312  }
1313 
1314  inline path::iterator
1315  path::begin() const noexcept
1316  {
1317  if (_M_type() == _Type::_Multi)
1318  return iterator(this, _M_cmpts.begin());
1319  return iterator(this, empty());
1320  }
1321 
1322  inline path::iterator
1323  path::end() const noexcept
1324  {
1325  if (_M_type() == _Type::_Multi)
1326  return iterator(this, _M_cmpts.end());
1327  return iterator(this, true);
1328  }
1329 
1330  inline path::iterator&
1331  path::iterator::operator++() noexcept
1332  {
1333  __glibcxx_assert(_M_path != nullptr);
1334  if (_M_is_multi())
1335  {
1336  __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1337  ++_M_cur;
1338  }
1339  else
1340  {
1341  __glibcxx_assert(!_M_at_end);
1342  _M_at_end = true;
1343  }
1344  return *this;
1345  }
1346 
1347  inline path::iterator&
1348  path::iterator::operator--() noexcept
1349  {
1350  __glibcxx_assert(_M_path != nullptr);
1351  if (_M_is_multi())
1352  {
1353  __glibcxx_assert(_M_cur != _M_path->_M_cmpts.begin());
1354  --_M_cur;
1355  }
1356  else
1357  {
1358  __glibcxx_assert(_M_at_end);
1359  _M_at_end = false;
1360  }
1361  return *this;
1362  }
1363 
1364  inline path::iterator::reference
1365  path::iterator::operator*() const noexcept
1366  {
1367  __glibcxx_assert(_M_path != nullptr);
1368  if (_M_is_multi())
1369  {
1370  __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1371  return *_M_cur;
1372  }
1373  return *_M_path;
1374  }
1375 
1376  inline bool
1377  path::iterator::_M_equals(iterator __rhs) const noexcept
1378  {
1379  if (_M_path != __rhs._M_path)
1380  return false;
1381  if (_M_path == nullptr)
1382  return true;
1383  if (_M_is_multi())
1384  return _M_cur == __rhs._M_cur;
1385  return _M_at_end == __rhs._M_at_end;
1386  }
1387 
1388  // Define this now that path and path::iterator are complete.
1389  // It needs to consider the string_view(Range&&) constructor during
1390  // overload resolution, which depends on whether range<path> is satisfied,
1391  // which depends on whether path::iterator is complete.
1392  inline int
1393  path::_S_compare(const path& __lhs, const path& __rhs) noexcept
1394  { return __lhs.compare(__rhs); }
1395 
1396  /// @} group filesystem
1397 _GLIBCXX_END_NAMESPACE_CXX11
1398 } // namespace filesystem
1399 
1400 /// @cond undocumented
1401 
1402 inline ptrdiff_t
1403 distance(filesystem::path::iterator __first, filesystem::path::iterator __last)
1404 noexcept
1405 { return __path_iter_distance(__first, __last); }
1406 
1407 template<typename _Distance>
1408  inline void
1409  advance(filesystem::path::iterator& __i, _Distance __n) noexcept
1410  { __path_iter_advance(__i, static_cast<ptrdiff_t>(__n)); }
1411 
1412 extern template class __shared_ptr<const filesystem::filesystem_error::_Impl>;
1413 
1414 /// @endcond
1415 
1416 _GLIBCXX_END_NAMESPACE_VERSION
1417 } // namespace std
1418 
1419 #endif // C++17
1420 
1421 #endif // _GLIBCXX_FS_PATH_H
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Definition: complex:392
path u8path(_InputIterator __first, _InputIterator __last)
Definition: bits/fs_path.h:814
path u8path(const _Source &__source)
Definition: bits/fs_path.h:836
integral_constant< bool, __v > bool_constant
Alias template for compile-time boolean constant types.
Definition: type_traits:98
void void_t
A metafunction that always yields void, used for detecting valid types.
Definition: type_traits:2636
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
Definition: type_traits:85
typename enable_if< _Cond, _Tp >::type enable_if_t
Alias template for enable_if.
Definition: type_traits:2614
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition: move.h:49
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition: move.h:104
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
Definition: any:429
_Tp * end(valarray< _Tp > &__va) noexcept
Return an iterator pointing to one past the last element of the valarray.
Definition: valarray:1237
ISO C++ entities toplevel namespace is std.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
constexpr auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())
Return whether a container is empty.
Definition: range_access.h:283
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
Definition: range_access.h:264
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
auto quoted(const _CharT *__string, _CharT __delim=_CharT('"'), _CharT __escape = _CharT('\\'))
Manipulator for quoted strings.
Definition: iomanip:461
Template class basic_istream.
Definition: istream:59
Template class basic_ostream.
Definition: ostream:59
A non-owning reference to a string.
Definition: string_view:101
An exception type that includes an error_code value.
Definition: system_error:447
Primary class template codecvt.
Definition: codecvt.h:279
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
Definition: cow_string.h:2203
void reserve(size_type __res_arg)
Attempt to preallocate enough memory for specified number of characters.
Definition: cow_string.h:3416
basic_string & assign(const basic_string &__str)
Set value to contents of another string.
Definition: cow_string.h:3157
const _CharT * data() const noexcept
Return const pointer to contents.
Definition: cow_string.h:2215
void clear() noexcept
Definition: cow_string.h:1001
bool empty() const noexcept
Definition: cow_string.h:1023
Traits class for iterators.
A filesystem path.
Definition: bits/fs_path.h:294
friend bool operator!=(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:570
friend bool operator<=(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:578
friend bool operator>(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:582
friend path operator/(const path &__lhs, const path &__rhs)
Append one path to another.
Definition: bits/fs_path.h:591
format
path::format is ignored in this implementation
Definition: bits/fs_path.h:311
friend bool operator>=(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:586
friend bool operator<(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:574
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
friend bool operator==(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Definition: bits/fs_path.h:560
Exception type thrown by the Filesystem library.
Definition: bits/fs_path.h:747
const char * what() const noexcept
An iterator for the components of a path.
Definition: bits/fs_path.h:916
Container class for localization functionality.
Bidirectional iterators support a superset of forward iterator operations.