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