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 // We need this type to be defined because we don't have `if constexpr`
738 // in C++11 and so path::string<C,T,A>(const A&) needs to be able to
739 // declare a variable of this type and pass it to __str_codecvt_in_all.
740 using __codecvt_utf8_to_wide = _Cvt;
741 // Dummy overload used for unreachable calls in path::string<C,T,A>.
742 template<typename _WStr>
743 friend bool
744 __str_codecvt_in_all(const char*, const char*,
745 _WStr&, __codecvt_utf8_to_wide&) noexcept
746 { return true; }
747
748 template<typename _Iter>
749 static string_type
750 _S_convert(_Iter __first, _Iter __last)
751 { return string_type{__first, __last}; }
752 };
753
754 // Performs conversions from _CharT to path::string_type.
755 template<typename _CharT>
756 struct path::_Cvt
757 {
758 // FIXME: We currently assume that the native wide encoding for wchar_t
759 // is either UTF-32 or UTF-16 (depending on the width of wchar_t).
760 // See comments in <bits/fs_path.h> for further details.
761 using __codecvt_utf8_to_wchar
762 = __conditional_t<sizeof(wchar_t) == sizeof(char32_t),
763 std::codecvt_utf8<wchar_t>, // from UTF-32
764 std::codecvt_utf8_utf16<wchar_t>>; // from UTF-16
765
766 // Converts from char16_t or char32_t using std::codecvt<charNN_t, char>.
767 // Need derived class here because std::codecvt has protected destructor.
768 struct __codecvt_utf8_to_utfNN : std::codecvt<_CharT, char, mbstate_t>
769 { };
770
771 // Convert from native pathname format (assumed to be UTF-8 everywhere)
772 // to the encoding implied by the wide character type _CharT.
773 using __codecvt_utf8_to_wide
774 = __conditional_t<is_same<_CharT, wchar_t>::value,
775 __codecvt_utf8_to_wchar,
776 __codecvt_utf8_to_utfNN>;
777
778#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
779#ifdef _GLIBCXX_USE_CHAR8_T
780 static string_type
781 _S_wconvert(const char8_t* __f, const char8_t* __l, const char8_t*)
782 {
783 const char* __f2 = (const char*)__f;
784 const char* __l2 = (const char*)__l;
785 std::wstring __wstr;
786 std::codecvt_utf8_utf16<wchar_t> __wcvt;
787 if (__str_codecvt_in_all(__f2, __l2, __wstr, __wcvt))
788 return __wstr;
789 }
790#endif
791
792 static string_type
793 _S_wconvert(const char* __f, const char* __l, const char*)
794 {
795 using _Cvt = std::codecvt_utf8_utf16<wchar_t>;
796 const auto& __cvt = std::use_facet<_Cvt>(std::locale{});
797 std::wstring __wstr;
798 if (__str_codecvt_in_all(__f, __l, __wstr, __cvt))
799 return __wstr;
800 _GLIBCXX_THROW_OR_ABORT(filesystem_error(
801 "Cannot convert character sequence",
802 std::make_error_code(errc::illegal_byte_sequence)));
803 }
804
805 static string_type
806 _S_wconvert(const _CharT* __f, const _CharT* __l, const void*)
807 {
808 __codecvt_utf8_to_wide __cvt;
809 std::string __str;
810 if (__str_codecvt_out_all(__f, __l, __str, __cvt))
811 {
812 const char* __f2 = __str.data();
813 const char* __l2 = __f2 + __str.size();
814 std::codecvt_utf8_utf16<wchar_t> __wcvt;
815 std::wstring __wstr;
816 if (__str_codecvt_in_all(__f2, __l2, __wstr, __wcvt))
817 return __wstr;
818 }
819 _GLIBCXX_THROW_OR_ABORT(filesystem_error(
820 "Cannot convert character sequence",
821 std::make_error_code(errc::illegal_byte_sequence)));
822 }
823
824 static string_type
825 _S_convert(const _CharT* __f, const _CharT* __l)
826 {
827 return _S_wconvert(__f, __l, (const _CharT*)nullptr);
828 }
829#else
830 static string_type
831 _S_convert(const _CharT* __f, const _CharT* __l)
832 {
833#ifdef _GLIBCXX_USE_CHAR8_T
834 if constexpr (is_same<_CharT, char8_t>::value)
835 return string_type(__f, __l);
836 else
837#endif
838 {
839 __codecvt_utf8_to_wide __cvt;
840 std::string __str;
841 if (__str_codecvt_out_all(__f, __l, __str, __cvt))
842 return __str;
843 _GLIBCXX_THROW_OR_ABORT(filesystem_error(
844 "Cannot convert character sequence",
845 std::make_error_code(errc::illegal_byte_sequence)));
846 }
847 }
848#endif
849
850 static string_type
851 _S_convert(_CharT* __f, _CharT* __l)
852 {
853 return _S_convert(const_cast<const _CharT*>(__f),
854 const_cast<const _CharT*>(__l));
855 }
856
857 template<typename _Iter>
858 static string_type
859 _S_convert(_Iter __first, _Iter __last)
860 {
861 const std::basic_string<_CharT> __str(__first, __last);
862 return _S_convert(__str.data(), __str.data() + __str.size());
863 }
864
865 template<typename _Iter, typename _Cont>
866 static string_type
867 _S_convert(__gnu_cxx::__normal_iterator<_Iter, _Cont> __first,
868 __gnu_cxx::__normal_iterator<_Iter, _Cont> __last)
869 { return _S_convert(__first.base(), __last.base()); }
870 };
871 /// @endcond
872
873 /// An iterator for the components of a path
874 class path::iterator
875 {
876 public:
877 using difference_type = std::ptrdiff_t;
878 using value_type = path;
879 using reference = const path&;
880 using pointer = const path*;
881 using iterator_category = std::bidirectional_iterator_tag;
882
883 iterator() noexcept : _M_path(nullptr), _M_cur(), _M_at_end() { }
884
885 iterator(const iterator&) = default;
886 iterator& operator=(const iterator&) = default;
887
888 reference operator*() const noexcept;
889 pointer operator->() const noexcept { return std::__addressof(**this); }
890
891 iterator& operator++() noexcept;
892
893 iterator operator++(int) noexcept
894 { auto __tmp = *this; ++*this; return __tmp; }
895
896 iterator& operator--() noexcept;
897
898 iterator operator--(int) noexcept
899 { auto __tmp = *this; --*this; return __tmp; }
900
901 friend bool
902 operator==(const iterator& __lhs, const iterator& __rhs) noexcept
903 { return __lhs._M_equals(__rhs); }
904
905 friend bool
906 operator!=(const iterator& __lhs, const iterator& __rhs) noexcept
907 { return !__lhs._M_equals(__rhs); }
908
909 private:
910 friend class path;
911
912 iterator(const path* __path, path::_List::const_iterator __iter) noexcept
913 : _M_path(__path), _M_cur(__iter), _M_at_end()
914 { }
915
916 iterator(const path* __path, bool __at_end) noexcept
917 : _M_path(__path), _M_cur(), _M_at_end(__at_end)
918 { }
919
920 bool _M_equals(iterator) const noexcept;
921
922 const path* _M_path;
923 path::_List::const_iterator _M_cur;
924 bool _M_at_end; // only used when type != _Multi
925 };
926
927 inline
928 path::path() noexcept = default;
929
930 inline
931 path::path(const path&) = default;
932
933 inline
934 path::path(path&& __p) noexcept
935 : _M_pathname(std::move(__p._M_pathname)),
936 _M_cmpts(__p._M_cmpts),
937 _M_type(__p._M_type)
938 { __p.clear(); }
939
940 inline
941 path::path(string_type&& __source)
942 : _M_pathname(std::move(__source))
943 { _M_split_cmpts(); }
944
945 inline
946 path::path(string_type __str, _Type __type)
947 : _M_pathname(__str), _M_type(__type)
948 {
949 __glibcxx_assert(!empty());
950 __glibcxx_assert(_M_type != _Type::_Multi);
951 }
952
953 inline
954 path::~path() = default;
955
956 inline path&
957 path::operator=(const path& __p) = default;
958
959 inline path&
960 path::operator=(path&& __p) noexcept
961 {
962 _M_pathname = std::move(__p._M_pathname);
963 _M_cmpts = std::move(__p._M_cmpts);
964 _M_type = __p._M_type;
965 __p.clear();
966 return *this;
967 }
968
969 inline path&
970 path::operator=(string_type&& __source)
971 { return *this = path(std::move(__source)); }
972
973 inline path&
974 path::assign(string_type&& __source)
975 { return *this = path(std::move(__source)); }
976
977 inline path&
978 path::operator+=(const path& __p)
979 {
980 return operator+=(__p.native());
981 }
982
983 inline path&
984 path::operator+=(const string_type& __x)
985 {
986 _M_pathname += __x;
987 _M_split_cmpts();
988 return *this;
989 }
990
991 inline path&
992 path::operator+=(const value_type* __x)
993 {
994 _M_pathname += __x;
995 _M_split_cmpts();
996 return *this;
997 }
998
999 inline path&
1000 path::operator+=(value_type __x)
1001 {
1002 _M_pathname += __x;
1003 _M_split_cmpts();
1004 return *this;
1005 }
1006
1007#if __cplusplus >= 201402L
1008 inline path&
1009 path::operator+=(basic_string_view<value_type> __x)
1010 {
1011 _M_pathname.append(__x.data(), __x.size());
1012 _M_split_cmpts();
1013 return *this;
1014 }
1015#endif
1016
1017 template<typename _CharT>
1018 inline __detail::_Path<_CharT*, _CharT*>&
1019 path::operator+=(_CharT __x)
1020 {
1021 auto* __addr = std::__addressof(__x);
1022 return concat(__addr, __addr + 1);
1023 }
1024
1025 inline path&
1026 path::make_preferred()
1027 {
1028#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1029 std::replace(_M_pathname.begin(), _M_pathname.end(), L'/',
1030 preferred_separator);
1031#endif
1032 return *this;
1033 }
1034
1035 inline void path::swap(path& __rhs) noexcept
1036 {
1037 _M_pathname.swap(__rhs._M_pathname);
1038 _M_cmpts.swap(__rhs._M_cmpts);
1039 std::swap(_M_type, __rhs._M_type);
1040 }
1041
1042 template<typename _CharT, typename _Traits, typename _Allocator>
1043 inline std::basic_string<_CharT, _Traits, _Allocator>
1044 path::string(const _Allocator& __a) const
1045 {
1046 if _GLIBCXX_CONSTEXPR (is_same<_CharT, value_type>::value)
1047 return { _M_pathname.begin(), _M_pathname.end(), __a };
1048
1049 using _WString = basic_string<_CharT, _Traits, _Allocator>;
1050
1051 const value_type* __first = _M_pathname.data();
1052 const value_type* __last = __first + _M_pathname.size();
1053
1054#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1055 using _CharAlloc = __alloc_rebind<_Allocator, char>;
1056 using _String = basic_string<char, char_traits<char>, _CharAlloc>;
1057
1058 // First convert native string from UTF-16 to to UTF-8.
1059 // XXX This assumes that the execution wide-character set is UTF-16.
1060 codecvt_utf8_utf16<value_type> __cvt;
1061 _String __u8str{_CharAlloc{__a}};
1062 if (__str_codecvt_out_all(__first, __last, __u8str, __cvt))
1063 {
1064 struct
1065 {
1066 const _String*
1067 operator()(const _String& __from, _String&, true_type)
1068 { return std::__addressof(__from); }
1069
1070 _WString*
1071 operator()(const _String& __from, _WString& __to, false_type)
1072 {
1073#ifdef _GLIBCXX_USE_CHAR8_T
1074 if constexpr (is_same<_CharT, char8_t>::value)
1075 {
1076 __to.assign(__from.begin(), __from.end());
1077 return std::__addressof(__to);
1078 }
1079 else
1080#endif
1081 {
1082 // Convert UTF-8 to char16_t or char32_t string.
1083 typename path::_Cvt<_CharT>::__codecvt_utf8_to_wide __cvt;
1084 const char* __f = __from.data();
1085 const char* __l = __f + __from.size();
1086 if (__str_codecvt_in_all(__f, __l, __to, __cvt))
1087 return std::__addressof(__to);
1088 }
1089 return nullptr;
1090 }
1091 } __dispatch;
1092 _WString __wstr(__a);
1093 if (auto* __p = __dispatch(__u8str, __wstr, is_same<_CharT, char>{}))
1094 return *__p;
1095 }
1096#else // ! Windows
1097#ifdef _GLIBCXX_USE_CHAR8_T
1098 if constexpr (is_same<_CharT, char8_t>::value)
1099 return _WString(__first, __last, __a);
1100 else
1101#endif
1102 {
1103 typename path::_Cvt<_CharT>::__codecvt_utf8_to_wide __cvt;
1104 _WString __wstr(__a);
1105 if (__str_codecvt_in_all(__first, __last, __wstr, __cvt))
1106 return __wstr;
1107 }
1108#endif
1109 _GLIBCXX_THROW_OR_ABORT(filesystem_error(
1110 "Cannot convert character sequence",
1111 std::make_error_code(errc::illegal_byte_sequence)));
1112 }
1113
1114 inline std::string
1115 path::string() const { return string<char>(); }
1116
1117#if _GLIBCXX_USE_WCHAR_T
1118 inline std::wstring
1119 path::wstring() const { return string<wchar_t>(); }
1120#endif
1121
1122#ifdef _GLIBCXX_USE_CHAR8_T
1123 inline std::u8string
1124 path::u8string() const { return string<char8_t>(); }
1125#else
1126 inline std::string
1127 path::u8string() const
1128 {
1129#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1130 std::string __str;
1131 // convert from native wide encoding (assumed to be UTF-16) to UTF-8
1132 std::codecvt_utf8_utf16<value_type> __cvt;
1133 const value_type* __first = _M_pathname.data();
1134 const value_type* __last = __first + _M_pathname.size();
1135 if (__str_codecvt_out_all(__first, __last, __str, __cvt))
1136 return __str;
1137 _GLIBCXX_THROW_OR_ABORT(filesystem_error(
1138 "Cannot convert character sequence",
1139 std::make_error_code(errc::illegal_byte_sequence)));
1140#else
1141 return _M_pathname;
1142#endif
1143 }
1144#endif // _GLIBCXX_USE_CHAR8_T
1145
1146 inline std::u16string
1147 path::u16string() const { return string<char16_t>(); }
1148
1149 inline std::u32string
1150 path::u32string() const { return string<char32_t>(); }
1151
1152 template<typename _CharT, typename _Traits, typename _Allocator>
1153 inline std::basic_string<_CharT, _Traits, _Allocator>
1154 path::generic_string(const _Allocator& __a) const
1155 {
1156#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1157 const _CharT __slash = is_same<_CharT, wchar_t>::value
1158 ? _CharT(L'/')
1159 : _CharT('/'); // Assume value is correct for the encoding.
1160#else
1161 const _CharT __slash = _CharT('/');
1162#endif
1163 basic_string<_CharT, _Traits, _Allocator> __str(__a);
1164 __str.reserve(_M_pathname.size());
1165 bool __add_slash = false;
1166 for (auto& __elem : *this)
1167 {
1168 if (__elem._M_type == _Type::_Root_dir)
1169 {
1170 __str += __slash;
1171 continue;
1172 }
1173 if (__add_slash)
1174 __str += __slash;
1175 __str += __elem.string<_CharT, _Traits, _Allocator>(__a);
1176 __add_slash = __elem._M_type == _Type::_Filename;
1177 }
1178 return __str;
1179 }
1180
1181 inline std::string
1182 path::generic_string() const { return generic_string<char>(); }
1183
1184#if _GLIBCXX_USE_WCHAR_T
1185 inline std::wstring
1186 path::generic_wstring() const { return generic_string<wchar_t>(); }
1187#endif
1188
1189#ifdef _GLIBCXX_USE_CHAR8_T
1190 inline std::u8string
1191 path::generic_u8string() const { return generic_string<char8_t>(); }
1192#else
1193 inline std::string
1194 path::generic_u8string() const { return generic_string<char>(); }
1195#endif
1196
1197 inline std::u16string
1198 path::generic_u16string() const { return generic_string<char16_t>(); }
1199
1200 inline std::u32string
1201 path::generic_u32string() const { return generic_string<char32_t>(); }
1202
1203 inline int
1204 path::compare(const string_type& __s) const { return compare(path(__s)); }
1205
1206 inline int
1207 path::compare(const value_type* __s) const { return compare(path(__s)); }
1208
1209#if __cplusplus >= 201402L
1210 inline int
1211 path::compare(basic_string_view<value_type> __s) const
1212 { return compare(path(__s)); }
1213#endif
1214
1215 inline path
1216 path::filename() const { return empty() ? path() : *--end(); }
1217
1218 inline path
1219 path::stem() const
1220 {
1221 auto ext = _M_find_extension();
1222 if (ext.first && ext.second != 0)
1223 return path{ext.first->substr(0, ext.second)};
1224 return {};
1225 }
1226
1227 inline path
1228 path::extension() const
1229 {
1230 auto ext = _M_find_extension();
1231 if (ext.first && ext.second != string_type::npos)
1232 return path{ext.first->substr(ext.second)};
1233 return {};
1234 }
1235
1236 inline bool
1237 path::has_stem() const
1238 {
1239 auto ext = _M_find_extension();
1240 return ext.first && ext.second != 0;
1241 }
1242
1243 inline bool
1244 path::has_extension() const
1245 {
1246 auto ext = _M_find_extension();
1247 return ext.first && ext.second != string_type::npos;
1248 }
1249
1250 inline bool
1251 path::is_absolute() const
1252 {
1253#ifdef _GLIBCXX_FILESYSTEM_IS_WINDOWS
1254 return has_root_name() && has_root_directory();
1255#else
1256 return has_root_directory();
1257#endif
1258 }
1259
1260 inline path::iterator
1261 path::begin() const noexcept
1262 {
1263 if (_M_type == _Type::_Multi)
1264 return iterator(this, _M_cmpts.begin());
1265 return iterator(this, false);
1266 }
1267
1268 inline path::iterator
1269 path::end() const noexcept
1270 {
1271 if (_M_type == _Type::_Multi)
1272 return iterator(this, _M_cmpts.end());
1273 return iterator(this, true);
1274 }
1275
1276 inline path::iterator&
1277 path::iterator::operator++() noexcept
1278 {
1279 __glibcxx_assert(_M_path != nullptr);
1280 if (_M_path->_M_type == _Type::_Multi)
1281 {
1282 __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1283 ++_M_cur;
1284 }
1285 else
1286 {
1287 __glibcxx_assert(!_M_at_end);
1288 _M_at_end = true;
1289 }
1290 return *this;
1291 }
1292
1293 inline path::iterator&
1294 path::iterator::operator--() noexcept
1295 {
1296 __glibcxx_assert(_M_path != nullptr);
1297 if (_M_path->_M_type == _Type::_Multi)
1298 {
1299 __glibcxx_assert(_M_cur != _M_path->_M_cmpts.begin());
1300 --_M_cur;
1301 }
1302 else
1303 {
1304 __glibcxx_assert(_M_at_end);
1305 _M_at_end = false;
1306 }
1307 return *this;
1308 }
1309
1310 inline path::iterator::reference
1311 path::iterator::operator*() const noexcept
1312 {
1313 __glibcxx_assert(_M_path != nullptr);
1314 if (_M_path->_M_type == _Type::_Multi)
1315 {
1316 __glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
1317 return *_M_cur;
1318 }
1319 return *_M_path;
1320 }
1321
1322 inline bool
1323 path::iterator::_M_equals(iterator __rhs) const noexcept
1324 {
1325 if (_M_path != __rhs._M_path)
1326 return false;
1327 if (_M_path == nullptr)
1328 return true;
1329 if (_M_path->_M_type == path::_Type::_Multi)
1330 return _M_cur == __rhs._M_cur;
1331 return _M_at_end == __rhs._M_at_end;
1332 }
1333
1334 // Define these now that path and path::iterator are complete.
1335 // They needs to consider the string_view(Range&&) constructor during
1336 // overload resolution, which depends on whether range<path> is satisfied,
1337 // which depends on whether path::iterator is complete.
1338 inline bool operator<(const path& __lhs, const path& __rhs) noexcept
1339 { return __lhs.compare(__rhs) < 0; }
1340
1341 inline bool operator==(const path& __lhs, const path& __rhs) noexcept
1342 { return __lhs.compare(__rhs) == 0; }
1343
1344 /// @} group filesystem-ts
1345_GLIBCXX_END_NAMESPACE_CXX11
1346} // namespace v1
1347} // namespace filesystem
1348} // namespace experimental
1349
1350_GLIBCXX_END_NAMESPACE_VERSION
1351} // namespace std
1352
1353#endif // C++11
1354
1355#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 times y.
Definition: complex:392
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::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