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

   1 // Class filesystem::path -*- C++ -*-
   2
   3 // Copyright (C) 2014-2018 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 <vector>
  38 #include <locale>
  39 #include <iosfwd>
  40 #include <iomanip>
  41 #include <codecvt>
  42 #include <string_view>
  43 #include <system_error>
  44 #include <bits/stl_algobase.h>
  45 #include <bits/locale_conv.h>
  46 #include <ext/concurrence.h>
  47 #include <bits/shared_ptr.h>
  48
  49 #if defined(_WIN32) && !defined(__CYGWIN__)
  50 # define _GLIBCXX_FILESYSTEM_IS_WINDOWS 1
  51 # include <algorithm>
  52 #endif
  53
  54 namespace std _GLIBCXX_VISIBILITY(default)
  55 {
  56 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  57
  58 namespace filesystem
  59 {
  60 _GLIBCXX_BEGIN_NAMESPACE_CXX11
  61
  62   /**
  63    * @ingroup filesystem
  64    * @{
  65    */
  66
  67   /// A filesystem path.
  68   class path
  69   {
  70     template<typename _CharT, typename _Ch = remove_const_t<_CharT>>
  71       using __is_encoded_char
  72         = __or_<is_same<_Ch, char>, is_same<_Ch, wchar_t>,
  73                 is_same<_Ch, char16_t>, is_same<_Ch, char32_t>>;
  74
  75     template<typename _Iter,
  76              typename _Iter_traits = std::iterator_traits<_Iter>>
  77       using __is_path_iter_src
  78         = __and_<__is_encoded_char<typename _Iter_traits::value_type>,
  79                  std::is_base_of<std::input_iterator_tag,
  80                                  typename _Iter_traits::iterator_category>>;
  81
  82     template<typename _Iter>
  83       static __is_path_iter_src<_Iter>
  84       __is_path_src(_Iter, int);
  85
  86     template<typename _CharT, typename _Traits, typename _Alloc>
  87       static __is_encoded_char<_CharT>
  88       __is_path_src(const basic_string<_CharT, _Traits, _Alloc>&, int);
  89
  90     template<typename _CharT, typename _Traits>
  91       static __is_encoded_char<_CharT>
  92       __is_path_src(const basic_string_view<_CharT, _Traits>&, int);
  93
  94     template<typename _Unknown>
  95       static std::false_type
  96       __is_path_src(const _Unknown&, ...);
  97
  98     template<typename _Tp1, typename _Tp2>
  99       struct __constructible_from;
 100
 101     template<typename _Iter>
 102       struct __constructible_from<_Iter, _Iter>
 103       : __is_path_iter_src<_Iter>
 104       { };
 105
 106     template<typename _Source>
 107       struct __constructible_from<_Source, void>
 108       : decltype(__is_path_src(std::declval<_Source>(), 0))
 109       { };
 110
 111     template<typename _Tp1, typename _Tp2 = void>
 112       using _Path = typename
 113         std::enable_if<__and_<__not_<is_same<_Tp1, path>>,
 114                               __constructible_from<_Tp1, _Tp2>>::value,
 115                        path>::type;
 116
 117     template<typename _Source>
 118       static _Source
 119       _S_range_begin(_Source __begin) { return __begin; }
 120
 121     struct __null_terminated { };
 122
 123     template<typename _Source>
 124       static __null_terminated
 125       _S_range_end(_Source) { return {}; }
 126
 127     template<typename _CharT, typename _Traits, typename _Alloc>
 128       static const _CharT*
 129       _S_range_begin(const basic_string<_CharT, _Traits, _Alloc>& __str)
 130       { return __str.data(); }
 131
 132     template<typename _CharT, typename _Traits, typename _Alloc>
 133       static const _CharT*
 134       _S_range_end(const basic_string<_CharT, _Traits, _Alloc>& __str)
 135       { return __str.data() + __str.size(); }
 136
 137     template<typename _CharT, typename _Traits>
 138       static const _CharT*
 139       _S_range_begin(const basic_string_view<_CharT, _Traits>& __str)
 140       { return __str.data(); }
 141
 142     template<typename _CharT, typename _Traits>
 143       static const _CharT*
 144       _S_range_end(const basic_string_view<_CharT, _Traits>& __str)
 145       { return __str.data() + __str.size(); }
 146
 147     template<typename _Tp,
 148              typename _Iter = decltype(_S_range_begin(std::declval<_Tp>())),
 149              typename _Val = typename std::iterator_traits<_Iter>::value_type>
 150       using __value_type_is_char
 151         = std::enable_if_t<std::is_same_v<std::remove_const_t<_Val>, char>>;
 152
 153   public:
 154 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 155     typedef wchar_t                             value_type;
 156     static constexpr value_type                 preferred_separator = L'\\';
 157 #else
 158     typedef char                                value_type;
 159     static constexpr value_type                 preferred_separator = '/';
 160 #endif
 161     typedef std::basic_string<value_type>       string_type;
 162
 163     enum format { native_format, generic_format, auto_format };
 164
 165     // constructors and destructor
 166
 167     path() noexcept { }
 168
 169     path(const path& __p) = default;
 170
 171     path(path&& __p) noexcept
 172     : _M_pathname(std::move(__p._M_pathname)), _M_type(__p._M_type)
 173     {
 174       _M_split_cmpts();
 175       __p.clear();
 176     }
 177
 178     path(string_type&& __source, format = auto_format)
 179     : _M_pathname(std::move(__source))
 180     { _M_split_cmpts(); }
 181
 182     template<typename _Source,
 183              typename _Require = _Path<_Source>>
 184       path(_Source const& __source, format = auto_format)
 185       : _M_pathname(_S_convert(_S_range_begin(__source),
 186                                _S_range_end(__source)))
 187       { _M_split_cmpts(); }
 188
 189     template<typename _InputIterator,
 190              typename _Require = _Path<_InputIterator, _InputIterator>>
 191       path(_InputIterator __first, _InputIterator __last, format = auto_format)
 192       : _M_pathname(_S_convert(__first, __last))
 193       { _M_split_cmpts(); }
 194
 195     template<typename _Source,
 196              typename _Require = _Path<_Source>,
 197              typename _Require2 = __value_type_is_char<_Source>>
 198       path(_Source const& __source, const locale& __loc, format = auto_format)
 199       : _M_pathname(_S_convert_loc(_S_range_begin(__source),
 200                                    _S_range_end(__source), __loc))
 201       { _M_split_cmpts(); }
 202
 203     template<typename _InputIterator,
 204              typename _Require = _Path<_InputIterator, _InputIterator>,
 205              typename _Require2 = __value_type_is_char<_InputIterator>>
 206       path(_InputIterator __first, _InputIterator __last, const locale& __loc,
 207            format = auto_format)
 208       : _M_pathname(_S_convert_loc(__first, __last, __loc))
 209       { _M_split_cmpts(); }
 210
 211     ~path() = default;
 212
 213     // assignments
 214
 215     path& operator=(const path& __p) = default;
 216     path& operator=(path&& __p) noexcept;
 217     path& operator=(string_type&& __source);
 218     path& assign(string_type&& __source);
 219
 220     template<typename _Source>
 221       _Path<_Source>&
 222       operator=(_Source const& __source)
 223       { return *this = path(__source); }
 224
 225     template<typename _Source>
 226       _Path<_Source>&
 227       assign(_Source const& __source)
 228       { return *this = path(__source); }
 229
 230     template<typename _InputIterator>
 231       _Path<_InputIterator, _InputIterator>&
 232       assign(_InputIterator __first, _InputIterator __last)
 233       { return *this = path(__first, __last); }
 234
 235     // appends
 236
 237     path& operator/=(const path& __p);
 238
 239     template <class _Source>
 240       _Path<_Source>&
 241       operator/=(_Source const& __source)
 242       { return _M_append(path(__source)); }
 243
 244     template<typename _Source>
 245       _Path<_Source>&
 246       append(_Source const& __source)
 247       { return _M_append(path(__source)); }
 248
 249     template<typename _InputIterator>
 250       _Path<_InputIterator, _InputIterator>&
 251       append(_InputIterator __first, _InputIterator __last)
 252       { return _M_append(path(__first, __last)); }
 253
 254     // concatenation
 255
 256     path& operator+=(const path& __x);
 257     path& operator+=(const string_type& __x);
 258     path& operator+=(const value_type* __x);
 259     path& operator+=(value_type __x);
 260     path& operator+=(basic_string_view<value_type> __x);
 261
 262     template<typename _Source>
 263       _Path<_Source>&
 264       operator+=(_Source const& __x) { return concat(__x); }
 265
 266     template<typename _CharT>
 267       _Path<_CharT*, _CharT*>&
 268       operator+=(_CharT __x);
 269
 270     template<typename _Source>
 271       _Path<_Source>&
 272       concat(_Source const& __x)
 273       { return *this += _S_convert(_S_range_begin(__x), _S_range_end(__x)); }
 274
 275     template<typename _InputIterator>
 276       _Path<_InputIterator, _InputIterator>&
 277       concat(_InputIterator __first, _InputIterator __last)
 278       { return *this += _S_convert(__first, __last); }
 279
 280     // modifiers
 281
 282     void clear() noexcept { _M_pathname.clear(); _M_split_cmpts(); }
 283
 284     path& make_preferred();
 285     path& remove_filename();
 286     path& replace_filename(const path& __replacement);
 287     path& replace_extension(const path& __replacement = path());
 288
 289     void swap(path& __rhs) noexcept;
 290
 291     // native format observers
 292
 293     const string_type&  native() const noexcept { return _M_pathname; }
 294     const value_type*   c_str() const noexcept { return _M_pathname.c_str(); }
 295     operator string_type() const { return _M_pathname; }
 296
 297     template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
 298              typename _Allocator = std::allocator<_CharT>>
 299       std::basic_string<_CharT, _Traits, _Allocator>
 300       string(const _Allocator& __a = _Allocator()) const;
 301
 302     std::string    string() const;
 303 #if _GLIBCXX_USE_WCHAR_T
 304     std::wstring   wstring() const;
 305 #endif
 306     std::string    u8string() const;
 307     std::u16string u16string() const;
 308     std::u32string u32string() const;
 309
 310     // generic format observers
 311     template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
 312              typename _Allocator = std::allocator<_CharT>>
 313       std::basic_string<_CharT, _Traits, _Allocator>
 314       generic_string(const _Allocator& __a = _Allocator()) const;
 315
 316     std::string    generic_string() const;
 317 #if _GLIBCXX_USE_WCHAR_T
 318     std::wstring   generic_wstring() const;
 319 #endif
 320     std::string    generic_u8string() const;
 321     std::u16string generic_u16string() const;
 322     std::u32string generic_u32string() const;
 323
 324     // compare
 325
 326     int compare(const path& __p) const noexcept;
 327     int compare(const string_type& __s) const;
 328     int compare(const value_type* __s) const;
 329     int compare(const basic_string_view<value_type> __s) const;
 330
 331     // decomposition
 332
 333     path root_name() const;
 334     path root_directory() const;
 335     path root_path() const;
 336     path relative_path() const;
 337     path parent_path() const;
 338     path filename() const;
 339     path stem() const;
 340     path extension() const;
 341
 342     // query
 343
 344     [[nodiscard]] bool empty() const noexcept { return _M_pathname.empty(); }
 345     bool has_root_name() const;
 346     bool has_root_directory() const;
 347     bool has_root_path() const;
 348     bool has_relative_path() const;
 349     bool has_parent_path() const;
 350     bool has_filename() const;
 351     bool has_stem() const;
 352     bool has_extension() const;
 353     bool is_absolute() const;
 354     bool is_relative() const { return !is_absolute(); }
 355
 356     // generation
 357     path lexically_normal() const;
 358     path lexically_relative(const path& base) const;
 359     path lexically_proximate(const path& base) const;
 360
 361     // iterators
 362     class iterator;
 363     typedef iterator const_iterator;
 364
 365     iterator begin() const;
 366     iterator end() const;
 367
 368     /// Write a path to a stream
 369     template<typename _CharT, typename _Traits>
 370       friend std::basic_ostream<_CharT, _Traits>&
 371       operator<<(std::basic_ostream<_CharT, _Traits>& __os, const path& __p)
 372       {
 373         __os << std::quoted(__p.string<_CharT, _Traits>());
 374         return __os;
 375       }
 376
 377     /// Read a path from a stream
 378     template<typename _CharT, typename _Traits>
 379       friend std::basic_istream<_CharT, _Traits>&
 380       operator>>(std::basic_istream<_CharT, _Traits>& __is, path& __p)
 381       {
 382         std::basic_string<_CharT, _Traits> __tmp;
 383         if (__is >> std::quoted(__tmp))
 384           __p = std::move(__tmp);
 385         return __is;
 386       }
 387
 388     // Create a basic_string by reading until a null character.
 389     template<typename _InputIterator,
 390              typename _Traits = std::iterator_traits<_InputIterator>,
 391              typename _CharT
 392                = typename std::remove_cv_t<typename _Traits::value_type>>
 393       static std::basic_string<_CharT>
 394       _S_string_from_iter(_InputIterator __source)
 395       {
 396         std::basic_string<_CharT> __str;
 397         for (_CharT __ch = *__source; __ch != _CharT(); __ch = *++__source)
 398           __str.push_back(__ch);
 399         return __str;
 400       }
 401
 402   private:
 403     enum class _Type : unsigned char {
 404         _Multi, _Root_name, _Root_dir, _Filename
 405     };
 406
 407     path(string_type __str, _Type __type) : _M_pathname(__str), _M_type(__type)
 408     {
 409       __glibcxx_assert(_M_type != _Type::_Multi);
 410     }
 411
 412     enum class _Split { _Stem, _Extension };
 413
 414     path& _M_append(path __p);
 415
 416     pair<const string_type*, size_t> _M_find_extension() const;
 417
 418     template<typename _CharT>
 419       struct _Cvt;
 420
 421     static string_type
 422     _S_convert(value_type* __src, __null_terminated)
 423     { return string_type(__src); }
 424
 425     static string_type
 426     _S_convert(const value_type* __src, __null_terminated)
 427     { return string_type(__src); }
 428
 429     template<typename _Iter>
 430       static string_type
 431       _S_convert(_Iter __first, _Iter __last)
 432       {
 433         using __value_type = typename std::iterator_traits<_Iter>::value_type;
 434         return _Cvt<typename remove_cv<__value_type>::type>::
 435           _S_convert(__first, __last);
 436       }
 437
 438     template<typename _InputIterator>
 439       static string_type
 440       _S_convert(_InputIterator __src, __null_terminated)
 441       {
 442         auto __s = _S_string_from_iter(__src);
 443         return _S_convert(__s.c_str(), __s.c_str() + __s.size());
 444       }
 445
 446     static string_type
 447     _S_convert_loc(const char* __first, const char* __last,
 448                    const std::locale& __loc);
 449
 450     template<typename _Iter>
 451       static string_type
 452       _S_convert_loc(_Iter __first, _Iter __last, const std::locale& __loc)
 453       {
 454         const std::string __str(__first, __last);
 455         return _S_convert_loc(__str.data(), __str.data()+__str.size(), __loc);
 456       }
 457
 458     template<typename _InputIterator>
 459       static string_type
 460       _S_convert_loc(_InputIterator __src, __null_terminated,
 461                      const std::locale& __loc)
 462       {
 463         std::string __s = _S_string_from_iter(__src);
 464         return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc);
 465       }
 466
 467     template<typename _CharT, typename _Traits, typename _Allocator>
 468       static basic_string<_CharT, _Traits, _Allocator>
 469       _S_str_convert(const string_type&, const _Allocator& __a);
 470
 471     bool _S_is_dir_sep(value_type __ch)
 472     {
 473 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 474       return __ch == L'/' || __ch == preferred_separator;
 475 #else
 476       return __ch == '/';
 477 #endif
 478     }
 479
 480     void _M_split_cmpts();
 481     void _M_trim();
 482     void _M_add_root_name(size_t __n);
 483     void _M_add_root_dir(size_t __pos);
 484     void _M_add_filename(size_t __pos, size_t __n);
 485
 486     string_type _M_pathname;
 487
 488     struct _Cmpt;
 489     using _List = _GLIBCXX_STD_C::vector<_Cmpt>;
 490     _List _M_cmpts; // empty unless _M_type == _Type::_Multi
 491     _Type _M_type = _Type::_Filename;
 492   };
 493
 494   inline void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); }
 495
 496   size_t hash_value(const path& __p) noexcept;
 497
 498   /// Compare paths
 499   inline bool operator<(const path& __lhs, const path& __rhs) noexcept
 500   { return __lhs.compare(__rhs) < 0; }
 501
 502   /// Compare paths
 503   inline bool operator<=(const path& __lhs, const path& __rhs) noexcept
 504   { return !(__rhs < __lhs); }
 505
 506   /// Compare paths
 507   inline bool operator>(const path& __lhs, const path& __rhs) noexcept
 508   { return __rhs < __lhs; }
 509
 510   /// Compare paths
 511   inline bool operator>=(const path& __lhs, const path& __rhs) noexcept
 512   { return !(__lhs < __rhs); }
 513
 514   /// Compare paths
 515   inline bool operator==(const path& __lhs, const path& __rhs) noexcept
 516   { return __lhs.compare(__rhs) == 0; }
 517
 518   /// Compare paths
 519   inline bool operator!=(const path& __lhs, const path& __rhs) noexcept
 520   { return !(__lhs == __rhs); }
 521
 522   /// Append one path to another
 523   inline path operator/(const path& __lhs, const path& __rhs)
 524   {
 525     path __result(__lhs);
 526     __result /= __rhs;
 527     return __result;
 528   }
 529
 530   template<typename _InputIterator>
 531     inline auto
 532     u8path(_InputIterator __first, _InputIterator __last)
 533     -> decltype(filesystem::path(__first, __last, std::locale::classic()))
 534     {
 535 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 536       codecvt_utf8<path::value_type> __cvt;
 537       path::string_type __tmp;
 538       if constexpr (is_pointer_v<_InputIterator>)
 539         {
 540           if (__str_codecvt_in(__first, __last, __tmp, __cvt))
 541             return path{ __tmp };
 542         }
 543       else
 544         {
 545           const std::string __u8str{__first, __last};
 546           const char* const __ptr = __u8str.data();
 547           if (__str_codecvt_in(__ptr, __ptr + __u8str.size(), __tmp, __cvt))
 548             return path{ __tmp };
 549         }
 550       return {};
 551 #else
 552       return path{ __first, __last };
 553 #endif
 554     }
 555
 556   template<typename _Source>
 557     inline auto
 558     u8path(const _Source& __source)
 559     -> decltype(filesystem::path(__source, std::locale::classic()))
 560     {
 561 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 562       if constexpr (is_convertible_v<const _Source&, std::string_view>)
 563         {
 564           const std::string_view __s = __source;
 565           return filesystem::u8path(__s.data(), __s.data() + __s.size());
 566         }
 567       else
 568         {
 569           std::string __s = path::_S_string_from_iter(__source);
 570           return filesystem::u8path(__s.data(), __s.data() + __s.size());
 571         }
 572 #else
 573       return path{ __source };
 574 #endif
 575     }
 576
 577   class filesystem_error : public std::system_error
 578   {
 579   public:
 580     filesystem_error(const string& __what_arg, error_code __ec);
 581
 582     filesystem_error(const string& __what_arg, const path& __p1,
 583                      error_code __ec);
 584
 585     filesystem_error(const string& __what_arg, const path& __p1,
 586                      const path& __p2, error_code __ec);
 587
 588     filesystem_error(const filesystem_error&) = default;
 589     filesystem_error& operator=(const filesystem_error&) = default;
 590
 591     // No move constructor or assignment operator.
 592     // Copy rvalues instead, so that _M_impl is not left empty.
 593
 594     ~filesystem_error();
 595
 596     const path& path1() const noexcept;
 597     const path& path2() const noexcept;
 598     const char* what() const noexcept;
 599
 600   private:
 601     struct _Impl;
 602     std::__shared_ptr<const _Impl> _M_impl;
 603   };
 604
 605   struct path::_Cmpt : path
 606   {
 607     _Cmpt(string_type __s, _Type __t, size_t __pos)
 608       : path(std::move(__s), __t), _M_pos(__pos) { }
 609
 610     _Cmpt() : _M_pos(-1) { }
 611
 612     size_t _M_pos;
 613   };
 614
 615   // specialize _Cvt for degenerate 'noconv' case
 616   template<>
 617     struct path::_Cvt<path::value_type>
 618     {
 619       template<typename _Iter>
 620         static string_type
 621         _S_convert(_Iter __first, _Iter __last)
 622         { return string_type{__first, __last}; }
 623     };
 624
 625   template<typename _CharT>
 626     struct path::_Cvt
 627     {
 628 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 629       static string_type
 630       _S_wconvert(const char* __f, const char* __l, true_type)
 631       {
 632         using _Cvt = std::codecvt<wchar_t, char, mbstate_t>;
 633         const auto& __cvt = std::use_facet<_Cvt>(std::locale{});
 634         std::wstring __wstr;
 635         if (__str_codecvt_in(__f, __l, __wstr, __cvt))
 636             return __wstr;
 637         _GLIBCXX_THROW_OR_ABORT(filesystem_error(
 638               "Cannot convert character sequence",
 639               std::make_error_code(errc::illegal_byte_sequence)));
 640       }
 641
 642       static string_type
 643       _S_wconvert(const _CharT* __f, const _CharT* __l, false_type)
 644       {
 645         std::codecvt_utf8<_CharT> __cvt;
 646         std::string __str;
 647         if (__str_codecvt_out(__f, __l, __str, __cvt))
 648           {
 649             const char* __f2 = __str.data();
 650             const char* __l2 = __f2 + __str.size();
 651             std::codecvt_utf8<wchar_t> __wcvt;
 652             std::wstring __wstr;
 653             if (__str_codecvt_in(__f2, __l2, __wstr, __wcvt))
 654               return __wstr;
 655           }
 656         _GLIBCXX_THROW_OR_ABORT(filesystem_error(
 657               "Cannot convert character sequence",
 658               std::make_error_code(errc::illegal_byte_sequence)));
 659       }
 660
 661       static string_type
 662       _S_convert(const _CharT* __f, const _CharT* __l)
 663       {
 664         return _S_wconvert(__f, __l, is_same<_CharT, char>{});
 665       }
 666 #else
 667       static string_type
 668       _S_convert(const _CharT* __f, const _CharT* __l)
 669       {
 670         std::codecvt_utf8<_CharT> __cvt;
 671         std::string __str;
 672         if (__str_codecvt_out(__f, __l, __str, __cvt))
 673           return __str;
 674         _GLIBCXX_THROW_OR_ABORT(filesystem_error(
 675               "Cannot convert character sequence",
 676               std::make_error_code(errc::illegal_byte_sequence)));
 677       }
 678 #endif
 679
 680       static string_type
 681       _S_convert(_CharT* __f, _CharT* __l)
 682       {
 683         return _S_convert(const_cast<const _CharT*>(__f),
 684                           const_cast<const _CharT*>(__l));
 685       }
 686
 687       template<typename _Iter>
 688         static string_type
 689         _S_convert(_Iter __first, _Iter __last)
 690         {
 691           const std::basic_string<_CharT> __str(__first, __last);
 692           return _S_convert(__str.data(), __str.data() + __str.size());
 693         }
 694
 695       template<typename _Iter, typename _Cont>
 696         static string_type
 697         _S_convert(__gnu_cxx::__normal_iterator<_Iter, _Cont> __first,
 698                   __gnu_cxx::__normal_iterator<_Iter, _Cont> __last)
 699         { return _S_convert(__first.base(), __last.base()); }
 700     };
 701
 702   /// An iterator for the components of a path
 703   class path::iterator
 704   {
 705   public:
 706     using difference_type       = std::ptrdiff_t;
 707     using value_type            = path;
 708     using reference             = const path&;
 709     using pointer               = const path*;
 710     using iterator_category     = std::bidirectional_iterator_tag;
 711
 712     iterator() : _M_path(nullptr), _M_cur(), _M_at_end() { }
 713
 714     iterator(const iterator&) = default;
 715     iterator& operator=(const iterator&) = default;
 716
 717     reference operator*() const;
 718     pointer   operator->() const { return std::__addressof(**this); }
 719
 720     iterator& operator++();
 721     iterator  operator++(int) { auto __tmp = *this; ++*this; return __tmp; }
 722
 723     iterator& operator--();
 724     iterator  operator--(int) { auto __tmp = *this; --*this; return __tmp; }
 725
 726     friend bool operator==(const iterator& __lhs, const iterator& __rhs)
 727     { return __lhs._M_equals(__rhs); }
 728
 729     friend bool operator!=(const iterator& __lhs, const iterator& __rhs)
 730     { return !__lhs._M_equals(__rhs); }
 731
 732   private:
 733     friend class path;
 734
 735     iterator(const path* __path, path::_List::const_iterator __iter)
 736     : _M_path(__path), _M_cur(__iter), _M_at_end()
 737     { }
 738
 739     iterator(const path* __path, bool __at_end)
 740     : _M_path(__path), _M_cur(), _M_at_end(__at_end)
 741     { }
 742
 743     bool _M_equals(iterator) const;
 744
 745     const path*                 _M_path;
 746     path::_List::const_iterator _M_cur;
 747     bool                        _M_at_end;  // only used when type != _Multi
 748   };
 749
 750
 751   inline path&
 752   path::operator=(path&& __p) noexcept
 753   {
 754     _M_pathname = std::move(__p._M_pathname);
 755     _M_cmpts = std::move(__p._M_cmpts);
 756     _M_type = __p._M_type;
 757     __p.clear();
 758     return *this;
 759   }
 760
 761   inline path&
 762   path::operator=(string_type&& __source)
 763   { return *this = path(std::move(__source)); }
 764
 765   inline path&
 766   path::assign(string_type&& __source)
 767   { return *this = path(std::move(__source)); }
 768
 769   inline path&
 770   path::operator+=(const path& __p)
 771   {
 772     return operator+=(__p.native());
 773   }
 774
 775   inline path&
 776   path::operator+=(const string_type& __x)
 777   {
 778     _M_pathname += __x;
 779     _M_split_cmpts();
 780     return *this;
 781   }
 782
 783   inline path&
 784   path::operator+=(const value_type* __x)
 785   {
 786     _M_pathname += __x;
 787     _M_split_cmpts();
 788     return *this;
 789   }
 790
 791   inline path&
 792   path::operator+=(value_type __x)
 793   {
 794     _M_pathname += __x;
 795     _M_split_cmpts();
 796     return *this;
 797   }
 798
 799   inline path&
 800   path::operator+=(basic_string_view<value_type> __x)
 801   {
 802     _M_pathname.append(__x.data(), __x.size());
 803     _M_split_cmpts();
 804     return *this;
 805   }
 806
 807   template<typename _CharT>
 808     inline path::_Path<_CharT*, _CharT*>&
 809     path::operator+=(_CharT __x)
 810     {
 811       auto* __addr = std::__addressof(__x);
 812       return concat(__addr, __addr + 1);
 813     }
 814
 815   inline path&
 816   path::make_preferred()
 817   {
 818 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 819     std::replace(_M_pathname.begin(), _M_pathname.end(), L'/',
 820                  preferred_separator);
 821 #endif
 822     return *this;
 823   }
 824
 825   inline void path::swap(path& __rhs) noexcept
 826   {
 827     _M_pathname.swap(__rhs._M_pathname);
 828     _M_cmpts.swap(__rhs._M_cmpts);
 829     std::swap(_M_type, __rhs._M_type);
 830   }
 831
 832   template<typename _CharT, typename _Traits, typename _Allocator>
 833     std::basic_string<_CharT, _Traits, _Allocator>
 834     path::_S_str_convert(const string_type& __str, const _Allocator& __a)
 835     {
 836       if (__str.size() == 0)
 837         return std::basic_string<_CharT, _Traits, _Allocator>(__a);
 838
 839       const value_type* __first = __str.data();
 840       const value_type* __last = __first + __str.size();
 841
 842 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 843       using _CharAlloc = __alloc_rebind<_Allocator, char>;
 844       using _String = basic_string<char, char_traits<char>, _CharAlloc>;
 845       using _WString = basic_string<_CharT, _Traits, _Allocator>;
 846
 847       // use codecvt_utf8<wchar_t> to convert native string to UTF-8
 848       codecvt_utf8<value_type> __cvt;
 849       _String __u8str{_CharAlloc{__a}};
 850       if (__str_codecvt_out(__first, __last, __u8str, __cvt))
 851         {
 852           if constexpr (is_same_v<_CharT, char>)
 853             return __u8str;
 854           else
 855             {
 856               _WString __wstr;
 857               // use codecvt_utf8<_CharT> to convert UTF-8 to wide string
 858               codecvt_utf8<_CharT> __cvt;
 859               const char* __f = __u8str.data();
 860               const char* __l = __f + __u8str.size();
 861               if (__str_codecvt_in(__f, __l, __wstr, __cvt))
 862                 return __wstr;
 863             }
 864         }
 865 #else
 866       codecvt_utf8<_CharT> __cvt;
 867       basic_string<_CharT, _Traits, _Allocator> __wstr{__a};
 868       if (__str_codecvt_in(__first, __last, __wstr, __cvt))
 869         return __wstr;
 870 #endif
 871       _GLIBCXX_THROW_OR_ABORT(filesystem_error(
 872             "Cannot convert character sequence",
 873             std::make_error_code(errc::illegal_byte_sequence)));
 874     }
 875
 876   template<typename _CharT, typename _Traits, typename _Allocator>
 877     inline basic_string<_CharT, _Traits, _Allocator>
 878     path::string(const _Allocator& __a) const
 879     {
 880       if constexpr (is_same_v<_CharT, value_type>)
 881         {
 882 #if _GLIBCXX_USE_CXX11_ABI
 883           return { _M_pathname, __a };
 884 #else
 885           if constexpr (is_same_v<_Allocator, string_type::allocator_type>)
 886             return _M_pathname;
 887           else
 888             return { _M_pathname, string_type::size_type(0), __a };
 889 #endif
 890         }
 891       else
 892         return _S_str_convert<_CharT, _Traits>(_M_pathname, __a);
 893     }
 894
 895   inline std::string
 896   path::string() const { return string<char>(); }
 897
 898 #if _GLIBCXX_USE_WCHAR_T
 899   inline std::wstring
 900   path::wstring() const { return string<wchar_t>(); }
 901 #endif
 902
 903   inline std::string
 904   path::u8string() const
 905   {
 906 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 907     std::string __str;
 908     // convert from native encoding to UTF-8
 909     codecvt_utf8<value_type> __cvt;
 910     const value_type* __first = _M_pathname.data();
 911     const value_type* __last = __first + _M_pathname.size();
 912     if (__str_codecvt_out(__first, __last, __str, __cvt))
 913       return __str;
 914     _GLIBCXX_THROW_OR_ABORT(filesystem_error(
 915           "Cannot convert character sequence",
 916           std::make_error_code(errc::illegal_byte_sequence)));
 917 #else
 918     return _M_pathname;
 919 #endif
 920   }
 921
 922   inline std::u16string
 923   path::u16string() const { return string<char16_t>(); }
 924
 925   inline std::u32string
 926   path::u32string() const { return string<char32_t>(); }
 927
 928   template<typename _CharT, typename _Traits, typename _Allocator>
 929     inline std::basic_string<_CharT, _Traits, _Allocator>
 930     path::generic_string(const _Allocator& __a) const
 931     {
 932 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
 933       const value_type __slash = L'/';
 934 #else
 935       const value_type __slash = '/';
 936 #endif
 937       string_type __str(__a);
 938
 939       if (_M_type == _Type::_Root_dir)
 940         __str.assign(1, __slash);
 941       else
 942         {
 943           __str.reserve(_M_pathname.size());
 944           bool __add_slash = false;
 945           for (auto& __elem : *this)
 946             {
 947               if (__add_slash)
 948                 __str += __slash;
 949               __str += __elem._M_pathname;
 950               __add_slash = __elem._M_type == _Type::_Filename;
 951             }
 952         }
 953
 954       if constexpr (is_same_v<_CharT, value_type>)
 955         return __str;
 956       else
 957         return _S_str_convert<_CharT, _Traits>(__str, __a);
 958     }
 959
 960   inline std::string
 961   path::generic_string() const
 962   { return generic_string<char>(); }
 963
 964 #if _GLIBCXX_USE_WCHAR_T
 965   inline std::wstring
 966   path::generic_wstring() const
 967   { return generic_string<wchar_t>(); }
 968 #endif
 969
 970   inline std::string
 971   path::generic_u8string() const
 972   { return generic_string(); }
 973
 974   inline std::u16string
 975   path::generic_u16string() const
 976   { return generic_string<char16_t>(); }
 977
 978   inline std::u32string
 979   path::generic_u32string() const
 980   { return generic_string<char32_t>(); }
 981
 982   inline int
 983   path::compare(const string_type& __s) const { return compare(path(__s)); }
 984
 985   inline int
 986   path::compare(const value_type* __s) const { return compare(path(__s)); }
 987
 988   inline int
 989   path::compare(basic_string_view<value_type> __s) const
 990   { return compare(path(__s)); }
 991
 992   inline path
 993   path::filename() const
 994   {
 995     if (empty())
 996       return {};
 997     else if (_M_type == _Type::_Filename)
 998       return *this;
 999     else if (_M_type == _Type::_Multi)
1000       {
1001         if (_M_pathname.back() == preferred_separator)
1002           return {};
1003         auto& __last = *--end();
1004         if (__last._M_type == _Type::_Filename)
1005           return __last;
1006       }
1007     return {};
1008   }
1009
1010   inline path
1011   path::stem() const
1012   {
1013     auto ext = _M_find_extension();
1014     if (ext.first && ext.second != 0)
1015       return path{ext.first->substr(0, ext.second)};
1016     return {};
1017   }
1018
1019   inline path
1020   path::extension() const
1021   {
1022     auto ext = _M_find_extension();
1023     if (ext.first && ext.second != string_type::npos)
1024       return path{ext.first->substr(ext.second)};
1025     return {};
1026   }
1027
1028   inline bool
1029   path::has_stem() const
1030   {
1031     auto ext = _M_find_extension();
1032     return ext.first && ext.second != 0;
1033   }
1034
1035   inline bool
1036   path::has_extension() const
1037   {
1038     auto ext = _M_find_extension();
1039     return ext.first && ext.second != string_type::npos;
1040   }
1041
1042   inline bool
1043   path::is_absolute() const
1044   {
1045 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1046     return has_root_name() && has_root_directory();
1047 #else
1048     return has_root_directory();
1049 #endif
1050   }
1051
1052   inline path::iterator
1053   path::begin() const
1054   {
1055     if (_M_type == _Type::_Multi)
1056       return iterator(this, _M_cmpts.begin());
1057     return iterator(this, empty());
1058   }
1059
1060   inline path::iterator
1061   path::end() const
1062   {
1063     if (_M_type == _Type::_Multi)
1064       return iterator(this, _M_cmpts.end());
1065     return iterator(this, true);
1066   }
1067
1068 #ifndef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1069   inline path& path::operator/=(const path& __p)
1070   {
1071     // Much simpler than the specification in the standard,
1072     // as any path with root-name or root-dir is absolute.
1073     if (__p.is_absolute())
1074       operator=(__p);
1075     else
1076       {
1077         if (has_filename() || (_M_type == _Type::_Root_name))
1078           _M_pathname += preferred_separator;
1079         _M_pathname += __p.native();
1080         _M_split_cmpts();
1081       }
1082     return *this;
1083   }
1084 #endif
1085
1086   inline path&
1087   path::_M_append(path __p)
1088   {
1089     if (__p.is_absolute())
1090       operator=(std::move(__p));
1091 #ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1092     else if (__p.has_root_name() && __p.root_name() != root_name())
1093       operator=(std::move(__p));
1094 #endif
1095     else
1096       operator/=(const_cast<const path&>(__p));
1097     return *this;
1098   }
1099
1100   inline path::iterator&
1101   path::iterator::operator++()
1102   {
1103     __glibcxx_assert(_M_path != nullptr);
1104     if (_M_path->_M_type == _Type::_Multi)
1105       {
1106         __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1107         ++_M_cur;
1108       }
1109     else
1110       {
1111         __glibcxx_assert(!_M_at_end);
1112         _M_at_end = true;
1113       }
1114     return *this;
1115   }
1116
1117   inline path::iterator&
1118   path::iterator::operator--()
1119   {
1120     __glibcxx_assert(_M_path != nullptr);
1121     if (_M_path->_M_type == _Type::_Multi)
1122       {
1123         __glibcxx_assert(_M_cur != _M_path->_M_cmpts.begin());
1124         --_M_cur;
1125       }
1126     else
1127       {
1128         __glibcxx_assert(_M_at_end);
1129         _M_at_end = false;
1130       }
1131     return *this;
1132   }
1133
1134   inline path::iterator::reference
1135   path::iterator::operator*() const
1136   {
1137     __glibcxx_assert(_M_path != nullptr);
1138     if (_M_path->_M_type == _Type::_Multi)
1139       {
1140         __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1141         return *_M_cur;
1142       }
1143     return *_M_path;
1144   }
1145
1146   inline bool
1147   path::iterator::_M_equals(iterator __rhs) const
1148   {
1149     if (_M_path != __rhs._M_path)
1150       return false;
1151     if (_M_path == nullptr)
1152       return true;
1153     if (_M_path->_M_type == path::_Type::_Multi)
1154       return _M_cur == __rhs._M_cur;
1155     return _M_at_end == __rhs._M_at_end;
1156   }
1157
1158   // @} group filesystem
1159 _GLIBCXX_END_NAMESPACE_CXX11
1160 } // namespace filesystem
1161
1162 extern template class __shared_ptr<const filesystem::filesystem_error::_Impl>;
1163
1164 _GLIBCXX_END_NAMESPACE_VERSION
1165 } // namespace std
1166
1167 #endif // C++17
1168
1169 #endif // _GLIBCXX_FS_PATH_H