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