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