libstdc++-v3/include/bits/fs_path.h

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