30 #ifndef _GLIBCXX_FS_PATH_H
31 #define _GLIBCXX_FS_PATH_H 1
33 #if __cplusplus >= 201703L
46 #include <bits/shared_ptr.h>
49 #if __cplusplus > 201703L
53 #if defined(_WIN32) && !defined(__CYGWIN__)
54 # define _GLIBCXX_FILESYSTEM_IS_WINDOWS 1
58 namespace std _GLIBCXX_VISIBILITY(default)
60 _GLIBCXX_BEGIN_NAMESPACE_VERSION
64 _GLIBCXX_BEGIN_NAMESPACE_CXX11
73 template<
typename _CharT>
74 inline constexpr
bool __is_encoded_char =
false;
76 inline constexpr
bool __is_encoded_char<char> =
true;
77 #ifdef _GLIBCXX_USE_CHAR8_T
79 inline constexpr
bool __is_encoded_char<char8_t> =
true;
81 #if _GLIBCXX_USE_WCHAR_T
83 inline constexpr
bool __is_encoded_char<wchar_t> =
true;
86 inline constexpr
bool __is_encoded_char<char16_t> =
true;
88 inline constexpr
bool __is_encoded_char<char32_t> =
true;
90 #if __cpp_concepts >= 201907L
91 template<
typename _Iter>
94 template<
typename _Iter>
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*> { };
105 template<
typename _Iter_traits,
typename =
void>
106 struct __is_path_iter_src
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>>
116 template<
typename _Source>
117 inline constexpr
bool __is_path_src
118 = __is_path_iter_src<iterator_traits<decay_t<_Source>>>::value;
121 inline constexpr
bool __is_path_src<path> =
false;
124 inline constexpr
bool __is_path_src<volatile path> =
false;
127 inline constexpr
bool __is_path_src<void*> =
false;
130 inline constexpr
bool __is_path_src<const void*> =
false;
133 inline constexpr
bool __is_path_src<volatile void*> =
false;
136 inline constexpr
bool __is_path_src<const volatile void*> =
false;
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>;
143 template<
typename _CharT,
typename _Traits>
144 inline constexpr
bool
145 __is_path_src<basic_string_view<_CharT, _Traits>>
146 = __is_encoded_char<_CharT>;
149 template<
typename _Tp>
150 using _Path = enable_if_t<__is_path_src<_Tp>, path>;
153 template<
typename _Iter,
typename _Tr = __safe_iterator_traits<_Iter>>
154 using _Path2 = enable_if_t<__is_path_iter_src<_Tr>::value, path>;
156 #if __cpp_lib_concepts
157 template<
typename _Iter>
158 constexpr
bool __is_contiguous = std::contiguous_iterator<_Iter>;
160 template<
typename _Iter>
161 constexpr
bool __is_contiguous =
false;
164 template<
typename _Tp>
165 constexpr
bool __is_contiguous<_Tp*> =
true;
167 template<
typename _Tp,
typename _Seq>
169 __is_contiguous<__gnu_cxx::__normal_iterator<_Tp*, _Seq>> =
true;
171 #if !defined _GLIBCXX_FILESYSTEM_IS_WINDOWS && defined _GLIBCXX_USE_CHAR8_T
173 template<
typename _E
charT>
175 = __conditional_t<is_same_v<_EcharT, char8_t>, char, _EcharT>;
177 template<
typename _E
charT>
178 using __unified_u8_t = _EcharT;
185 template<
typename _CharT,
typename _Traits,
typename _Alloc>
186 inline basic_string_view<_CharT>
187 __effective_range(
const basic_string<_CharT, _Traits, _Alloc>& __source)
191 template<
typename _CharT,
typename _Traits>
192 inline basic_string_view<_CharT>
193 __effective_range(
const basic_string_view<_CharT, _Traits>& __source)
198 template<
typename _Source>
200 __effective_range(
const _Source& __source)
203 using _Iter = decltype(std::__niter_base(__source));
204 using value_type =
typename iterator_traits<_Iter>::value_type;
206 if constexpr (__is_contiguous<_Iter>)
207 return basic_string_view<value_type>{&*__source};
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);
221 template<
typename _Source>
222 struct __source_value_type_impl
225 =
typename __safe_iterator_traits<decay_t<_Source>>::value_type;
228 template<
typename _CharT,
typename _Traits,
typename _Alloc>
229 struct __source_value_type_impl<basic_string<_CharT, _Traits, _Alloc>>
234 template<
typename _CharT,
typename _Traits>
235 struct __source_value_type_impl<basic_string_view<_CharT, _Traits>>
241 template<
typename _Source>
242 using __source_value_t =
typename __source_value_type_impl<_Source>::type;
247 template<
typename _Tp,
typename _Val = __source_value_t<_Tp>>
248 using __value_type_is_char
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>
262 template<
typename _InputIterator>
264 __string_from_range(_InputIterator __first, _InputIterator __last)
268 static_assert(__is_encoded_char<_EcharT>);
270 if constexpr (__is_contiguous<_InputIterator>)
273 if (
auto __len = __last - __first) [[__likely__]]
274 return basic_string_view<_EcharT>(&*__first, __len);
275 return basic_string_view<_EcharT>();
280 return basic_string<__unified_u8_t<_EcharT>>(__first, __last);
296 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
297 using value_type = wchar_t;
298 static constexpr value_type preferred_separator = L
'\\';
300 # ifdef _GLIBCXX_DOXYGEN
302 using value_type = __os_dependent__;
304 using value_type = char;
306 static constexpr value_type preferred_separator =
'/';
311 enum format :
unsigned char { native_format, generic_format, auto_format };
317 path(
const path& __p) =
default;
319 path(path&& __p) noexcept
320 : _M_pathname(
std::move(__p._M_pathname)),
324 path(string_type&& __source,
format = auto_format)
325 : _M_pathname(
std::
move(__source))
326 { _M_split_cmpts(); }
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(); }
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(); }
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(); }
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,
352 : _M_pathname(_S_convert_loc(__first, __last, __loc))
353 { _M_split_cmpts(); }
359 path& operator=(
const path&);
360 path& operator=(path&&) noexcept;
361 path& operator=(string_type&& __source);
362 path& assign(string_type&& __source);
364 template<typename _Source>
365 __detail::_Path<_Source>&
366 operator=(_Source const& __source)
367 {
return *
this = path(__source); }
369 template<
typename _Source>
370 __detail::_Path<_Source>&
371 assign(_Source
const& __source)
372 {
return *
this = path(__source); }
374 template<
typename _InputIterator>
375 __detail::_Path2<_InputIterator>&
376 assign(_InputIterator __first, _InputIterator __last)
377 {
return *
this = path(__first, __last); }
381 path& operator/=(
const path& __p);
383 template<
typename _Source>
384 __detail::_Path<_Source>&
385 operator/=(_Source
const& __source)
387 _M_append(_S_convert(__detail::__effective_range(__source)));
391 template<
typename _Source>
392 __detail::_Path<_Source>&
393 append(_Source
const& __source)
395 _M_append(_S_convert(__detail::__effective_range(__source)));
399 template<
typename _InputIterator>
400 __detail::_Path2<_InputIterator>&
401 append(_InputIterator __first, _InputIterator __last)
403 _M_append(_S_convert(__detail::__string_from_range(__first, __last)));
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);
415 template<
typename _Source>
416 __detail::_Path<_Source>&
417 operator+=(_Source
const& __x) {
return concat(__x); }
419 template<
typename _CharT>
420 __detail::_Path2<_CharT*>&
421 operator+=(_CharT __x);
423 template<
typename _Source>
424 __detail::_Path<_Source>&
425 concat(_Source
const& __x)
427 _M_concat(_S_convert(__detail::__effective_range(__x)));
431 template<
typename _InputIterator>
432 __detail::_Path2<_InputIterator>&
433 concat(_InputIterator __first, _InputIterator __last)
435 _M_concat(_S_convert(__detail::__string_from_range(__first, __last)));
441 void clear() noexcept { _M_pathname.
clear(); _M_split_cmpts(); }
443 path& make_preferred();
444 path& remove_filename();
445 path& replace_filename(
const path& __replacement);
446 path& replace_extension(
const path& __replacement = path());
448 void swap(path& __rhs) noexcept;
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; }
456 template<
typename _CharT,
typename _Traits = std::
char_traits<_CharT>,
457 typename _Allocator = std::allocator<_CharT>>
459 string(
const _Allocator& __a = _Allocator())
const;
462 #if _GLIBCXX_USE_WCHAR_T
465 #ifdef _GLIBCXX_USE_CHAR8_T
466 __attribute__((__abi_tag__(
"__u8")))
467 std::u8string u8string() const;
475 template<
typename _CharT,
typename _Traits = std::
char_traits<_CharT>,
476 typename _Allocator = std::allocator<_CharT>>
478 generic_string(
const _Allocator& __a = _Allocator())
const;
481 #if _GLIBCXX_USE_WCHAR_T
484 #ifdef _GLIBCXX_USE_CHAR8_T
485 __attribute__((__abi_tag__(
"__u8")))
486 std::u8string generic_u8string() const;
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;
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;
509 path extension()
const;
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(); }
526 path lexically_normal()
const;
527 path lexically_relative(
const path& base)
const;
528 path lexically_proximate(
const path& base)
const;
532 using const_iterator = iterator;
534 iterator begin() const noexcept;
535 iterator end() const noexcept;
538 template<typename _CharT, typename _Traits>
542 __os <<
std::quoted(__p.string<_CharT, _Traits>());
547 template<
typename _CharT,
typename _Traits>
561 {
return path::_S_compare(__lhs, __rhs) == 0; }
563 #if __cpp_lib_three_way_comparison
565 friend strong_ordering
566 operator<=>(
const path& __lhs,
const path& __rhs) noexcept
567 {
return path::_S_compare(__lhs, __rhs) <=> 0; }
571 {
return !(__lhs == __rhs); }
575 {
return __lhs.compare(__rhs) < 0; }
579 {
return !(__rhs < __lhs); }
583 {
return __rhs < __lhs; }
587 {
return !(__lhs < __rhs); }
593 path __result(__lhs);
599 enum class _Type : unsigned char {
600 _Multi = 0, _Root_name, _Root_dir, _Filename
606 __glibcxx_assert(__type != _Type::_Multi);
607 _M_cmpts.type(__type);
610 enum class _Split { _Stem, _Extension };
612 void _M_append(basic_string_view<value_type>);
613 void _M_concat(basic_string_view<value_type>);
615 pair<const string_type*, size_t> _M_find_extension() const noexcept;
621 template<typename _Tp>
623 _S_convert(_Tp __str)
624 noexcept(is_same_v<typename _Tp::value_type, value_type>)
626 if constexpr (is_same_v<typename _Tp::value_type, value_type>)
628 #if !defined _GLIBCXX_FILESYSTEM_IS_WINDOWS && defined _GLIBCXX_USE_CHAR8_T
629 else if constexpr (is_same_v<_Tp, std::u8string>)
633 return string_type(_S_convert(__str.data(),
634 __str.data() + __str.size()));
637 return _S_convert(__str.data(), __str.data() + __str.size());
640 template<
typename _E
charT>
642 _S_convert(
const _EcharT* __first,
const _EcharT* __last);
648 _S_convert_loc(
const char* __first,
const char* __last,
651 template<
typename _Iter>
653 _S_convert_loc(_Iter __first, _Iter __last,
const std::locale& __loc)
655 const auto __s = __detail::__string_from_range(__first, __last);
656 return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc);
659 template<
typename _Tp>
661 _S_convert_loc(
const _Tp& __s,
const std::locale& __loc)
663 return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc);
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&);
671 __attribute__((__always_inline__))
673 _S_compare(
const path& __lhs,
const path& __rhs) noexcept;
675 void _M_split_cmpts();
677 _Type _M_type() const noexcept {
return _M_cmpts.type(); }
679 string_type _M_pathname;
685 using value_type = _Cmpt;
686 using iterator = value_type*;
687 using const_iterator =
const value_type*;
691 _List(_List&&) =
default;
692 _List& operator=(
const _List&);
693 _List& operator=(_List&&) =
default;
696 _Type type() const noexcept
697 {
return _Type(
reinterpret_cast<uintptr_t
>(_M_impl.get()) & 0x3); }
699 void type(_Type) noexcept;
701 int size() const noexcept;
702 bool empty() const noexcept;
704 void swap(_List& __l) noexcept { _M_impl.swap(__l._M_impl); }
705 int capacity() const noexcept;
706 void reserve(
int,
bool);
711 iterator begin() noexcept;
712 iterator end() noexcept;
713 const_iterator begin() const noexcept;
714 const_iterator end() const noexcept;
716 value_type& front() noexcept;
717 value_type& back() noexcept;
718 const value_type& front() const noexcept;
719 const value_type& back() const noexcept;
722 void _M_erase_from(const_iterator __pos);
727 void operator()(_Impl*)
const noexcept;
729 unique_ptr<_Impl, _Impl_deleter> _M_impl;
739 inline void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); }
741 size_t hash_value(
const path& __p) noexcept;
765 const path& path1()
const noexcept;
766 const path& path2()
const noexcept;
767 const char*
what() const noexcept;
771 std::__shared_ptr<const _Impl> _M_impl;
777 [[noreturn]]
inline void
778 __throw_conversion_error()
781 "Cannot convert character sequence",
782 std::make_error_code(errc::illegal_byte_sequence)));
785 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
786 template<
typename _Tp>
788 __wstr_from_utf8(
const _Tp& __str)
790 static_assert(std::is_same_v<typename _Tp::value_type, char>);
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();
809 template<
typename _InputIterator,
810 typename _Require = __detail::_Path2<_InputIterator>,
812 = __detail::__value_type_is_char_or_char8_t<_InputIterator>>
814 u8path(_InputIterator __first, _InputIterator __last)
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)) };
821 return path{ __first, __last };
824 return path{ __first, __last };
832 template<
typename _Source,
833 typename _Require = __detail::_Path<_Source>,
834 typename _CharT = __detail::__value_type_is_char_or_char8_t<_Source>>
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)) };
843 return path{ __source };
846 return path{ __source };
852 struct path::_Cmpt :
path
855 :
path(__s, __t), _M_pos(__pos) { }
857 _Cmpt() : _M_pos(-1) { }
862 template<
typename _E
charT>
864 path::_S_convert(
const _EcharT* __f,
const _EcharT* __l)
866 static_assert(__detail::__is_encoded_char<_EcharT>);
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>)
873 return string_view(
reinterpret_cast<const char*
>(__f), __l - __f);
877 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
879 if constexpr (is_same_v<_EcharT, char>)
881 struct _UCvt :
std::codecvt<wchar_t, char, std::mbstate_t>
883 if (__str_codecvt_in_all(__f, __l, __wstr, __cvt))
886 #ifdef _GLIBCXX_USE_CHAR8_T
887 else if constexpr (is_same_v<_EcharT, char8_t>)
889 const auto __f2 =
reinterpret_cast<const char*
>(__f);
890 return __detail::__wstr_from_utf8(string_view(__f2, __l - __f));
895 struct _UCvt :
std::codecvt<_EcharT, char, std::mbstate_t>
898 if (__str_codecvt_out_all(__f, __l, __str, __cvt))
899 return __detail::__wstr_from_utf8(__str);
902 struct _UCvt :
std::codecvt<_EcharT, char, std::mbstate_t>
905 if (__str_codecvt_out_all(__f, __l, __str, __cvt))
908 __detail::__throw_conversion_error();
918 using difference_type = std::ptrdiff_t;
924 iterator() noexcept : _M_path(
nullptr), _M_cur(), _M_at_end() { }
935 {
auto __tmp = *
this; ++*
this;
return __tmp; }
940 {
auto __tmp = *
this; --*
this;
return __tmp; }
944 {
return __lhs._M_equals(__rhs); }
948 {
return !__lhs._M_equals(__rhs); }
954 _M_is_multi()
const noexcept
955 {
return _M_path->_M_type() == _Type::_Multi; }
957 friend difference_type
961 __glibcxx_assert(__first._M_path !=
nullptr);
962 __glibcxx_assert(__first._M_path == __last._M_path);
963 if (__first._M_is_multi())
965 else if (__first._M_at_end == __last._M_at_end)
968 return __first._M_at_end ? -1 : 1;
972 __path_iter_advance(
iterator& __i, difference_type __n) noexcept
980 __glibcxx_assert(__i._M_path !=
nullptr);
981 __glibcxx_assert(__i._M_is_multi());
987 iterator(
const path* __path, path::_List::const_iterator __iter) noexcept
988 : _M_path(__path), _M_cur(__iter), _M_at_end()
992 : _M_path(__path), _M_cur(), _M_at_end(__at_end)
995 bool _M_equals(
iterator)
const noexcept;
998 path::_List::const_iterator _M_cur;
1004 path::operator=(
path&& __p) noexcept
1006 if (&__p ==
this) [[__unlikely__]]
1009 _M_pathname =
std::move(__p._M_pathname);
1016 path::operator=(string_type&& __source)
1020 path::assign(string_type&& __source)
1021 {
return *
this = path(
std::move(__source)); }
1024 path::operator+=(
const string_type& __x)
1031 path::operator+=(
const value_type* __x)
1038 path::operator+=(value_type __x)
1040 _M_concat(basic_string_view<value_type>(&__x, 1));
1045 path::operator+=(basic_string_view<value_type> __x)
1051 template<
typename _CharT>
1052 inline __detail::_Path2<_CharT*>&
1053 path::operator+=(
const _CharT __x)
1055 _M_concat(_S_convert(&__x, &__x + 1));
1060 path::make_preferred()
1062 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1063 std::replace(_M_pathname.begin(), _M_pathname.end(), L
'/',
1064 preferred_separator);
1069 inline void path::swap(path& __rhs) noexcept
1071 _M_pathname.swap(__rhs._M_pathname);
1072 _M_cmpts.swap(__rhs._M_cmpts);
1076 template<
typename _CharT,
typename _Traits,
typename _Allocator>
1078 path::_S_str_convert(basic_string_view<value_type> __str,
1079 const _Allocator& __a)
1081 static_assert(!is_same_v<_CharT, value_type>);
1083 using _WString = basic_string<_CharT, _Traits, _Allocator>;
1085 if (__str.size() == 0)
1086 return _WString(__a);
1088 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1091 std::codecvt_utf8_utf16<value_type> __cvt;
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>)
1103 const char* __first = __u8str.data();
1104 const char* __last = __first + __u8str.size();
1106 const value_type* __first = __str.data();
1107 const value_type* __last = __first + __str.size();
1111 #ifdef _GLIBCXX_USE_CHAR8_T
1112 if constexpr (is_same_v<_CharT, char8_t>)
1113 return _WString(__first, __last, __a);
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))
1124 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1127 __detail::__throw_conversion_error();
1131 template<
typename _CharT,
typename _Traits,
typename _Allocator>
1132 inline basic_string<_CharT, _Traits, _Allocator>
1133 path::string(
const _Allocator& __a)
const
1135 if constexpr (is_same_v<_CharT, value_type>)
1136 return { _M_pathname.c_str(), _M_pathname.length(), __a };
1138 return _S_str_convert<_CharT, _Traits>(_M_pathname, __a);
1142 path::string()
const {
return string<char>(); }
1144 #if _GLIBCXX_USE_WCHAR_T
1146 path::wstring()
const {
return string<wchar_t>(); }
1149 #ifdef _GLIBCXX_USE_CHAR8_T
1150 inline std::u8string
1151 path::u8string()
const {
return string<char8_t>(); }
1154 path::u8string()
const
1156 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
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))
1164 __detail::__throw_conversion_error();
1172 path::u16string()
const {
return string<char16_t>(); }
1175 path::u32string()
const {
return string<char32_t>(); }
1177 template<
typename _CharT,
typename _Traits,
typename _Allocator>
1179 path::generic_string(
const _Allocator& __a)
const
1181 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1182 const value_type __slash = L
'/';
1184 const value_type __slash =
'/';
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);
1190 if (_M_type() == _Type::_Root_dir)
1191 __str.
assign(1, __slash);
1194 __str.
reserve(_M_pathname.size());
1195 bool __add_slash =
false;
1196 for (
auto& __elem : *
this)
1198 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1199 if (__elem._M_type() == _Type::_Root_dir)
1207 __str += basic_string_view<value_type>(__elem._M_pathname);
1208 __add_slash = __elem._M_type() == _Type::_Filename;
1212 if constexpr (is_same_v<_CharT, value_type>)
1215 return _S_str_convert<_CharT, _Traits>(__str, __a);
1219 path::generic_string()
const
1220 {
return generic_string<char>(); }
1222 #if _GLIBCXX_USE_WCHAR_T
1224 path::generic_wstring()
const
1225 {
return generic_string<wchar_t>(); }
1228 #ifdef _GLIBCXX_USE_CHAR8_T
1229 inline std::u8string
1230 path::generic_u8string()
const
1231 {
return generic_string<char8_t>(); }
1234 path::generic_u8string()
const
1235 {
return generic_string(); }
1239 path::generic_u16string()
const
1240 {
return generic_string<char16_t>(); }
1243 path::generic_u32string()
const
1244 {
return generic_string<char32_t>(); }
1247 path::compare(
const string_type& __s)
const noexcept
1248 {
return compare(basic_string_view<value_type>(__s)); }
1251 path::compare(
const value_type* __s)
const noexcept
1252 {
return compare(basic_string_view<value_type>(__s)); }
1255 path::filename()
const
1259 else if (_M_type() == _Type::_Filename)
1261 else if (_M_type() == _Type::_Multi)
1263 if (_M_pathname.back() == preferred_separator)
1265 auto& __last = *--
end();
1266 if (__last._M_type() == _Type::_Filename)
1275 auto ext = _M_find_extension();
1276 if (ext.first && ext.second != 0)
1277 return path{ext.first->substr(0, ext.second)};
1282 path::extension()
const
1284 auto ext = _M_find_extension();
1285 if (ext.first && ext.second != string_type::npos)
1286 return path{ext.first->substr(ext.second)};
1291 path::has_stem() const noexcept
1293 auto ext = _M_find_extension();
1294 return ext.first && ext.second != 0;
1298 path::has_extension() const noexcept
1300 auto ext = _M_find_extension();
1301 return ext.first && ext.second != string_type::npos;
1305 path::is_absolute() const noexcept
1307 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1308 return has_root_name() && has_root_directory();
1310 return has_root_directory();
1314 inline path::iterator
1315 path::begin() const noexcept
1317 if (_M_type() == _Type::_Multi)
1318 return iterator(
this, _M_cmpts.begin());
1319 return iterator(
this,
empty());
1322 inline path::iterator
1323 path::end() const noexcept
1325 if (_M_type() == _Type::_Multi)
1326 return iterator(
this, _M_cmpts.end());
1327 return iterator(
this,
true);
1330 inline path::iterator&
1331 path::iterator::operator++() noexcept
1333 __glibcxx_assert(_M_path !=
nullptr);
1336 __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1341 __glibcxx_assert(!_M_at_end);
1347 inline path::iterator&
1348 path::iterator::operator--() noexcept
1350 __glibcxx_assert(_M_path !=
nullptr);
1353 __glibcxx_assert(_M_cur != _M_path->_M_cmpts.begin());
1358 __glibcxx_assert(_M_at_end);
1364 inline path::iterator::reference
1365 path::iterator::operator*() const noexcept
1367 __glibcxx_assert(_M_path !=
nullptr);
1370 __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1377 path::iterator::_M_equals(iterator __rhs)
const noexcept
1379 if (_M_path != __rhs._M_path)
1381 if (_M_path ==
nullptr)
1384 return _M_cur == __rhs._M_cur;
1385 return _M_at_end == __rhs._M_at_end;
1393 path::_S_compare(
const path& __lhs,
const path& __rhs) noexcept
1394 {
return __lhs.compare(__rhs); }
1397 _GLIBCXX_END_NAMESPACE_CXX11
1403 distance(filesystem::path::iterator __first, filesystem::path::iterator __last)
1405 {
return __path_iter_distance(__first, __last); }
1407 template<
typename _Distance>
1409 advance(filesystem::path::iterator& __i, _Distance __n) noexcept
1410 { __path_iter_advance(__i,
static_cast<ptrdiff_t
>(__n)); }
1412 extern template class __shared_ptr<const filesystem::filesystem_error::_Impl>;
1416 _GLIBCXX_END_NAMESPACE_VERSION
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
path u8path(_InputIterator __first, _InputIterator __last)
path u8path(const _Source &__source)
integral_constant< bool, __v > bool_constant
Alias template for compile-time boolean constant types.
void void_t
A metafunction that always yields void, used for detecting valid types.
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
typename enable_if< _Cond, _Tp >::type enable_if_t
Alias template for enable_if.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
_Tp * end(valarray< _Tp > &__va) noexcept
Return an iterator pointing to one past the last element of the valarray.
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.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
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.
Template class basic_istream.
Template class basic_ostream.
A non-owning reference to a string.
An exception type that includes an error_code value.
Primary class template codecvt.
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
void reserve(size_type __res_arg)
Attempt to preallocate enough memory for specified number of characters.
basic_string & assign(const basic_string &__str)
Set value to contents of another string.
const _CharT * data() const noexcept
Return const pointer to contents.
bool empty() const noexcept
Traits class for iterators.
friend bool operator!=(const path &__lhs, const path &__rhs) noexcept
Compare paths.
friend bool operator<=(const path &__lhs, const path &__rhs) noexcept
Compare paths.
friend bool operator>(const path &__lhs, const path &__rhs) noexcept
Compare paths.
friend path operator/(const path &__lhs, const path &__rhs)
Append one path to another.
format
path::format is ignored in this implementation
friend bool operator>=(const path &__lhs, const path &__rhs) noexcept
Compare paths.
friend bool operator<(const path &__lhs, const path &__rhs) noexcept
Compare paths.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, path &__p)
Read a path from a stream.
friend bool operator==(const path &__lhs, const path &__rhs) noexcept
Compare paths.
Exception type thrown by the Filesystem library.
const char * what() const noexcept
An iterator for the components of a path.
Container class for localization functionality.
Bidirectional iterators support a superset of forward iterator operations.