source: Daodan/MSYS2/mingw32/include/c++/11.2.0/experimental/string_view

Last change on this file was 1166, checked in by rossy, 3 years ago

Daodan: Replace MinGW build env with an up-to-date MSYS2 env
File size: 22.0 KB
Line 
1// Components for manipulating non-owning sequences of characters -*- C++ -*-
2
3// Copyright (C) 2013-2021 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/string_view
26 * This is a TS C++ Library header.
27 * @ingroup libfund-ts
28 */
29
30//
31// N3762 basic_string_view library
32//
33
34#ifndef _GLIBCXX_EXPERIMENTAL_STRING_VIEW
35#define _GLIBCXX_EXPERIMENTAL_STRING_VIEW 1
36
37#pragma GCC system_header
38
39#if __cplusplus >= 201402L
40
41#include <string>
42#include <limits>
43#include <bits/ranges_base.h> // enable_borrowed_range, enable_view
44#include <experimental/bits/lfts_config.h>
45
46namespace std _GLIBCXX_VISIBILITY(default)
47{
48_GLIBCXX_BEGIN_NAMESPACE_VERSION
49
50namespace experimental
51{
52inline namespace fundamentals_v1
53{
54#define __cpp_lib_experimental_string_view 201411
55
56 /**
57 * @class basic_string_view <experimental/string_view>
58 * @brief A non-owning reference to a string.
59 *
60 * @ingroup strings
61 * @ingroup sequences
62 * @ingroup libfund-ts
63 *
64 * @tparam _CharT Type of character
65 * @tparam _Traits Traits for character type, defaults to
66 * char_traits<_CharT>.
67 *
68 * A basic_string_view looks like this:
69 *
70 * @code
71 * _CharT* _M_str
72 * size_t _M_len
73 * @endcode
74 */
75 template<typename _CharT, typename _Traits = std::char_traits<_CharT>>
76 class basic_string_view
77 {
78 public:
79
80 // types
81 using traits_type = _Traits;
82 using value_type = _CharT;
83 using pointer = _CharT*;
84 using const_pointer = const _CharT*;
85 using reference = _CharT&;
86 using const_reference = const _CharT&;
87 using const_iterator = const _CharT*;
88 using iterator = const_iterator;
89 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
90 using reverse_iterator = const_reverse_iterator;
91 using size_type = size_t;
92 using difference_type = ptrdiff_t;
93 static constexpr size_type npos = size_type(-1);
94
95 // [string.view.cons], construct/copy
96
97 constexpr
98 basic_string_view() noexcept
99 : _M_len{0}, _M_str{nullptr}
100 { }
101
102 constexpr basic_string_view(const basic_string_view&) noexcept = default;
103
104 template<typename _Allocator>
105 basic_string_view(const basic_string<_CharT, _Traits,
106 _Allocator>& __str) noexcept
107 : _M_len{__str.length()}, _M_str{__str.data()}
108 { }
109
110 constexpr basic_string_view(const _CharT* __str)
111 : _M_len{__str == nullptr ? 0 : traits_type::length(__str)},
112 _M_str{__str}
113 { }
114
115 constexpr basic_string_view(const _CharT* __str, size_type __len)
116 : _M_len{__len},
117 _M_str{__str}
118 { }
119
120 basic_string_view&
121 operator=(const basic_string_view&) noexcept = default;
122
123 // [string.view.iterators], iterators
124
125 constexpr const_iterator
126 begin() const noexcept
127 { return this->_M_str; }
128
129 constexpr const_iterator
130 end() const noexcept
131 { return this->_M_str + this->_M_len; }
132
133 constexpr const_iterator
134 cbegin() const noexcept
135 { return this->_M_str; }
136
137 constexpr const_iterator
138 cend() const noexcept
139 { return this->_M_str + this->_M_len; }
140
141 const_reverse_iterator
142 rbegin() const noexcept
143 { return const_reverse_iterator(this->end()); }
144
145 const_reverse_iterator
146 rend() const noexcept
147 { return const_reverse_iterator(this->begin()); }
148
149 const_reverse_iterator
150 crbegin() const noexcept
151 { return const_reverse_iterator(this->end()); }
152
153 const_reverse_iterator
154 crend() const noexcept
155 { return const_reverse_iterator(this->begin()); }
156
157 // [string.view.capacity], capacity
158
159 constexpr size_type
160 size() const noexcept
161 { return this->_M_len; }
162
163 constexpr size_type
164 length() const noexcept
165 { return _M_len; }
166
167 constexpr size_type
168 max_size() const noexcept
169 {
170 return (npos - sizeof(size_type) - sizeof(void*))
171 / sizeof(value_type) / 4;
172 }
173
174 _GLIBCXX_NODISCARD constexpr bool
175 empty() const noexcept
176 { return this->_M_len == 0; }
177
178 // [string.view.access], element access
179
180 constexpr const _CharT&
181 operator[](size_type __pos) const
182 {
183 __glibcxx_assert(__pos < this->_M_len);
184 return *(this->_M_str + __pos);
185 }
186
187 constexpr const _CharT&
188 at(size_type __pos) const
189 {
190 return __pos < this->_M_len
191 ? *(this->_M_str + __pos)
192 : (__throw_out_of_range_fmt(__N("basic_string_view::at: __pos "
193 "(which is %zu) >= this->size() "
194 "(which is %zu)"),
195 __pos, this->size()),
196 *this->_M_str);
197 }
198
199 constexpr const _CharT&
200 front() const
201 {
202 __glibcxx_assert(this->_M_len > 0);
203 return *this->_M_str;
204 }
205
206 constexpr const _CharT&
207 back() const
208 {
209 __glibcxx_assert(this->_M_len > 0);
210 return *(this->_M_str + this->_M_len - 1);
211 }
212
213 constexpr const _CharT*
214 data() const noexcept
215 { return this->_M_str; }
216
217 // [string.view.modifiers], modifiers:
218
219 constexpr void
220 remove_prefix(size_type __n)
221 {
222 __glibcxx_assert(this->_M_len >= __n);
223 this->_M_str += __n;
224 this->_M_len -= __n;
225 }
226
227 constexpr void
228 remove_suffix(size_type __n)
229 { this->_M_len -= __n; }
230
231 constexpr void
232 swap(basic_string_view& __sv) noexcept
233 {
234 auto __tmp = *this;
235 *this = __sv;
236 __sv = __tmp;
237 }
238
239
240 // [string.view.ops], string operations:
241
242 template<typename _Allocator>
243 explicit operator basic_string<_CharT, _Traits, _Allocator>() const
244 {
245 return { this->_M_str, this->_M_len };
246 }
247
248 template<typename _Allocator = std::allocator<_CharT>>
249 basic_string<_CharT, _Traits, _Allocator>
250 to_string(const _Allocator& __alloc = _Allocator()) const
251 {
252 return { this->_M_str, this->_M_len, __alloc };
253 }
254
255 size_type
256 copy(_CharT* __str, size_type __n, size_type __pos = 0) const
257 {
258 __glibcxx_requires_string_len(__str, __n);
259 if (__pos > this->_M_len)
260 __throw_out_of_range_fmt(__N("basic_string_view::copy: __pos "
261 "(which is %zu) > this->size() "
262 "(which is %zu)"),
263 __pos, this->size());
264 size_type __rlen{std::min(__n, size_type{this->_M_len - __pos})};
265 for (auto __begin = this->_M_str + __pos,
266 __end = __begin + __rlen; __begin != __end;)
267 *__str++ = *__begin++;
268 return __rlen;
269 }
270
271
272 // [string.view.ops], string operations:
273
274 constexpr basic_string_view
275 substr(size_type __pos = 0, size_type __n = npos) const
276 {
277 return __pos <= this->_M_len
278 ? basic_string_view{this->_M_str + __pos,
279 std::min(__n, size_type{this->_M_len - __pos})}
280 : (__throw_out_of_range_fmt(__N("basic_string_view::substr: __pos "
281 "(which is %zu) > this->size() "
282 "(which is %zu)"),
283 __pos, this->size()), basic_string_view{});
284 }
285
286 constexpr int
287 compare(basic_string_view __str) const noexcept
288 {
289 int __ret = traits_type::compare(this->_M_str, __str._M_str,
290 std::min(this->_M_len, __str._M_len));
291 if (__ret == 0)
292 __ret = _S_compare(this->_M_len, __str._M_len);
293 return __ret;
294 }
295
296 constexpr int
297 compare(size_type __pos1, size_type __n1, basic_string_view __str) const
298 { return this->substr(__pos1, __n1).compare(__str); }
299
300 constexpr int
301 compare(size_type __pos1, size_type __n1,
302 basic_string_view __str, size_type __pos2, size_type __n2) const
303 { return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2)); }
304
305 constexpr int
306 compare(const _CharT* __str) const noexcept
307 { return this->compare(basic_string_view{__str}); }
308
309 constexpr int
310 compare(size_type __pos1, size_type __n1, const _CharT* __str) const
311 { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }
312
313 constexpr int
314 compare(size_type __pos1, size_type __n1,
315 const _CharT* __str, size_type __n2) const
316 {
317 return this->substr(__pos1, __n1)
318 .compare(basic_string_view(__str, __n2));
319 }
320
321 constexpr size_type
322 find(basic_string_view __str, size_type __pos = 0) const noexcept
323 { return this->find(__str._M_str, __pos, __str._M_len); }
324
325 constexpr size_type
326 find(_CharT __c, size_type __pos=0) const noexcept;
327
328 constexpr size_type
329 find(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
330
331 constexpr size_type
332 find(const _CharT* __str, size_type __pos=0) const noexcept
333 { return this->find(__str, __pos, traits_type::length(__str)); }
334
335 constexpr size_type
336 rfind(basic_string_view __str, size_type __pos = npos) const noexcept
337 { return this->rfind(__str._M_str, __pos, __str._M_len); }
338
339 constexpr size_type
340 rfind(_CharT __c, size_type __pos = npos) const noexcept;
341
342 constexpr size_type
343 rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
344
345 constexpr size_type
346 rfind(const _CharT* __str, size_type __pos = npos) const noexcept
347 { return this->rfind(__str, __pos, traits_type::length(__str)); }
348
349 constexpr size_type
350 find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
351 { return this->find_first_of(__str._M_str, __pos, __str._M_len); }
352
353 constexpr size_type
354 find_first_of(_CharT __c, size_type __pos = 0) const noexcept
355 { return this->find(__c, __pos); }
356
357 constexpr size_type
358 find_first_of(const _CharT* __str, size_type __pos, size_type __n) const;
359
360 constexpr size_type
361 find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
362 { return this->find_first_of(__str, __pos, traits_type::length(__str)); }
363
364 constexpr size_type
365 find_last_of(basic_string_view __str,
366 size_type __pos = npos) const noexcept
367 { return this->find_last_of(__str._M_str, __pos, __str._M_len); }
368
369 constexpr size_type
370 find_last_of(_CharT __c, size_type __pos=npos) const noexcept
371 { return this->rfind(__c, __pos); }
372
373 constexpr size_type
374 find_last_of(const _CharT* __str, size_type __pos, size_type __n) const;
375
376 constexpr size_type
377 find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
378 { return this->find_last_of(__str, __pos, traits_type::length(__str)); }
379
380 constexpr size_type
381 find_first_not_of(basic_string_view __str,
382 size_type __pos = 0) const noexcept
383 { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }
384
385 constexpr size_type
386 find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;
387
388 constexpr size_type
389 find_first_not_of(const _CharT* __str,
390 size_type __pos, size_type __n) const;
391
392 constexpr size_type
393 find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
394 {
395 return this->find_first_not_of(__str, __pos,
396 traits_type::length(__str));
397 }
398
399 constexpr size_type
400 find_last_not_of(basic_string_view __str,
401 size_type __pos = npos) const noexcept
402 { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }
403
404 constexpr size_type
405 find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;
406
407 constexpr size_type
408 find_last_not_of(const _CharT* __str,
409 size_type __pos, size_type __n) const;
410
411 constexpr size_type
412 find_last_not_of(const _CharT* __str,
413 size_type __pos = npos) const noexcept
414 {
415 return this->find_last_not_of(__str, __pos,
416 traits_type::length(__str));
417 }
418
419 private:
420
421 static constexpr int
422 _S_compare(size_type __n1, size_type __n2) noexcept
423 {
424 return difference_type(__n1 - __n2) > std::numeric_limits<int>::max()
425 ? std::numeric_limits<int>::max()
426 : difference_type(__n1 - __n2) < std::numeric_limits<int>::min()
427 ? std::numeric_limits<int>::min()
428 : static_cast<int>(difference_type(__n1 - __n2));
429 }
430
431 size_t _M_len;
432 const _CharT* _M_str;
433 };
434
435 // [string.view.comparison], non-member basic_string_view comparison functions
436
437 // Several of these functions use type_identity_t to create a non-deduced
438 // context, so that only one argument participates in template argument
439 // deduction and the other argument gets implicitly converted to the deduced
440 // type (see N3766).
441
442 template<typename _CharT, typename _Traits>
443 constexpr bool
444 operator==(basic_string_view<_CharT, _Traits> __x,
445 basic_string_view<_CharT, _Traits> __y) noexcept
446 { return __x.size() == __y.size() && __x.compare(__y) == 0; }
447
448 template<typename _CharT, typename _Traits>
449 constexpr bool
450 operator==(basic_string_view<_CharT, _Traits> __x,
451 __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
452 noexcept
453 { return __x.size() == __y.size() && __x.compare(__y) == 0; }
454
455 template<typename _CharT, typename _Traits>
456 constexpr bool
457 operator==(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
458 basic_string_view<_CharT, _Traits> __y) noexcept
459 { return __x.size() == __y.size() && __x.compare(__y) == 0; }
460
461 template<typename _CharT, typename _Traits>
462 constexpr bool
463 operator!=(basic_string_view<_CharT, _Traits> __x,
464 basic_string_view<_CharT, _Traits> __y) noexcept
465 { return !(__x == __y); }
466
467 template<typename _CharT, typename _Traits>
468 constexpr bool
469 operator!=(basic_string_view<_CharT, _Traits> __x,
470 __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
471 noexcept
472 { return !(__x == __y); }
473
474 template<typename _CharT, typename _Traits>
475 constexpr bool
476 operator!=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
477 basic_string_view<_CharT, _Traits> __y) noexcept
478 { return !(__x == __y); }
479
480 template<typename _CharT, typename _Traits>
481 constexpr bool
482 operator< (basic_string_view<_CharT, _Traits> __x,
483 basic_string_view<_CharT, _Traits> __y) noexcept
484 { return __x.compare(__y) < 0; }
485
486 template<typename _CharT, typename _Traits>
487 constexpr bool
488 operator< (basic_string_view<_CharT, _Traits> __x,
489 __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
490 noexcept
491 { return __x.compare(__y) < 0; }
492
493 template<typename _CharT, typename _Traits>
494 constexpr bool
495 operator< (__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
496 basic_string_view<_CharT, _Traits> __y) noexcept
497 { return __x.compare(__y) < 0; }
498
499 template<typename _CharT, typename _Traits>
500 constexpr bool
501 operator> (basic_string_view<_CharT, _Traits> __x,
502 basic_string_view<_CharT, _Traits> __y) noexcept
503 { return __x.compare(__y) > 0; }
504
505 template<typename _CharT, typename _Traits>
506 constexpr bool
507 operator> (basic_string_view<_CharT, _Traits> __x,
508 __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
509 noexcept
510 { return __x.compare(__y) > 0; }
511
512 template<typename _CharT, typename _Traits>
513 constexpr bool
514 operator> (__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
515 basic_string_view<_CharT, _Traits> __y) noexcept
516 { return __x.compare(__y) > 0; }
517
518 template<typename _CharT, typename _Traits>
519 constexpr bool
520 operator<=(basic_string_view<_CharT, _Traits> __x,
521 basic_string_view<_CharT, _Traits> __y) noexcept
522 { return __x.compare(__y) <= 0; }
523
524 template<typename _CharT, typename _Traits>
525 constexpr bool
526 operator<=(basic_string_view<_CharT, _Traits> __x,
527 __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
528 noexcept
529 { return __x.compare(__y) <= 0; }
530
531 template<typename _CharT, typename _Traits>
532 constexpr bool
533 operator<=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
534 basic_string_view<_CharT, _Traits> __y) noexcept
535 { return __x.compare(__y) <= 0; }
536
537 template<typename _CharT, typename _Traits>
538 constexpr bool
539 operator>=(basic_string_view<_CharT, _Traits> __x,
540 basic_string_view<_CharT, _Traits> __y) noexcept
541 { return __x.compare(__y) >= 0; }
542
543 template<typename _CharT, typename _Traits>
544 constexpr bool
545 operator>=(basic_string_view<_CharT, _Traits> __x,
546 __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
547 noexcept
548 { return __x.compare(__y) >= 0; }
549
550 template<typename _CharT, typename _Traits>
551 constexpr bool
552 operator>=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
553 basic_string_view<_CharT, _Traits> __y) noexcept
554 { return __x.compare(__y) >= 0; }
555
556 // [string.view.io], Inserters and extractors
557 template<typename _CharT, typename _Traits>
558 inline basic_ostream<_CharT, _Traits>&
559 operator<<(basic_ostream<_CharT, _Traits>& __os,
560 basic_string_view<_CharT,_Traits> __str)
561 { return __ostream_insert(__os, __str.data(), __str.size()); }
562
563
564 // basic_string_view typedef names
565
566 using string_view = basic_string_view<char>;
567#ifdef _GLIBCXX_USE_WCHAR_T
568 using wstring_view = basic_string_view<wchar_t>;
569#endif
570#ifdef _GLIBCXX_USE_CHAR8_T
571 using u8string_view = basic_string_view<char8_t>;
572#endif
573 using u16string_view = basic_string_view<char16_t>;
574 using u32string_view = basic_string_view<char32_t>;
575} // namespace fundamentals_v1
576} // namespace experimental
577
578
579 // [string.view.hash], hash support:
580 template<typename _Tp>
581 struct hash;
582
583 template<>
584 struct hash<experimental::string_view>
585 : public __hash_base<size_t, experimental::string_view>
586 {
587 size_t
588 operator()(const experimental::string_view& __str) const noexcept
589 { return std::_Hash_impl::hash(__str.data(), __str.length()); }
590 };
591
592 template<>
593 struct __is_fast_hash<hash<experimental::string_view>> : std::false_type
594 { };
595
596#ifdef _GLIBCXX_USE_WCHAR_T
597 template<>
598 struct hash<experimental::wstring_view>
599 : public __hash_base<size_t, wstring>
600 {
601 size_t
602 operator()(const experimental::wstring_view& __s) const noexcept
603 { return std::_Hash_impl::hash(__s.data(),
604 __s.length() * sizeof(wchar_t)); }
605 };
606
607 template<>
608 struct __is_fast_hash<hash<experimental::wstring_view>> : std::false_type
609 { };
610#endif
611
612#ifdef _GLIBCXX_USE_CHAR8_T
613 template<>
614 struct hash<experimental::u8string_view>
615 : public __hash_base<size_t, experimental::u8string_view>
616 {
617 size_t
618 operator()(const experimental::u8string_view& __s) const noexcept
619 { return std::_Hash_impl::hash(__s.data(), __s.length()); }
620 };
621
622 template<>
623 struct __is_fast_hash<hash<experimental::u8string_view>> : std::false_type
624 { };
625#endif
626
627 template<>
628 struct hash<experimental::u16string_view>
629 : public __hash_base<size_t, experimental::u16string_view>
630 {
631 size_t
632 operator()(const experimental::u16string_view& __s) const noexcept
633 { return std::_Hash_impl::hash(__s.data(),
634 __s.length() * sizeof(char16_t)); }
635 };
636
637 template<>
638 struct __is_fast_hash<hash<experimental::u16string_view>> : std::false_type
639 { };
640
641 template<>
642 struct hash<experimental::u32string_view>
643 : public __hash_base<size_t, experimental::u32string_view>
644 {
645 size_t
646 operator()(const experimental::u32string_view& __s) const noexcept
647 { return std::_Hash_impl::hash(__s.data(),
648 __s.length() * sizeof(char32_t)); }
649 };
650
651 template<>
652 struct __is_fast_hash<hash<experimental::u32string_view>> : std::false_type
653 { };
654
655namespace experimental
656{
657 // I added these EMSR.
658 inline namespace literals
659 {
660 inline namespace string_view_literals
661 {
662#pragma GCC diagnostic push
663#pragma GCC diagnostic ignored "-Wliteral-suffix"
664 inline constexpr basic_string_view<char>
665 operator""sv(const char* __str, size_t __len) noexcept
666 { return basic_string_view<char>{__str, __len}; }
667
668#ifdef _GLIBCXX_USE_WCHAR_T
669 inline constexpr basic_string_view<wchar_t>
670 operator""sv(const wchar_t* __str, size_t __len) noexcept
671 { return basic_string_view<wchar_t>{__str, __len}; }
672#endif
673
674#ifdef _GLIBCXX_USE_CHAR8_T
675 inline constexpr basic_string_view<char8_t>
676 operator""sv(const char8_t* __str, size_t __len) noexcept
677 { return basic_string_view<char8_t>{__str, __len}; }
678#endif
679
680 inline constexpr basic_string_view<char16_t>
681 operator""sv(const char16_t* __str, size_t __len) noexcept
682 { return basic_string_view<char16_t>{__str, __len}; }
683
684 inline constexpr basic_string_view<char32_t>
685 operator""sv(const char32_t* __str, size_t __len) noexcept
686 { return basic_string_view<char32_t>{__str, __len}; }
687#pragma GCC diagnostic pop
688 } // namespace string_literals
689 } // namespace literals
690} // namespace experimental
691
692#if __cpp_lib_concepts
693 namespace ranges
694 {
695 // Opt-in to borrowed_range concept
696 template<typename _CharT, typename _Traits>
697 inline constexpr bool
698 enable_borrowed_range<experimental::basic_string_view<_CharT, _Traits>>
699 = true;
700
701 // Opt-in to view concept
702 template<typename _CharT, typename _Traits>
703 inline constexpr bool
704 enable_view<experimental::basic_string_view<_CharT, _Traits>> = true;
705 }
706#endif
707
708_GLIBCXX_END_NAMESPACE_VERSION
709} // namespace std
710
711#include <experimental/bits/string_view.tcc>
712
713#endif // __cplusplus <= 201103L
714
715#endif // _GLIBCXX_EXPERIMENTAL_STRING_VIEW
Note: See TracBrowser for help on using the repository browser.