Line data Source code
1 : // Components for manipulating sequences of characters -*- C++ -*-
2 :
3 : // Copyright (C) 1997-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 bits/basic_string.h
26 : * This is an internal header file, included by other library headers.
27 : * Do not attempt to use it directly. @headername{string}
28 : */
29 :
30 : //
31 : // ISO C++ 14882: 21 Strings library
32 : //
33 :
34 : #ifndef _BASIC_STRING_H
35 : #define _BASIC_STRING_H 1
36 :
37 : #pragma GCC system_header
38 :
39 : #include <ext/alloc_traits.h>
40 : #include <debug/debug.h>
41 :
42 : #if __cplusplus >= 201103L
43 : #include <initializer_list>
44 : #endif
45 :
46 : #if __cplusplus >= 201703L
47 : # include <string_view>
48 : #endif
49 :
50 : #if ! _GLIBCXX_USE_CXX11_ABI
51 : # include "cow_string.h"
52 : #else
53 : namespace std _GLIBCXX_VISIBILITY(default)
54 : {
55 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
56 : _GLIBCXX_BEGIN_NAMESPACE_CXX11
57 :
58 : #ifdef __cpp_lib_is_constant_evaluated
59 : // Support P0980R1 in C++20.
60 : # define __cpp_lib_constexpr_string 201907L
61 : #elif __cplusplus >= 201703L && _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
62 : // Support P0426R1 changes to char_traits in C++17.
63 : # define __cpp_lib_constexpr_string 201611L
64 : #endif
65 :
66 : /**
67 : * @class basic_string basic_string.h <string>
68 : * @brief Managing sequences of characters and character-like objects.
69 : *
70 : * @ingroup strings
71 : * @ingroup sequences
72 : *
73 : * @tparam _CharT Type of character
74 : * @tparam _Traits Traits for character type, defaults to
75 : * char_traits<_CharT>.
76 : * @tparam _Alloc Allocator type, defaults to allocator<_CharT>.
77 : *
78 : * Meets the requirements of a <a href="tables.html#65">container</a>, a
79 : * <a href="tables.html#66">reversible container</a>, and a
80 : * <a href="tables.html#67">sequence</a>. Of the
81 : * <a href="tables.html#68">optional sequence requirements</a>, only
82 : * @c push_back, @c at, and @c %array access are supported.
83 : */
84 : template<typename _CharT, typename _Traits, typename _Alloc>
85 : class basic_string
86 : {
87 : typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
88 : rebind<_CharT>::other _Char_alloc_type;
89 :
90 : #if __cpp_lib_constexpr_string < 201907L
91 : typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
92 : #else
93 : template<typename _Traits2, typename _Dummy_for_PR85282>
94 : struct _Alloc_traits_impl : __gnu_cxx::__alloc_traits<_Char_alloc_type>
95 : {
96 : typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Base;
97 :
98 : [[__gnu__::__always_inline__]]
99 : static constexpr typename _Base::pointer
100 : allocate(_Char_alloc_type& __a, typename _Base::size_type __n)
101 : {
102 : pointer __p = _Base::allocate(__a, __n);
103 : if (std::is_constant_evaluated())
104 : // Begin the lifetime of characters in allocated storage.
105 : for (size_type __i = 0; __i < __n; ++__i)
106 : std::construct_at(__builtin_addressof(__p[__i]));
107 : return __p;
108 : }
109 : };
110 :
111 : template<typename _Dummy_for_PR85282>
112 : struct _Alloc_traits_impl<char_traits<_CharT>, _Dummy_for_PR85282>
113 : : __gnu_cxx::__alloc_traits<_Char_alloc_type>
114 : {
115 : // std::char_traits begins the lifetime of characters.
116 : };
117 :
118 : using _Alloc_traits = _Alloc_traits_impl<_Traits, void>;
119 : #endif
120 :
121 : // Types:
122 : public:
123 : typedef _Traits traits_type;
124 : typedef typename _Traits::char_type value_type;
125 : typedef _Char_alloc_type allocator_type;
126 : typedef typename _Alloc_traits::size_type size_type;
127 : typedef typename _Alloc_traits::difference_type difference_type;
128 : typedef typename _Alloc_traits::reference reference;
129 : typedef typename _Alloc_traits::const_reference const_reference;
130 : typedef typename _Alloc_traits::pointer pointer;
131 : typedef typename _Alloc_traits::const_pointer const_pointer;
132 : typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
133 : typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
134 : const_iterator;
135 : typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
136 : typedef std::reverse_iterator<iterator> reverse_iterator;
137 :
138 : /// Value returned by various member functions when they fail.
139 : static const size_type npos = static_cast<size_type>(-1);
140 :
141 : protected:
142 : // type used for positions in insert, erase etc.
143 : #if __cplusplus < 201103L
144 : typedef iterator __const_iterator;
145 : #else
146 : typedef const_iterator __const_iterator;
147 : #endif
148 :
149 : private:
150 : #if __cplusplus >= 201703L
151 : // A helper type for avoiding boiler-plate.
152 : typedef basic_string_view<_CharT, _Traits> __sv_type;
153 :
154 : template<typename _Tp, typename _Res>
155 : using _If_sv = enable_if_t<
156 : __and_<is_convertible<const _Tp&, __sv_type>,
157 : __not_<is_convertible<const _Tp*, const basic_string*>>,
158 : __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
159 : _Res>;
160 :
161 : // Allows an implicit conversion to __sv_type.
162 : _GLIBCXX20_CONSTEXPR
163 : static __sv_type
164 : _S_to_string_view(__sv_type __svt) noexcept
165 : { return __svt; }
166 :
167 : // Wraps a string_view by explicit conversion and thus
168 : // allows to add an internal constructor that does not
169 : // participate in overload resolution when a string_view
170 : // is provided.
171 : struct __sv_wrapper
172 : {
173 : _GLIBCXX20_CONSTEXPR explicit
174 : __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }
175 :
176 : __sv_type _M_sv;
177 : };
178 :
179 : /**
180 : * @brief Only internally used: Construct string from a string view
181 : * wrapper.
182 : * @param __svw string view wrapper.
183 : * @param __a Allocator to use.
184 : */
185 : _GLIBCXX20_CONSTEXPR
186 : explicit
187 : basic_string(__sv_wrapper __svw, const _Alloc& __a)
188 : : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }
189 : #endif
190 :
191 : // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
192 91475 : struct _Alloc_hider : allocator_type // TODO check __is_final
193 : {
194 : #if __cplusplus < 201103L
195 : _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
196 : : allocator_type(__a), _M_p(__dat) { }
197 : #else
198 : _GLIBCXX20_CONSTEXPR
199 5815 : _Alloc_hider(pointer __dat, const _Alloc& __a)
200 5815 : : allocator_type(__a), _M_p(__dat) { }
201 :
202 : _GLIBCXX20_CONSTEXPR
203 5767 : _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
204 2894 : : allocator_type(std::move(__a)), _M_p(__dat) { }
205 : #endif
206 :
207 : pointer _M_p; // The actual data.
208 : };
209 :
210 : _Alloc_hider _M_dataplus;
211 : size_type _M_string_length;
212 :
213 : enum { _S_local_capacity = 15 / sizeof(_CharT) };
214 :
215 : union
216 : {
217 : _CharT _M_local_buf[_S_local_capacity + 1];
218 : size_type _M_allocated_capacity;
219 : };
220 :
221 : _GLIBCXX20_CONSTEXPR
222 : void
223 24005 : _M_data(pointer __p)
224 24005 : { _M_dataplus._M_p = __p; }
225 :
226 : _GLIBCXX20_CONSTEXPR
227 : void
228 82511 : _M_length(size_type __length)
229 82511 : { _M_string_length = __length; }
230 :
231 : _GLIBCXX20_CONSTEXPR
232 : pointer
233 169703 : _M_data() const
234 58852 : { return _M_dataplus._M_p; }
235 :
236 : _GLIBCXX20_CONSTEXPR
237 : pointer
238 2894 : _M_local_data()
239 : {
240 : #if __cplusplus >= 201103L
241 8610 : return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
242 : #else
243 : return pointer(_M_local_buf);
244 : #endif
245 : }
246 :
247 : _GLIBCXX20_CONSTEXPR
248 : const_pointer
249 : _M_local_data() const
250 : {
251 : #if __cplusplus >= 201103L
252 : return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
253 : #else
254 : return const_pointer(_M_local_buf);
255 : #endif
256 : }
257 :
258 : _GLIBCXX20_CONSTEXPR
259 : void
260 24005 : _M_capacity(size_type __capacity)
261 24005 : { _M_allocated_capacity = __capacity; }
262 :
263 : _GLIBCXX20_CONSTEXPR
264 : void
265 82511 : _M_set_length(size_type __n)
266 : {
267 82511 : _M_length(__n);
268 82511 : traits_type::assign(_M_data()[__n], _CharT());
269 : }
270 :
271 : _GLIBCXX20_CONSTEXPR
272 : bool
273 : _M_is_local() const
274 : {
275 : if (_M_data() == _M_local_data())
276 : {
277 : if (_M_string_length > _S_local_capacity)
278 : __builtin_unreachable();
279 : return true;
280 : }
281 : return false;
282 : }
283 :
284 : // Create & Destroy
285 : _GLIBCXX20_CONSTEXPR
286 : pointer
287 : _M_create(size_type&, size_type);
288 :
289 : _GLIBCXX20_CONSTEXPR
290 : void
291 : _M_dispose()
292 : {
293 : if (!_M_is_local())
294 : _M_destroy(_M_allocated_capacity);
295 : }
296 :
297 : _GLIBCXX20_CONSTEXPR
298 : void
299 : _M_destroy(size_type __size) throw()
300 : { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
301 :
302 : #if __cplusplus < 201103L || defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
303 : // _M_construct_aux is used to implement the 21.3.1 para 15 which
304 : // requires special behaviour if _InIterator is an integral type
305 : template<typename _InIterator>
306 : void
307 : _M_construct_aux(_InIterator __beg, _InIterator __end,
308 : std::__false_type)
309 : {
310 : typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
311 : _M_construct(__beg, __end, _Tag());
312 : }
313 :
314 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
315 : // 438. Ambiguity in the "do the right thing" clause
316 : template<typename _Integer>
317 : void
318 : _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
319 : { _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
320 :
321 : void
322 : _M_construct_aux_2(size_type __req, _CharT __c)
323 : { _M_construct(__req, __c); }
324 : #endif
325 :
326 : // For Input Iterators, used in istreambuf_iterators, etc.
327 : template<typename _InIterator>
328 : _GLIBCXX20_CONSTEXPR
329 : void
330 : _M_construct(_InIterator __beg, _InIterator __end,
331 : std::input_iterator_tag);
332 :
333 : // For forward_iterators up to random_access_iterators, used for
334 : // string::iterator, _CharT*, etc.
335 : template<typename _FwdIterator>
336 : _GLIBCXX20_CONSTEXPR
337 : void
338 : _M_construct(_FwdIterator __beg, _FwdIterator __end,
339 : std::forward_iterator_tag);
340 :
341 : _GLIBCXX20_CONSTEXPR
342 : void
343 : _M_construct(size_type __req, _CharT __c);
344 :
345 : _GLIBCXX20_CONSTEXPR
346 : allocator_type&
347 : _M_get_allocator()
348 : { return _M_dataplus; }
349 :
350 : _GLIBCXX20_CONSTEXPR
351 : const allocator_type&
352 : _M_get_allocator() const
353 : { return _M_dataplus; }
354 :
355 : // Ensure that _M_local_buf is the active member of the union.
356 : __attribute__((__always_inline__))
357 : _GLIBCXX14_CONSTEXPR
358 : pointer
359 37152 : _M_use_local_data() _GLIBCXX_NOEXCEPT
360 : {
361 : #if __cpp_lib_is_constant_evaluated
362 : if (std::is_constant_evaluated())
363 : for (size_type __i = 0; __i <= _S_local_capacity; ++__i)
364 : _M_local_buf[__i] = _CharT();
365 : #endif
366 31385 : return _M_local_data();
367 : }
368 :
369 : private:
370 :
371 : #ifdef _GLIBCXX_DISAMBIGUATE_REPLACE_INST
372 : // The explicit instantiations in misc-inst.cc require this due to
373 : // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64063
374 : template<typename _Tp, bool _Requires =
375 : !__are_same<_Tp, _CharT*>::__value
376 : && !__are_same<_Tp, const _CharT*>::__value
377 : && !__are_same<_Tp, iterator>::__value
378 : && !__are_same<_Tp, const_iterator>::__value>
379 : struct __enable_if_not_native_iterator
380 : { typedef basic_string& __type; };
381 : template<typename _Tp>
382 : struct __enable_if_not_native_iterator<_Tp, false> { };
383 : #endif
384 :
385 : _GLIBCXX20_CONSTEXPR
386 : size_type
387 : _M_check(size_type __pos, const char* __s) const
388 : {
389 : if (__pos > this->size())
390 : __throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > "
391 : "this->size() (which is %zu)"),
392 : __s, __pos, this->size());
393 : return __pos;
394 : }
395 :
396 : _GLIBCXX20_CONSTEXPR
397 : void
398 : _M_check_length(size_type __n1, size_type __n2, const char* __s) const
399 : {
400 : if (this->max_size() - (this->size() - __n1) < __n2)
401 : __throw_length_error(__N(__s));
402 : }
403 :
404 :
405 : // NB: _M_limit doesn't check for a bad __pos value.
406 : _GLIBCXX20_CONSTEXPR
407 : size_type
408 : _M_limit(size_type __pos, size_type __off) const _GLIBCXX_NOEXCEPT
409 : {
410 : const bool __testoff = __off < this->size() - __pos;
411 : return __testoff ? __off : this->size() - __pos;
412 : }
413 :
414 : // True if _Rep and source do not overlap.
415 : bool
416 : _M_disjunct(const _CharT* __s) const _GLIBCXX_NOEXCEPT
417 : {
418 : return (less<const _CharT*>()(__s, _M_data())
419 : || less<const _CharT*>()(_M_data() + this->size(), __s));
420 : }
421 :
422 : // When __n = 1 way faster than the general multichar
423 : // traits_type::copy/move/assign.
424 : _GLIBCXX20_CONSTEXPR
425 : static void
426 : _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
427 : {
428 : if (__n == 1)
429 : traits_type::assign(*__d, *__s);
430 : else
431 : traits_type::copy(__d, __s, __n);
432 : }
433 :
434 : _GLIBCXX20_CONSTEXPR
435 : static void
436 : _S_move(_CharT* __d, const _CharT* __s, size_type __n)
437 : {
438 : if (__n == 1)
439 : traits_type::assign(*__d, *__s);
440 : else
441 : traits_type::move(__d, __s, __n);
442 : }
443 :
444 : _GLIBCXX20_CONSTEXPR
445 : static void
446 : _S_assign(_CharT* __d, size_type __n, _CharT __c)
447 : {
448 : if (__n == 1)
449 : traits_type::assign(*__d, __c);
450 : else
451 : traits_type::assign(__d, __n, __c);
452 : }
453 :
454 : // _S_copy_chars is a separate template to permit specialization
455 : // to optimize for the common case of pointers as iterators.
456 : template<class _Iterator>
457 : _GLIBCXX20_CONSTEXPR
458 : static void
459 : _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
460 : {
461 : for (; __k1 != __k2; ++__k1, (void)++__p)
462 : traits_type::assign(*__p, *__k1); // These types are off.
463 : }
464 :
465 : _GLIBCXX20_CONSTEXPR
466 : static void
467 : _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) _GLIBCXX_NOEXCEPT
468 : { _S_copy_chars(__p, __k1.base(), __k2.base()); }
469 :
470 : _GLIBCXX20_CONSTEXPR
471 : static void
472 : _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
473 : _GLIBCXX_NOEXCEPT
474 : { _S_copy_chars(__p, __k1.base(), __k2.base()); }
475 :
476 : _GLIBCXX20_CONSTEXPR
477 : static void
478 49572 : _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) _GLIBCXX_NOEXCEPT
479 49572 : { _S_copy(__p, __k1, __k2 - __k1); }
480 :
481 : _GLIBCXX20_CONSTEXPR
482 : static void
483 5818 : _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
484 : _GLIBCXX_NOEXCEPT
485 5818 : { _S_copy(__p, __k1, __k2 - __k1); }
486 :
487 : _GLIBCXX20_CONSTEXPR
488 : static int
489 : _S_compare(size_type __n1, size_type __n2) _GLIBCXX_NOEXCEPT
490 : {
491 : const difference_type __d = difference_type(__n1 - __n2);
492 :
493 : if (__d > __gnu_cxx::__numeric_traits<int>::__max)
494 : return __gnu_cxx::__numeric_traits<int>::__max;
495 : else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
496 : return __gnu_cxx::__numeric_traits<int>::__min;
497 : else
498 : return int(__d);
499 : }
500 :
501 : _GLIBCXX20_CONSTEXPR
502 : void
503 : _M_assign(const basic_string&);
504 :
505 : _GLIBCXX20_CONSTEXPR
506 : void
507 : _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
508 : size_type __len2);
509 :
510 : _GLIBCXX20_CONSTEXPR
511 : void
512 : _M_erase(size_type __pos, size_type __n);
513 :
514 : public:
515 : // Construct/copy/destroy:
516 : // NB: We overload ctors in some cases instead of using default
517 : // arguments, per 17.4.4.4 para. 2 item 2.
518 :
519 : /**
520 : * @brief Default constructor creates an empty string.
521 : */
522 : _GLIBCXX20_CONSTEXPR
523 5767 : basic_string()
524 : _GLIBCXX_NOEXCEPT_IF(is_nothrow_default_constructible<_Alloc>::value)
525 2894 : : _M_dataplus(_M_local_data())
526 : {
527 2894 : _M_use_local_data();
528 5767 : _M_set_length(0);
529 3 : }
530 :
531 : /**
532 : * @brief Construct an empty string using allocator @a a.
533 : */
534 : _GLIBCXX20_CONSTEXPR
535 : explicit
536 : basic_string(const _Alloc& __a) _GLIBCXX_NOEXCEPT
537 : : _M_dataplus(_M_local_data(), __a)
538 : {
539 : _M_use_local_data();
540 : _M_set_length(0);
541 : }
542 :
543 : /**
544 : * @brief Construct string with copy of value of @a __str.
545 : * @param __str Source string.
546 : */
547 : _GLIBCXX20_CONSTEXPR
548 : basic_string(const basic_string& __str)
549 : : _M_dataplus(_M_local_data(),
550 : _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
551 : {
552 : _M_construct(__str._M_data(), __str._M_data() + __str.length(),
553 : std::forward_iterator_tag());
554 : }
555 :
556 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
557 : // 2583. no way to supply an allocator for basic_string(str, pos)
558 : /**
559 : * @brief Construct string as copy of a substring.
560 : * @param __str Source string.
561 : * @param __pos Index of first character to copy from.
562 : * @param __a Allocator to use.
563 : */
564 : _GLIBCXX20_CONSTEXPR
565 : basic_string(const basic_string& __str, size_type __pos,
566 : const _Alloc& __a = _Alloc())
567 : : _M_dataplus(_M_local_data(), __a)
568 : {
569 : const _CharT* __start = __str._M_data()
570 : + __str._M_check(__pos, "basic_string::basic_string");
571 : _M_construct(__start, __start + __str._M_limit(__pos, npos),
572 : std::forward_iterator_tag());
573 : }
574 :
575 : /**
576 : * @brief Construct string as copy of a substring.
577 : * @param __str Source string.
578 : * @param __pos Index of first character to copy from.
579 : * @param __n Number of characters to copy.
580 : */
581 : _GLIBCXX20_CONSTEXPR
582 : basic_string(const basic_string& __str, size_type __pos,
583 : size_type __n)
584 : : _M_dataplus(_M_local_data())
585 : {
586 : const _CharT* __start = __str._M_data()
587 : + __str._M_check(__pos, "basic_string::basic_string");
588 : _M_construct(__start, __start + __str._M_limit(__pos, __n),
589 : std::forward_iterator_tag());
590 : }
591 :
592 : /**
593 : * @brief Construct string as copy of a substring.
594 : * @param __str Source string.
595 : * @param __pos Index of first character to copy from.
596 : * @param __n Number of characters to copy.
597 : * @param __a Allocator to use.
598 : */
599 : _GLIBCXX20_CONSTEXPR
600 : basic_string(const basic_string& __str, size_type __pos,
601 : size_type __n, const _Alloc& __a)
602 : : _M_dataplus(_M_local_data(), __a)
603 : {
604 : const _CharT* __start
605 : = __str._M_data() + __str._M_check(__pos, "string::string");
606 : _M_construct(__start, __start + __str._M_limit(__pos, __n),
607 : std::forward_iterator_tag());
608 : }
609 :
610 : /**
611 : * @brief Construct string initialized by a character %array.
612 : * @param __s Source character %array.
613 : * @param __n Number of characters to copy.
614 : * @param __a Allocator to use (default is default allocator).
615 : *
616 : * NB: @a __s must have at least @a __n characters, '\\0'
617 : * has no special meaning.
618 : */
619 : _GLIBCXX20_CONSTEXPR
620 : basic_string(const _CharT* __s, size_type __n,
621 : const _Alloc& __a = _Alloc())
622 : : _M_dataplus(_M_local_data(), __a)
623 : {
624 : // NB: Not required, but considered best practice.
625 : if (__s == 0 && __n > 0)
626 : std::__throw_logic_error(__N("basic_string: "
627 : "construction from null is not valid"));
628 : _M_construct(__s, __s + __n, std::forward_iterator_tag());
629 : }
630 :
631 : /**
632 : * @brief Construct string as copy of a C string.
633 : * @param __s Source C string.
634 : * @param __a Allocator to use (default is default allocator).
635 : */
636 : #if __cpp_deduction_guides && ! defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
637 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
638 : // 3076. basic_string CTAD ambiguity
639 : template<typename = _RequireAllocator<_Alloc>>
640 : #endif
641 : _GLIBCXX20_CONSTEXPR
642 5737 : basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
643 5737 : : _M_dataplus(_M_local_data(), __a)
644 : {
645 : // NB: Not required, but considered best practice.
646 5737 : if (__s == 0)
647 0 : std::__throw_logic_error(__N("basic_string: "
648 : "construction from null is not valid"));
649 5737 : const _CharT* __end = __s + traits_type::length(__s);
650 5737 : _M_construct(__s, __end, forward_iterator_tag());
651 5737 : }
652 :
653 : /**
654 : * @brief Construct string as multiple characters.
655 : * @param __n Number of characters.
656 : * @param __c Character to use.
657 : * @param __a Allocator to use (default is default allocator).
658 : */
659 : #if __cpp_deduction_guides && ! defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
660 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
661 : // 3076. basic_string CTAD ambiguity
662 : template<typename = _RequireAllocator<_Alloc>>
663 : #endif
664 : _GLIBCXX20_CONSTEXPR
665 : basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
666 : : _M_dataplus(_M_local_data(), __a)
667 : { _M_construct(__n, __c); }
668 :
669 : #if __cplusplus >= 201103L
670 : /**
671 : * @brief Move construct string.
672 : * @param __str Source string.
673 : *
674 : * The newly-created string contains the exact contents of @a __str.
675 : * @a __str is a valid, but unspecified string.
676 : */
677 : _GLIBCXX20_CONSTEXPR
678 : basic_string(basic_string&& __str) noexcept
679 : : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
680 : {
681 : if (__str._M_is_local())
682 : {
683 : traits_type::copy(_M_local_buf, __str._M_local_buf,
684 : __str.length() + 1);
685 : }
686 : else
687 : {
688 : _M_data(__str._M_data());
689 : _M_capacity(__str._M_allocated_capacity);
690 : }
691 :
692 : // Must use _M_length() here not _M_set_length() because
693 : // basic_stringbuf relies on writing into unallocated capacity so
694 : // we mess up the contents if we put a '\0' in the string.
695 : _M_length(__str.length());
696 : __str._M_data(__str._M_local_data());
697 : __str._M_set_length(0);
698 : }
699 :
700 : /**
701 : * @brief Construct string from an initializer %list.
702 : * @param __l std::initializer_list of characters.
703 : * @param __a Allocator to use (default is default allocator).
704 : */
705 : _GLIBCXX20_CONSTEXPR
706 : basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
707 : : _M_dataplus(_M_local_data(), __a)
708 : { _M_construct(__l.begin(), __l.end(), std::forward_iterator_tag()); }
709 :
710 : _GLIBCXX20_CONSTEXPR
711 : basic_string(const basic_string& __str, const _Alloc& __a)
712 : : _M_dataplus(_M_local_data(), __a)
713 : { _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); }
714 :
715 : _GLIBCXX20_CONSTEXPR
716 : basic_string(basic_string&& __str, const _Alloc& __a)
717 : noexcept(_Alloc_traits::_S_always_equal())
718 : : _M_dataplus(_M_local_data(), __a)
719 : {
720 : if (__str._M_is_local())
721 : {
722 : traits_type::copy(_M_local_buf, __str._M_local_buf,
723 : __str.length() + 1);
724 : _M_length(__str.length());
725 : __str._M_set_length(0);
726 : }
727 : else if (_Alloc_traits::_S_always_equal()
728 : || __str.get_allocator() == __a)
729 : {
730 : _M_data(__str._M_data());
731 : _M_length(__str.length());
732 : _M_capacity(__str._M_allocated_capacity);
733 : __str._M_data(__str._M_local_buf);
734 : __str._M_set_length(0);
735 : }
736 : else
737 : _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag());
738 : }
739 : #endif // C++11
740 :
741 : #if __cplusplus >= 202100L
742 : basic_string(nullptr_t) = delete;
743 : basic_string& operator=(nullptr_t) = delete;
744 : #endif // C++23
745 :
746 : /**
747 : * @brief Construct string as copy of a range.
748 : * @param __beg Start of range.
749 : * @param __end End of range.
750 : * @param __a Allocator to use (default is default allocator).
751 : */
752 : #if __cplusplus >= 201103L
753 : template<typename _InputIterator,
754 : typename = std::_RequireInputIter<_InputIterator>>
755 : #else
756 : template<typename _InputIterator>
757 : #endif
758 : _GLIBCXX20_CONSTEXPR
759 78 : basic_string(_InputIterator __beg, _InputIterator __end,
760 : const _Alloc& __a = _Alloc())
761 78 : : _M_dataplus(_M_local_data(), __a), _M_string_length(0)
762 : {
763 : #if __cplusplus >= 201103L
764 78 : _M_construct(__beg, __end, std::__iterator_category(__beg));
765 : #else
766 : typedef typename std::__is_integer<_InputIterator>::__type _Integral;
767 : _M_construct_aux(__beg, __end, _Integral());
768 : #endif
769 : }
770 :
771 : #if __cplusplus >= 201703L
772 : /**
773 : * @brief Construct string from a substring of a string_view.
774 : * @param __t Source object convertible to string view.
775 : * @param __pos The index of the first character to copy from __t.
776 : * @param __n The number of characters to copy from __t.
777 : * @param __a Allocator to use.
778 : */
779 : template<typename _Tp,
780 : typename = enable_if_t<is_convertible_v<const _Tp&, __sv_type>>>
781 : _GLIBCXX20_CONSTEXPR
782 : basic_string(const _Tp& __t, size_type __pos, size_type __n,
783 : const _Alloc& __a = _Alloc())
784 : : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }
785 :
786 : /**
787 : * @brief Construct string from a string_view.
788 : * @param __t Source object convertible to string view.
789 : * @param __a Allocator to use (default is default allocator).
790 : */
791 : template<typename _Tp, typename = _If_sv<_Tp, void>>
792 : _GLIBCXX20_CONSTEXPR
793 : explicit
794 : basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
795 : : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }
796 : #endif // C++17
797 :
798 : /**
799 : * @brief Destroy the string instance.
800 : */
801 : _GLIBCXX20_CONSTEXPR
802 30470 : ~basic_string()
803 61005 : { _M_dispose(); }
804 :
805 : /**
806 : * @brief Assign the value of @a str to this string.
807 : * @param __str Source string.
808 : */
809 : _GLIBCXX20_CONSTEXPR
810 : basic_string&
811 : operator=(const basic_string& __str)
812 : {
813 : return this->assign(__str);
814 : }
815 :
816 : /**
817 : * @brief Copy contents of @a s into this string.
818 : * @param __s Source null-terminated string.
819 : */
820 : _GLIBCXX20_CONSTEXPR
821 : basic_string&
822 48 : operator=(const _CharT* __s)
823 48 : { return this->assign(__s); }
824 :
825 : /**
826 : * @brief Set value to string of length 1.
827 : * @param __c Source character.
828 : *
829 : * Assigning to a character makes this string length 1 and
830 : * (*this)[0] == @a c.
831 : */
832 : _GLIBCXX20_CONSTEXPR
833 : basic_string&
834 : operator=(_CharT __c)
835 : {
836 : this->assign(1, __c);
837 : return *this;
838 : }
839 :
840 : #if __cplusplus >= 201103L
841 : /**
842 : * @brief Move assign the value of @a str to this string.
843 : * @param __str Source string.
844 : *
845 : * The contents of @a str are moved into this string (without copying).
846 : * @a str is a valid, but unspecified string.
847 : */
848 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
849 : // 2063. Contradictory requirements for string move assignment
850 : _GLIBCXX20_CONSTEXPR
851 : basic_string&
852 : operator=(basic_string&& __str)
853 : noexcept(_Alloc_traits::_S_nothrow_move())
854 : {
855 : if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
856 : && !_Alloc_traits::_S_always_equal()
857 : && _M_get_allocator() != __str._M_get_allocator())
858 : {
859 : // Destroy existing storage before replacing allocator.
860 : _M_destroy(_M_allocated_capacity);
861 : _M_data(_M_local_data());
862 : _M_set_length(0);
863 : }
864 : // Replace allocator if POCMA is true.
865 : std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
866 :
867 : if (__str._M_is_local())
868 : {
869 : // We've always got room for a short string, just copy it
870 : // (unless this is a self-move, because that would violate the
871 : // char_traits::copy precondition that the ranges don't overlap).
872 : if (__builtin_expect(std::__addressof(__str) != this, true))
873 : {
874 : if (__str.size())
875 : this->_S_copy(_M_data(), __str._M_data(), __str.size());
876 : _M_set_length(__str.size());
877 : }
878 : }
879 : else if (_Alloc_traits::_S_propagate_on_move_assign()
880 : || _Alloc_traits::_S_always_equal()
881 : || _M_get_allocator() == __str._M_get_allocator())
882 : {
883 : // Just move the allocated pointer, our allocator can free it.
884 : pointer __data = nullptr;
885 : size_type __capacity;
886 : if (!_M_is_local())
887 : {
888 : if (_Alloc_traits::_S_always_equal())
889 : {
890 : // __str can reuse our existing storage.
891 : __data = _M_data();
892 : __capacity = _M_allocated_capacity;
893 : }
894 : else // __str can't use it, so free it.
895 : _M_destroy(_M_allocated_capacity);
896 : }
897 :
898 : _M_data(__str._M_data());
899 : _M_length(__str.length());
900 : _M_capacity(__str._M_allocated_capacity);
901 : if (__data)
902 : {
903 : __str._M_data(__data);
904 : __str._M_capacity(__capacity);
905 : }
906 : else
907 : __str._M_data(__str._M_local_buf);
908 : }
909 : else // Need to do a deep copy
910 : assign(__str);
911 : __str.clear();
912 : return *this;
913 : }
914 :
915 : /**
916 : * @brief Set value to string constructed from initializer %list.
917 : * @param __l std::initializer_list.
918 : */
919 : _GLIBCXX20_CONSTEXPR
920 : basic_string&
921 : operator=(initializer_list<_CharT> __l)
922 : {
923 : this->assign(__l.begin(), __l.size());
924 : return *this;
925 : }
926 : #endif // C++11
927 :
928 : #if __cplusplus >= 201703L
929 : /**
930 : * @brief Set value to string constructed from a string_view.
931 : * @param __svt An object convertible to string_view.
932 : */
933 : template<typename _Tp>
934 : _GLIBCXX20_CONSTEXPR
935 : _If_sv<_Tp, basic_string&>
936 : operator=(const _Tp& __svt)
937 : { return this->assign(__svt); }
938 :
939 : /**
940 : * @brief Convert to a string_view.
941 : * @return A string_view.
942 : */
943 : _GLIBCXX20_CONSTEXPR
944 : operator __sv_type() const noexcept
945 : { return __sv_type(data(), size()); }
946 : #endif // C++17
947 :
948 : // Iterators:
949 : /**
950 : * Returns a read/write iterator that points to the first character in
951 : * the %string.
952 : */
953 : _GLIBCXX20_CONSTEXPR
954 : iterator
955 : begin() _GLIBCXX_NOEXCEPT
956 : { return iterator(_M_data()); }
957 :
958 : /**
959 : * Returns a read-only (constant) iterator that points to the first
960 : * character in the %string.
961 : */
962 : _GLIBCXX20_CONSTEXPR
963 : const_iterator
964 : begin() const _GLIBCXX_NOEXCEPT
965 : { return const_iterator(_M_data()); }
966 :
967 : /**
968 : * Returns a read/write iterator that points one past the last
969 : * character in the %string.
970 : */
971 : _GLIBCXX20_CONSTEXPR
972 : iterator
973 : end() _GLIBCXX_NOEXCEPT
974 : { return iterator(_M_data() + this->size()); }
975 :
976 : /**
977 : * Returns a read-only (constant) iterator that points one past the
978 : * last character in the %string.
979 : */
980 : _GLIBCXX20_CONSTEXPR
981 : const_iterator
982 : end() const _GLIBCXX_NOEXCEPT
983 : { return const_iterator(_M_data() + this->size()); }
984 :
985 : /**
986 : * Returns a read/write reverse iterator that points to the last
987 : * character in the %string. Iteration is done in reverse element
988 : * order.
989 : */
990 : _GLIBCXX20_CONSTEXPR
991 : reverse_iterator
992 : rbegin() _GLIBCXX_NOEXCEPT
993 : { return reverse_iterator(this->end()); }
994 :
995 : /**
996 : * Returns a read-only (constant) reverse iterator that points
997 : * to the last character in the %string. Iteration is done in
998 : * reverse element order.
999 : */
1000 : _GLIBCXX20_CONSTEXPR
1001 : const_reverse_iterator
1002 : rbegin() const _GLIBCXX_NOEXCEPT
1003 : { return const_reverse_iterator(this->end()); }
1004 :
1005 : /**
1006 : * Returns a read/write reverse iterator that points to one before the
1007 : * first character in the %string. Iteration is done in reverse
1008 : * element order.
1009 : */
1010 : _GLIBCXX20_CONSTEXPR
1011 : reverse_iterator
1012 : rend() _GLIBCXX_NOEXCEPT
1013 : { return reverse_iterator(this->begin()); }
1014 :
1015 : /**
1016 : * Returns a read-only (constant) reverse iterator that points
1017 : * to one before the first character in the %string. Iteration
1018 : * is done in reverse element order.
1019 : */
1020 : _GLIBCXX20_CONSTEXPR
1021 : const_reverse_iterator
1022 : rend() const _GLIBCXX_NOEXCEPT
1023 : { return const_reverse_iterator(this->begin()); }
1024 :
1025 : #if __cplusplus >= 201103L
1026 : /**
1027 : * Returns a read-only (constant) iterator that points to the first
1028 : * character in the %string.
1029 : */
1030 : _GLIBCXX20_CONSTEXPR
1031 : const_iterator
1032 : cbegin() const noexcept
1033 : { return const_iterator(this->_M_data()); }
1034 :
1035 : /**
1036 : * Returns a read-only (constant) iterator that points one past the
1037 : * last character in the %string.
1038 : */
1039 : _GLIBCXX20_CONSTEXPR
1040 : const_iterator
1041 : cend() const noexcept
1042 : { return const_iterator(this->_M_data() + this->size()); }
1043 :
1044 : /**
1045 : * Returns a read-only (constant) reverse iterator that points
1046 : * to the last character in the %string. Iteration is done in
1047 : * reverse element order.
1048 : */
1049 : _GLIBCXX20_CONSTEXPR
1050 : const_reverse_iterator
1051 : crbegin() const noexcept
1052 : { return const_reverse_iterator(this->end()); }
1053 :
1054 : /**
1055 : * Returns a read-only (constant) reverse iterator that points
1056 : * to one before the first character in the %string. Iteration
1057 : * is done in reverse element order.
1058 : */
1059 : _GLIBCXX20_CONSTEXPR
1060 : const_reverse_iterator
1061 : crend() const noexcept
1062 : { return const_reverse_iterator(this->begin()); }
1063 : #endif
1064 :
1065 : public:
1066 : // Capacity:
1067 : /// Returns the number of characters in the string, not including any
1068 : /// null-termination.
1069 : _GLIBCXX20_CONSTEXPR
1070 : size_type
1071 82107 : size() const _GLIBCXX_NOEXCEPT
1072 79204 : { return _M_string_length; }
1073 :
1074 : /// Returns the number of characters in the string, not including any
1075 : /// null-termination.
1076 : _GLIBCXX20_CONSTEXPR
1077 : size_type
1078 : length() const _GLIBCXX_NOEXCEPT
1079 : { return _M_string_length; }
1080 :
1081 : /// Returns the size() of the largest possible %string.
1082 : _GLIBCXX20_CONSTEXPR
1083 : size_type
1084 : max_size() const _GLIBCXX_NOEXCEPT
1085 : { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
1086 :
1087 : /**
1088 : * @brief Resizes the %string to the specified number of characters.
1089 : * @param __n Number of characters the %string should contain.
1090 : * @param __c Character to fill any new elements.
1091 : *
1092 : * This function will %resize the %string to the specified
1093 : * number of characters. If the number is smaller than the
1094 : * %string's current size the %string is truncated, otherwise
1095 : * the %string is extended and new elements are %set to @a __c.
1096 : */
1097 : _GLIBCXX20_CONSTEXPR
1098 : void
1099 : resize(size_type __n, _CharT __c);
1100 :
1101 : /**
1102 : * @brief Resizes the %string to the specified number of characters.
1103 : * @param __n Number of characters the %string should contain.
1104 : *
1105 : * This function will resize the %string to the specified length. If
1106 : * the new size is smaller than the %string's current size the %string
1107 : * is truncated, otherwise the %string is extended and new characters
1108 : * are default-constructed. For basic types such as char, this means
1109 : * setting them to 0.
1110 : */
1111 : _GLIBCXX20_CONSTEXPR
1112 : void
1113 : resize(size_type __n)
1114 : { this->resize(__n, _CharT()); }
1115 :
1116 : #if __cplusplus >= 201103L
1117 : #pragma GCC diagnostic push
1118 : #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1119 : /// A non-binding request to reduce capacity() to size().
1120 : _GLIBCXX20_CONSTEXPR
1121 : void
1122 : shrink_to_fit() noexcept
1123 : { reserve(); }
1124 : #pragma GCC diagnostic pop
1125 : #endif
1126 :
1127 : #if __cplusplus > 202002L
1128 : #define __cpp_lib_string_resize_and_overwrite 202110L
1129 : template<typename _Operation>
1130 : constexpr void
1131 : resize_and_overwrite(size_type __n, _Operation __op);
1132 : #endif
1133 :
1134 : /**
1135 : * Returns the total number of characters that the %string can hold
1136 : * before needing to allocate more memory.
1137 : */
1138 : _GLIBCXX20_CONSTEXPR
1139 : size_type
1140 : capacity() const _GLIBCXX_NOEXCEPT
1141 : {
1142 : return _M_is_local() ? size_type(_S_local_capacity)
1143 : : _M_allocated_capacity;
1144 : }
1145 :
1146 : /**
1147 : * @brief Attempt to preallocate enough memory for specified number of
1148 : * characters.
1149 : * @param __res_arg Number of characters required.
1150 : * @throw std::length_error If @a __res_arg exceeds @c max_size().
1151 : *
1152 : * This function attempts to reserve enough memory for the
1153 : * %string to hold the specified number of characters. If the
1154 : * number requested is more than max_size(), length_error is
1155 : * thrown.
1156 : *
1157 : * The advantage of this function is that if optimal code is a
1158 : * necessity and the user can determine the string length that will be
1159 : * required, the user can reserve the memory in %advance, and thus
1160 : * prevent a possible reallocation of memory and copying of %string
1161 : * data.
1162 : */
1163 : _GLIBCXX20_CONSTEXPR
1164 : void
1165 : reserve(size_type __res_arg);
1166 :
1167 : /**
1168 : * Equivalent to shrink_to_fit().
1169 : */
1170 : #if __cplusplus > 201703L
1171 : [[deprecated("use shrink_to_fit() instead")]]
1172 : #endif
1173 : _GLIBCXX20_CONSTEXPR
1174 : void
1175 : reserve();
1176 :
1177 : /**
1178 : * Erases the string, making it empty.
1179 : */
1180 : _GLIBCXX20_CONSTEXPR
1181 : void
1182 21354 : clear() _GLIBCXX_NOEXCEPT
1183 21354 : { _M_set_length(0); }
1184 :
1185 : /**
1186 : * Returns true if the %string is empty. Equivalent to
1187 : * <code>*this == ""</code>.
1188 : */
1189 : _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1190 : bool
1191 76262 : empty() const _GLIBCXX_NOEXCEPT
1192 76262 : { return this->size() == 0; }
1193 :
1194 : // Element access:
1195 : /**
1196 : * @brief Subscript access to the data contained in the %string.
1197 : * @param __pos The index of the character to access.
1198 : * @return Read-only (constant) reference to the character.
1199 : *
1200 : * This operator allows for easy, array-style, data access.
1201 : * Note that data access with this operator is unchecked and
1202 : * out_of_range lookups are not defined. (For checked lookups
1203 : * see at().)
1204 : */
1205 : _GLIBCXX20_CONSTEXPR
1206 : const_reference
1207 : operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
1208 : {
1209 : __glibcxx_assert(__pos <= size());
1210 : return _M_data()[__pos];
1211 : }
1212 :
1213 : /**
1214 : * @brief Subscript access to the data contained in the %string.
1215 : * @param __pos The index of the character to access.
1216 : * @return Read/write reference to the character.
1217 : *
1218 : * This operator allows for easy, array-style, data access.
1219 : * Note that data access with this operator is unchecked and
1220 : * out_of_range lookups are not defined. (For checked lookups
1221 : * see at().)
1222 : */
1223 : _GLIBCXX20_CONSTEXPR
1224 : reference
1225 87 : operator[](size_type __pos)
1226 : {
1227 : // Allow pos == size() both in C++98 mode, as v3 extension,
1228 : // and in C++11 mode.
1229 87 : __glibcxx_assert(__pos <= size());
1230 : // In pedantic mode be strict in C++98 mode.
1231 : _GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L || __pos < size());
1232 81 : return _M_data()[__pos];
1233 : }
1234 :
1235 : /**
1236 : * @brief Provides access to the data contained in the %string.
1237 : * @param __n The index of the character to access.
1238 : * @return Read-only (const) reference to the character.
1239 : * @throw std::out_of_range If @a n is an invalid index.
1240 : *
1241 : * This function provides for safer data access. The parameter is
1242 : * first checked that it is in the range of the string. The function
1243 : * throws out_of_range if the check fails.
1244 : */
1245 : _GLIBCXX20_CONSTEXPR
1246 : const_reference
1247 : at(size_type __n) const
1248 : {
1249 : if (__n >= this->size())
1250 : __throw_out_of_range_fmt(__N("basic_string::at: __n "
1251 : "(which is %zu) >= this->size() "
1252 : "(which is %zu)"),
1253 : __n, this->size());
1254 : return _M_data()[__n];
1255 : }
1256 :
1257 : /**
1258 : * @brief Provides access to the data contained in the %string.
1259 : * @param __n The index of the character to access.
1260 : * @return Read/write reference to the character.
1261 : * @throw std::out_of_range If @a n is an invalid index.
1262 : *
1263 : * This function provides for safer data access. The parameter is
1264 : * first checked that it is in the range of the string. The function
1265 : * throws out_of_range if the check fails.
1266 : */
1267 : _GLIBCXX20_CONSTEXPR
1268 : reference
1269 : at(size_type __n)
1270 : {
1271 : if (__n >= size())
1272 : __throw_out_of_range_fmt(__N("basic_string::at: __n "
1273 : "(which is %zu) >= this->size() "
1274 : "(which is %zu)"),
1275 : __n, this->size());
1276 : return _M_data()[__n];
1277 : }
1278 :
1279 : #if __cplusplus >= 201103L
1280 : /**
1281 : * Returns a read/write reference to the data at the first
1282 : * element of the %string.
1283 : */
1284 : _GLIBCXX20_CONSTEXPR
1285 : reference
1286 : front() noexcept
1287 : {
1288 : __glibcxx_assert(!empty());
1289 : return operator[](0);
1290 : }
1291 :
1292 : /**
1293 : * Returns a read-only (constant) reference to the data at the first
1294 : * element of the %string.
1295 : */
1296 : _GLIBCXX20_CONSTEXPR
1297 : const_reference
1298 : front() const noexcept
1299 : {
1300 : __glibcxx_assert(!empty());
1301 : return operator[](0);
1302 : }
1303 :
1304 : /**
1305 : * Returns a read/write reference to the data at the last
1306 : * element of the %string.
1307 : */
1308 : _GLIBCXX20_CONSTEXPR
1309 : reference
1310 : back() noexcept
1311 : {
1312 : __glibcxx_assert(!empty());
1313 : return operator[](this->size() - 1);
1314 : }
1315 :
1316 : /**
1317 : * Returns a read-only (constant) reference to the data at the
1318 : * last element of the %string.
1319 : */
1320 : _GLIBCXX20_CONSTEXPR
1321 : const_reference
1322 : back() const noexcept
1323 : {
1324 : __glibcxx_assert(!empty());
1325 : return operator[](this->size() - 1);
1326 : }
1327 : #endif
1328 :
1329 : // Modifiers:
1330 : /**
1331 : * @brief Append a string to this string.
1332 : * @param __str The string to append.
1333 : * @return Reference to this string.
1334 : */
1335 : _GLIBCXX20_CONSTEXPR
1336 : basic_string&
1337 : operator+=(const basic_string& __str)
1338 : { return this->append(__str); }
1339 :
1340 : /**
1341 : * @brief Append a C string.
1342 : * @param __s The C string to append.
1343 : * @return Reference to this string.
1344 : */
1345 : _GLIBCXX20_CONSTEXPR
1346 : basic_string&
1347 : operator+=(const _CharT* __s)
1348 : { return this->append(__s); }
1349 :
1350 : /**
1351 : * @brief Append a character.
1352 : * @param __c The character to append.
1353 : * @return Reference to this string.
1354 : */
1355 : _GLIBCXX20_CONSTEXPR
1356 : basic_string&
1357 : operator+=(_CharT __c)
1358 : {
1359 : this->push_back(__c);
1360 : return *this;
1361 : }
1362 :
1363 : #if __cplusplus >= 201103L
1364 : /**
1365 : * @brief Append an initializer_list of characters.
1366 : * @param __l The initializer_list of characters to be appended.
1367 : * @return Reference to this string.
1368 : */
1369 : _GLIBCXX20_CONSTEXPR
1370 : basic_string&
1371 : operator+=(initializer_list<_CharT> __l)
1372 : { return this->append(__l.begin(), __l.size()); }
1373 : #endif // C++11
1374 :
1375 : #if __cplusplus >= 201703L
1376 : /**
1377 : * @brief Append a string_view.
1378 : * @param __svt An object convertible to string_view to be appended.
1379 : * @return Reference to this string.
1380 : */
1381 : template<typename _Tp>
1382 : _GLIBCXX20_CONSTEXPR
1383 : _If_sv<_Tp, basic_string&>
1384 : operator+=(const _Tp& __svt)
1385 : { return this->append(__svt); }
1386 : #endif // C++17
1387 :
1388 : /**
1389 : * @brief Append a string to this string.
1390 : * @param __str The string to append.
1391 : * @return Reference to this string.
1392 : */
1393 : _GLIBCXX20_CONSTEXPR
1394 : basic_string&
1395 9 : append(const basic_string& __str)
1396 9 : { return this->append(__str._M_data(), __str.size()); }
1397 :
1398 : /**
1399 : * @brief Append a substring.
1400 : * @param __str The string to append.
1401 : * @param __pos Index of the first character of str to append.
1402 : * @param __n The number of characters to append.
1403 : * @return Reference to this string.
1404 : * @throw std::out_of_range if @a __pos is not a valid index.
1405 : *
1406 : * This function appends @a __n characters from @a __str
1407 : * starting at @a __pos to this string. If @a __n is is larger
1408 : * than the number of available characters in @a __str, the
1409 : * remainder of @a __str is appended.
1410 : */
1411 : _GLIBCXX20_CONSTEXPR
1412 : basic_string&
1413 : append(const basic_string& __str, size_type __pos, size_type __n = npos)
1414 : { return this->append(__str._M_data()
1415 : + __str._M_check(__pos, "basic_string::append"),
1416 : __str._M_limit(__pos, __n)); }
1417 :
1418 : /**
1419 : * @brief Append a C substring.
1420 : * @param __s The C string to append.
1421 : * @param __n The number of characters to append.
1422 : * @return Reference to this string.
1423 : */
1424 : _GLIBCXX20_CONSTEXPR
1425 : basic_string&
1426 : append(const _CharT* __s, size_type __n)
1427 : {
1428 : __glibcxx_requires_string_len(__s, __n);
1429 : _M_check_length(size_type(0), __n, "basic_string::append");
1430 : return _M_append(__s, __n);
1431 : }
1432 :
1433 : /**
1434 : * @brief Append a C string.
1435 : * @param __s The C string to append.
1436 : * @return Reference to this string.
1437 : */
1438 : _GLIBCXX20_CONSTEXPR
1439 : basic_string&
1440 : append(const _CharT* __s)
1441 : {
1442 : __glibcxx_requires_string(__s);
1443 : const size_type __n = traits_type::length(__s);
1444 : _M_check_length(size_type(0), __n, "basic_string::append");
1445 : return _M_append(__s, __n);
1446 : }
1447 :
1448 : /**
1449 : * @brief Append multiple characters.
1450 : * @param __n The number of characters to append.
1451 : * @param __c The character to use.
1452 : * @return Reference to this string.
1453 : *
1454 : * Appends __n copies of __c to this string.
1455 : */
1456 : _GLIBCXX20_CONSTEXPR
1457 : basic_string&
1458 : append(size_type __n, _CharT __c)
1459 : { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
1460 :
1461 : #if __cplusplus >= 201103L
1462 : /**
1463 : * @brief Append an initializer_list of characters.
1464 : * @param __l The initializer_list of characters to append.
1465 : * @return Reference to this string.
1466 : */
1467 : _GLIBCXX20_CONSTEXPR
1468 : basic_string&
1469 : append(initializer_list<_CharT> __l)
1470 : { return this->append(__l.begin(), __l.size()); }
1471 : #endif // C++11
1472 :
1473 : /**
1474 : * @brief Append a range of characters.
1475 : * @param __first Iterator referencing the first character to append.
1476 : * @param __last Iterator marking the end of the range.
1477 : * @return Reference to this string.
1478 : *
1479 : * Appends characters in the range [__first,__last) to this string.
1480 : */
1481 : #if __cplusplus >= 201103L
1482 : template<class _InputIterator,
1483 : typename = std::_RequireInputIter<_InputIterator>>
1484 : _GLIBCXX20_CONSTEXPR
1485 : #else
1486 : template<class _InputIterator>
1487 : #endif
1488 : basic_string&
1489 : append(_InputIterator __first, _InputIterator __last)
1490 : { return this->replace(end(), end(), __first, __last); }
1491 :
1492 : #if __cplusplus >= 201703L
1493 : /**
1494 : * @brief Append a string_view.
1495 : * @param __svt An object convertible to string_view to be appended.
1496 : * @return Reference to this string.
1497 : */
1498 : template<typename _Tp>
1499 : _GLIBCXX20_CONSTEXPR
1500 : _If_sv<_Tp, basic_string&>
1501 : append(const _Tp& __svt)
1502 : {
1503 : __sv_type __sv = __svt;
1504 : return this->append(__sv.data(), __sv.size());
1505 : }
1506 :
1507 : /**
1508 : * @brief Append a range of characters from a string_view.
1509 : * @param __svt An object convertible to string_view to be appended from.
1510 : * @param __pos The position in the string_view to append from.
1511 : * @param __n The number of characters to append from the string_view.
1512 : * @return Reference to this string.
1513 : */
1514 : template<typename _Tp>
1515 : _GLIBCXX20_CONSTEXPR
1516 : _If_sv<_Tp, basic_string&>
1517 : append(const _Tp& __svt, size_type __pos, size_type __n = npos)
1518 : {
1519 : __sv_type __sv = __svt;
1520 : return _M_append(__sv.data()
1521 : + std::__sv_check(__sv.size(), __pos, "basic_string::append"),
1522 : std::__sv_limit(__sv.size(), __pos, __n));
1523 : }
1524 : #endif // C++17
1525 :
1526 : /**
1527 : * @brief Append a single character.
1528 : * @param __c Character to append.
1529 : */
1530 : _GLIBCXX20_CONSTEXPR
1531 : void
1532 : push_back(_CharT __c)
1533 : {
1534 : const size_type __size = this->size();
1535 : if (__size + 1 > this->capacity())
1536 : this->_M_mutate(__size, size_type(0), 0, size_type(1));
1537 : traits_type::assign(this->_M_data()[__size], __c);
1538 : this->_M_set_length(__size + 1);
1539 : }
1540 :
1541 : /**
1542 : * @brief Set value to contents of another string.
1543 : * @param __str Source string to use.
1544 : * @return Reference to this string.
1545 : */
1546 : _GLIBCXX20_CONSTEXPR
1547 : basic_string&
1548 : assign(const basic_string& __str)
1549 : {
1550 : #if __cplusplus >= 201103L
1551 : if (_Alloc_traits::_S_propagate_on_copy_assign())
1552 : {
1553 : if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
1554 : && _M_get_allocator() != __str._M_get_allocator())
1555 : {
1556 : // Propagating allocator cannot free existing storage so must
1557 : // deallocate it before replacing current allocator.
1558 : if (__str.size() <= _S_local_capacity)
1559 : {
1560 : _M_destroy(_M_allocated_capacity);
1561 : _M_data(_M_use_local_data());
1562 : _M_set_length(0);
1563 : }
1564 : else
1565 : {
1566 : const auto __len = __str.size();
1567 : auto __alloc = __str._M_get_allocator();
1568 : // If this allocation throws there are no effects:
1569 : auto __ptr = _Alloc_traits::allocate(__alloc, __len + 1);
1570 : _M_destroy(_M_allocated_capacity);
1571 : _M_data(__ptr);
1572 : _M_capacity(__len);
1573 : _M_set_length(__len);
1574 : }
1575 : }
1576 : std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
1577 : }
1578 : #endif
1579 : this->_M_assign(__str);
1580 : return *this;
1581 : }
1582 :
1583 : #if __cplusplus >= 201103L
1584 : /**
1585 : * @brief Set value to contents of another string.
1586 : * @param __str Source string to use.
1587 : * @return Reference to this string.
1588 : *
1589 : * This function sets this string to the exact contents of @a __str.
1590 : * @a __str is a valid, but unspecified string.
1591 : */
1592 : _GLIBCXX20_CONSTEXPR
1593 : basic_string&
1594 : assign(basic_string&& __str)
1595 : noexcept(_Alloc_traits::_S_nothrow_move())
1596 : {
1597 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1598 : // 2063. Contradictory requirements for string move assignment
1599 : return *this = std::move(__str);
1600 : }
1601 : #endif // C++11
1602 :
1603 : /**
1604 : * @brief Set value to a substring of a string.
1605 : * @param __str The string to use.
1606 : * @param __pos Index of the first character of str.
1607 : * @param __n Number of characters to use.
1608 : * @return Reference to this string.
1609 : * @throw std::out_of_range if @a pos is not a valid index.
1610 : *
1611 : * This function sets this string to the substring of @a __str
1612 : * consisting of @a __n characters at @a __pos. If @a __n is
1613 : * is larger than the number of available characters in @a
1614 : * __str, the remainder of @a __str is used.
1615 : */
1616 : _GLIBCXX20_CONSTEXPR
1617 : basic_string&
1618 : assign(const basic_string& __str, size_type __pos, size_type __n = npos)
1619 : { return _M_replace(size_type(0), this->size(), __str._M_data()
1620 : + __str._M_check(__pos, "basic_string::assign"),
1621 : __str._M_limit(__pos, __n)); }
1622 :
1623 : /**
1624 : * @brief Set value to a C substring.
1625 : * @param __s The C string to use.
1626 : * @param __n Number of characters to use.
1627 : * @return Reference to this string.
1628 : *
1629 : * This function sets the value of this string to the first @a __n
1630 : * characters of @a __s. If @a __n is is larger than the number of
1631 : * available characters in @a __s, the remainder of @a __s is used.
1632 : */
1633 : _GLIBCXX20_CONSTEXPR
1634 : basic_string&
1635 : assign(const _CharT* __s, size_type __n)
1636 : {
1637 : __glibcxx_requires_string_len(__s, __n);
1638 : return _M_replace(size_type(0), this->size(), __s, __n);
1639 : }
1640 :
1641 : /**
1642 : * @brief Set value to contents of a C string.
1643 : * @param __s The C string to use.
1644 : * @return Reference to this string.
1645 : *
1646 : * This function sets the value of this string to the value of @a __s.
1647 : * The data is copied, so there is no dependence on @a __s once the
1648 : * function returns.
1649 : */
1650 : _GLIBCXX20_CONSTEXPR
1651 : basic_string&
1652 : assign(const _CharT* __s)
1653 : {
1654 : __glibcxx_requires_string(__s);
1655 : return _M_replace(size_type(0), this->size(), __s,
1656 : traits_type::length(__s));
1657 : }
1658 :
1659 : /**
1660 : * @brief Set value to multiple characters.
1661 : * @param __n Length of the resulting string.
1662 : * @param __c The character to use.
1663 : * @return Reference to this string.
1664 : *
1665 : * This function sets the value of this string to @a __n copies of
1666 : * character @a __c.
1667 : */
1668 : _GLIBCXX20_CONSTEXPR
1669 : basic_string&
1670 : assign(size_type __n, _CharT __c)
1671 : { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
1672 :
1673 : /**
1674 : * @brief Set value to a range of characters.
1675 : * @param __first Iterator referencing the first character to append.
1676 : * @param __last Iterator marking the end of the range.
1677 : * @return Reference to this string.
1678 : *
1679 : * Sets value of string to characters in the range [__first,__last).
1680 : */
1681 : #if __cplusplus >= 201103L
1682 : template<class _InputIterator,
1683 : typename = std::_RequireInputIter<_InputIterator>>
1684 : _GLIBCXX20_CONSTEXPR
1685 : #else
1686 : template<class _InputIterator>
1687 : #endif
1688 : basic_string&
1689 : assign(_InputIterator __first, _InputIterator __last)
1690 : { return this->replace(begin(), end(), __first, __last); }
1691 :
1692 : #if __cplusplus >= 201103L
1693 : /**
1694 : * @brief Set value to an initializer_list of characters.
1695 : * @param __l The initializer_list of characters to assign.
1696 : * @return Reference to this string.
1697 : */
1698 : _GLIBCXX20_CONSTEXPR
1699 : basic_string&
1700 : assign(initializer_list<_CharT> __l)
1701 : { return this->assign(__l.begin(), __l.size()); }
1702 : #endif // C++11
1703 :
1704 : #if __cplusplus >= 201703L
1705 : /**
1706 : * @brief Set value from a string_view.
1707 : * @param __svt The source object convertible to string_view.
1708 : * @return Reference to this string.
1709 : */
1710 : template<typename _Tp>
1711 : _GLIBCXX20_CONSTEXPR
1712 : _If_sv<_Tp, basic_string&>
1713 : assign(const _Tp& __svt)
1714 : {
1715 : __sv_type __sv = __svt;
1716 : return this->assign(__sv.data(), __sv.size());
1717 : }
1718 :
1719 : /**
1720 : * @brief Set value from a range of characters in a string_view.
1721 : * @param __svt The source object convertible to string_view.
1722 : * @param __pos The position in the string_view to assign from.
1723 : * @param __n The number of characters to assign.
1724 : * @return Reference to this string.
1725 : */
1726 : template<typename _Tp>
1727 : _GLIBCXX20_CONSTEXPR
1728 : _If_sv<_Tp, basic_string&>
1729 : assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
1730 : {
1731 : __sv_type __sv = __svt;
1732 : return _M_replace(size_type(0), this->size(),
1733 : __sv.data()
1734 : + std::__sv_check(__sv.size(), __pos, "basic_string::assign"),
1735 : std::__sv_limit(__sv.size(), __pos, __n));
1736 : }
1737 : #endif // C++17
1738 :
1739 : #if __cplusplus >= 201103L
1740 : /**
1741 : * @brief Insert multiple characters.
1742 : * @param __p Const_iterator referencing location in string to
1743 : * insert at.
1744 : * @param __n Number of characters to insert
1745 : * @param __c The character to insert.
1746 : * @return Iterator referencing the first inserted char.
1747 : * @throw std::length_error If new length exceeds @c max_size().
1748 : *
1749 : * Inserts @a __n copies of character @a __c starting at the
1750 : * position referenced by iterator @a __p. If adding
1751 : * characters causes the length to exceed max_size(),
1752 : * length_error is thrown. The value of the string doesn't
1753 : * change if an error is thrown.
1754 : */
1755 : _GLIBCXX20_CONSTEXPR
1756 : iterator
1757 : insert(const_iterator __p, size_type __n, _CharT __c)
1758 : {
1759 : _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1760 : const size_type __pos = __p - begin();
1761 : this->replace(__p, __p, __n, __c);
1762 : return iterator(this->_M_data() + __pos);
1763 : }
1764 : #else
1765 : /**
1766 : * @brief Insert multiple characters.
1767 : * @param __p Iterator referencing location in string to insert at.
1768 : * @param __n Number of characters to insert
1769 : * @param __c The character to insert.
1770 : * @throw std::length_error If new length exceeds @c max_size().
1771 : *
1772 : * Inserts @a __n copies of character @a __c starting at the
1773 : * position referenced by iterator @a __p. If adding
1774 : * characters causes the length to exceed max_size(),
1775 : * length_error is thrown. The value of the string doesn't
1776 : * change if an error is thrown.
1777 : */
1778 : void
1779 : insert(iterator __p, size_type __n, _CharT __c)
1780 : { this->replace(__p, __p, __n, __c); }
1781 : #endif
1782 :
1783 : #if __cplusplus >= 201103L
1784 : /**
1785 : * @brief Insert a range of characters.
1786 : * @param __p Const_iterator referencing location in string to
1787 : * insert at.
1788 : * @param __beg Start of range.
1789 : * @param __end End of range.
1790 : * @return Iterator referencing the first inserted char.
1791 : * @throw std::length_error If new length exceeds @c max_size().
1792 : *
1793 : * Inserts characters in range [beg,end). If adding characters
1794 : * causes the length to exceed max_size(), length_error is
1795 : * thrown. The value of the string doesn't change if an error
1796 : * is thrown.
1797 : */
1798 : template<class _InputIterator,
1799 : typename = std::_RequireInputIter<_InputIterator>>
1800 : _GLIBCXX20_CONSTEXPR
1801 : iterator
1802 : insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
1803 : {
1804 : _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1805 : const size_type __pos = __p - begin();
1806 : this->replace(__p, __p, __beg, __end);
1807 : return iterator(this->_M_data() + __pos);
1808 : }
1809 : #else
1810 : /**
1811 : * @brief Insert a range of characters.
1812 : * @param __p Iterator referencing location in string to insert at.
1813 : * @param __beg Start of range.
1814 : * @param __end End of range.
1815 : * @throw std::length_error If new length exceeds @c max_size().
1816 : *
1817 : * Inserts characters in range [__beg,__end). If adding
1818 : * characters causes the length to exceed max_size(),
1819 : * length_error is thrown. The value of the string doesn't
1820 : * change if an error is thrown.
1821 : */
1822 : template<class _InputIterator>
1823 : void
1824 : insert(iterator __p, _InputIterator __beg, _InputIterator __end)
1825 : { this->replace(__p, __p, __beg, __end); }
1826 : #endif
1827 :
1828 : #if __cplusplus >= 201103L
1829 : /**
1830 : * @brief Insert an initializer_list of characters.
1831 : * @param __p Iterator referencing location in string to insert at.
1832 : * @param __l The initializer_list of characters to insert.
1833 : * @throw std::length_error If new length exceeds @c max_size().
1834 : */
1835 : _GLIBCXX20_CONSTEXPR
1836 : iterator
1837 : insert(const_iterator __p, initializer_list<_CharT> __l)
1838 : { return this->insert(__p, __l.begin(), __l.end()); }
1839 :
1840 : #ifdef _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
1841 : // See PR libstdc++/83328
1842 : void
1843 : insert(iterator __p, initializer_list<_CharT> __l)
1844 : {
1845 : _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1846 : this->insert(__p - begin(), __l.begin(), __l.size());
1847 : }
1848 : #endif
1849 : #endif // C++11
1850 :
1851 : /**
1852 : * @brief Insert value of a string.
1853 : * @param __pos1 Position in string to insert at.
1854 : * @param __str The string to insert.
1855 : * @return Reference to this string.
1856 : * @throw std::length_error If new length exceeds @c max_size().
1857 : *
1858 : * Inserts value of @a __str starting at @a __pos1. If adding
1859 : * characters causes the length to exceed max_size(),
1860 : * length_error is thrown. The value of the string doesn't
1861 : * change if an error is thrown.
1862 : */
1863 : _GLIBCXX20_CONSTEXPR
1864 : basic_string&
1865 : insert(size_type __pos1, const basic_string& __str)
1866 : { return this->replace(__pos1, size_type(0),
1867 : __str._M_data(), __str.size()); }
1868 :
1869 : /**
1870 : * @brief Insert a substring.
1871 : * @param __pos1 Position in string to insert at.
1872 : * @param __str The string to insert.
1873 : * @param __pos2 Start of characters in str to insert.
1874 : * @param __n Number of characters to insert.
1875 : * @return Reference to this string.
1876 : * @throw std::length_error If new length exceeds @c max_size().
1877 : * @throw std::out_of_range If @a pos1 > size() or
1878 : * @a __pos2 > @a str.size().
1879 : *
1880 : * Starting at @a pos1, insert @a __n character of @a __str
1881 : * beginning with @a __pos2. If adding characters causes the
1882 : * length to exceed max_size(), length_error is thrown. If @a
1883 : * __pos1 is beyond the end of this string or @a __pos2 is
1884 : * beyond the end of @a __str, out_of_range is thrown. The
1885 : * value of the string doesn't change if an error is thrown.
1886 : */
1887 : _GLIBCXX20_CONSTEXPR
1888 : basic_string&
1889 : insert(size_type __pos1, const basic_string& __str,
1890 : size_type __pos2, size_type __n = npos)
1891 : { return this->replace(__pos1, size_type(0), __str._M_data()
1892 : + __str._M_check(__pos2, "basic_string::insert"),
1893 : __str._M_limit(__pos2, __n)); }
1894 :
1895 : /**
1896 : * @brief Insert a C substring.
1897 : * @param __pos Position in string to insert at.
1898 : * @param __s The C string to insert.
1899 : * @param __n The number of characters to insert.
1900 : * @return Reference to this string.
1901 : * @throw std::length_error If new length exceeds @c max_size().
1902 : * @throw std::out_of_range If @a __pos is beyond the end of this
1903 : * string.
1904 : *
1905 : * Inserts the first @a __n characters of @a __s starting at @a
1906 : * __pos. If adding characters causes the length to exceed
1907 : * max_size(), length_error is thrown. If @a __pos is beyond
1908 : * end(), out_of_range is thrown. The value of the string
1909 : * doesn't change if an error is thrown.
1910 : */
1911 : _GLIBCXX20_CONSTEXPR
1912 : basic_string&
1913 : insert(size_type __pos, const _CharT* __s, size_type __n)
1914 : { return this->replace(__pos, size_type(0), __s, __n); }
1915 :
1916 : /**
1917 : * @brief Insert a C string.
1918 : * @param __pos Position in string to insert at.
1919 : * @param __s The C string to insert.
1920 : * @return Reference to this string.
1921 : * @throw std::length_error If new length exceeds @c max_size().
1922 : * @throw std::out_of_range If @a pos is beyond the end of this
1923 : * string.
1924 : *
1925 : * Inserts the first @a n characters of @a __s starting at @a __pos. If
1926 : * adding characters causes the length to exceed max_size(),
1927 : * length_error is thrown. If @a __pos is beyond end(), out_of_range is
1928 : * thrown. The value of the string doesn't change if an error is
1929 : * thrown.
1930 : */
1931 : _GLIBCXX20_CONSTEXPR
1932 : basic_string&
1933 : insert(size_type __pos, const _CharT* __s)
1934 : {
1935 : __glibcxx_requires_string(__s);
1936 : return this->replace(__pos, size_type(0), __s,
1937 : traits_type::length(__s));
1938 : }
1939 :
1940 : /**
1941 : * @brief Insert multiple characters.
1942 : * @param __pos Index in string to insert at.
1943 : * @param __n Number of characters to insert
1944 : * @param __c The character to insert.
1945 : * @return Reference to this string.
1946 : * @throw std::length_error If new length exceeds @c max_size().
1947 : * @throw std::out_of_range If @a __pos is beyond the end of this
1948 : * string.
1949 : *
1950 : * Inserts @a __n copies of character @a __c starting at index
1951 : * @a __pos. If adding characters causes the length to exceed
1952 : * max_size(), length_error is thrown. If @a __pos > length(),
1953 : * out_of_range is thrown. The value of the string doesn't
1954 : * change if an error is thrown.
1955 : */
1956 : _GLIBCXX20_CONSTEXPR
1957 : basic_string&
1958 : insert(size_type __pos, size_type __n, _CharT __c)
1959 : { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
1960 : size_type(0), __n, __c); }
1961 :
1962 : /**
1963 : * @brief Insert one character.
1964 : * @param __p Iterator referencing position in string to insert at.
1965 : * @param __c The character to insert.
1966 : * @return Iterator referencing newly inserted char.
1967 : * @throw std::length_error If new length exceeds @c max_size().
1968 : *
1969 : * Inserts character @a __c at position referenced by @a __p.
1970 : * If adding character causes the length to exceed max_size(),
1971 : * length_error is thrown. If @a __p is beyond end of string,
1972 : * out_of_range is thrown. The value of the string doesn't
1973 : * change if an error is thrown.
1974 : */
1975 : _GLIBCXX20_CONSTEXPR
1976 : iterator
1977 : insert(__const_iterator __p, _CharT __c)
1978 : {
1979 : _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1980 : const size_type __pos = __p - begin();
1981 : _M_replace_aux(__pos, size_type(0), size_type(1), __c);
1982 : return iterator(_M_data() + __pos);
1983 : }
1984 :
1985 : #if __cplusplus >= 201703L
1986 : /**
1987 : * @brief Insert a string_view.
1988 : * @param __pos Position in string to insert at.
1989 : * @param __svt The object convertible to string_view to insert.
1990 : * @return Reference to this string.
1991 : */
1992 : template<typename _Tp>
1993 : _GLIBCXX20_CONSTEXPR
1994 : _If_sv<_Tp, basic_string&>
1995 : insert(size_type __pos, const _Tp& __svt)
1996 : {
1997 : __sv_type __sv = __svt;
1998 : return this->insert(__pos, __sv.data(), __sv.size());
1999 : }
2000 :
2001 : /**
2002 : * @brief Insert a string_view.
2003 : * @param __pos1 Position in string to insert at.
2004 : * @param __svt The object convertible to string_view to insert from.
2005 : * @param __pos2 Start of characters in str to insert.
2006 : * @param __n The number of characters to insert.
2007 : * @return Reference to this string.
2008 : */
2009 : template<typename _Tp>
2010 : _GLIBCXX20_CONSTEXPR
2011 : _If_sv<_Tp, basic_string&>
2012 : insert(size_type __pos1, const _Tp& __svt,
2013 : size_type __pos2, size_type __n = npos)
2014 : {
2015 : __sv_type __sv = __svt;
2016 : return this->replace(__pos1, size_type(0),
2017 : __sv.data()
2018 : + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"),
2019 : std::__sv_limit(__sv.size(), __pos2, __n));
2020 : }
2021 : #endif // C++17
2022 :
2023 : /**
2024 : * @brief Remove characters.
2025 : * @param __pos Index of first character to remove (default 0).
2026 : * @param __n Number of characters to remove (default remainder).
2027 : * @return Reference to this string.
2028 : * @throw std::out_of_range If @a pos is beyond the end of this
2029 : * string.
2030 : *
2031 : * Removes @a __n characters from this string starting at @a
2032 : * __pos. The length of the string is reduced by @a __n. If
2033 : * there are < @a __n characters to remove, the remainder of
2034 : * the string is truncated. If @a __p is beyond end of string,
2035 : * out_of_range is thrown. The value of the string doesn't
2036 : * change if an error is thrown.
2037 : */
2038 : _GLIBCXX20_CONSTEXPR
2039 : basic_string&
2040 : erase(size_type __pos = 0, size_type __n = npos)
2041 : {
2042 : _M_check(__pos, "basic_string::erase");
2043 : if (__n == npos)
2044 : this->_M_set_length(__pos);
2045 : else if (__n != 0)
2046 : this->_M_erase(__pos, _M_limit(__pos, __n));
2047 : return *this;
2048 : }
2049 :
2050 : /**
2051 : * @brief Remove one character.
2052 : * @param __position Iterator referencing the character to remove.
2053 : * @return iterator referencing same location after removal.
2054 : *
2055 : * Removes the character at @a __position from this string. The value
2056 : * of the string doesn't change if an error is thrown.
2057 : */
2058 : _GLIBCXX20_CONSTEXPR
2059 : iterator
2060 : erase(__const_iterator __position)
2061 : {
2062 : _GLIBCXX_DEBUG_PEDASSERT(__position >= begin()
2063 : && __position < end());
2064 : const size_type __pos = __position - begin();
2065 : this->_M_erase(__pos, size_type(1));
2066 : return iterator(_M_data() + __pos);
2067 : }
2068 :
2069 : /**
2070 : * @brief Remove a range of characters.
2071 : * @param __first Iterator referencing the first character to remove.
2072 : * @param __last Iterator referencing the end of the range.
2073 : * @return Iterator referencing location of first after removal.
2074 : *
2075 : * Removes the characters in the range [first,last) from this string.
2076 : * The value of the string doesn't change if an error is thrown.
2077 : */
2078 : _GLIBCXX20_CONSTEXPR
2079 : iterator
2080 : erase(__const_iterator __first, __const_iterator __last)
2081 : {
2082 : _GLIBCXX_DEBUG_PEDASSERT(__first >= begin() && __first <= __last
2083 : && __last <= end());
2084 : const size_type __pos = __first - begin();
2085 : if (__last == end())
2086 : this->_M_set_length(__pos);
2087 : else
2088 : this->_M_erase(__pos, __last - __first);
2089 : return iterator(this->_M_data() + __pos);
2090 : }
2091 :
2092 : #if __cplusplus >= 201103L
2093 : /**
2094 : * @brief Remove the last character.
2095 : *
2096 : * The string must be non-empty.
2097 : */
2098 : _GLIBCXX20_CONSTEXPR
2099 : void
2100 : pop_back() noexcept
2101 : {
2102 : __glibcxx_assert(!empty());
2103 : _M_erase(size() - 1, 1);
2104 : }
2105 : #endif // C++11
2106 :
2107 : /**
2108 : * @brief Replace characters with value from another string.
2109 : * @param __pos Index of first character to replace.
2110 : * @param __n Number of characters to be replaced.
2111 : * @param __str String to insert.
2112 : * @return Reference to this string.
2113 : * @throw std::out_of_range If @a pos is beyond the end of this
2114 : * string.
2115 : * @throw std::length_error If new length exceeds @c max_size().
2116 : *
2117 : * Removes the characters in the range [__pos,__pos+__n) from
2118 : * this string. In place, the value of @a __str is inserted.
2119 : * If @a __pos is beyond end of string, out_of_range is thrown.
2120 : * If the length of the result exceeds max_size(), length_error
2121 : * is thrown. The value of the string doesn't change if an
2122 : * error is thrown.
2123 : */
2124 : _GLIBCXX20_CONSTEXPR
2125 : basic_string&
2126 : replace(size_type __pos, size_type __n, const basic_string& __str)
2127 : { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
2128 :
2129 : /**
2130 : * @brief Replace characters with value from another string.
2131 : * @param __pos1 Index of first character to replace.
2132 : * @param __n1 Number of characters to be replaced.
2133 : * @param __str String to insert.
2134 : * @param __pos2 Index of first character of str to use.
2135 : * @param __n2 Number of characters from str to use.
2136 : * @return Reference to this string.
2137 : * @throw std::out_of_range If @a __pos1 > size() or @a __pos2 >
2138 : * __str.size().
2139 : * @throw std::length_error If new length exceeds @c max_size().
2140 : *
2141 : * Removes the characters in the range [__pos1,__pos1 + n) from this
2142 : * string. In place, the value of @a __str is inserted. If @a __pos is
2143 : * beyond end of string, out_of_range is thrown. If the length of the
2144 : * result exceeds max_size(), length_error is thrown. The value of the
2145 : * string doesn't change if an error is thrown.
2146 : */
2147 : _GLIBCXX20_CONSTEXPR
2148 : basic_string&
2149 : replace(size_type __pos1, size_type __n1, const basic_string& __str,
2150 : size_type __pos2, size_type __n2 = npos)
2151 : { return this->replace(__pos1, __n1, __str._M_data()
2152 : + __str._M_check(__pos2, "basic_string::replace"),
2153 : __str._M_limit(__pos2, __n2)); }
2154 :
2155 : /**
2156 : * @brief Replace characters with value of a C substring.
2157 : * @param __pos Index of first character to replace.
2158 : * @param __n1 Number of characters to be replaced.
2159 : * @param __s C string to insert.
2160 : * @param __n2 Number of characters from @a s to use.
2161 : * @return Reference to this string.
2162 : * @throw std::out_of_range If @a pos1 > size().
2163 : * @throw std::length_error If new length exceeds @c max_size().
2164 : *
2165 : * Removes the characters in the range [__pos,__pos + __n1)
2166 : * from this string. In place, the first @a __n2 characters of
2167 : * @a __s are inserted, or all of @a __s if @a __n2 is too large. If
2168 : * @a __pos is beyond end of string, out_of_range is thrown. If
2169 : * the length of result exceeds max_size(), length_error is
2170 : * thrown. The value of the string doesn't change if an error
2171 : * is thrown.
2172 : */
2173 : _GLIBCXX20_CONSTEXPR
2174 : basic_string&
2175 : replace(size_type __pos, size_type __n1, const _CharT* __s,
2176 : size_type __n2)
2177 : {
2178 : __glibcxx_requires_string_len(__s, __n2);
2179 : return _M_replace(_M_check(__pos, "basic_string::replace"),
2180 : _M_limit(__pos, __n1), __s, __n2);
2181 : }
2182 :
2183 : /**
2184 : * @brief Replace characters with value of a C string.
2185 : * @param __pos Index of first character to replace.
2186 : * @param __n1 Number of characters to be replaced.
2187 : * @param __s C string to insert.
2188 : * @return Reference to this string.
2189 : * @throw std::out_of_range If @a pos > size().
2190 : * @throw std::length_error If new length exceeds @c max_size().
2191 : *
2192 : * Removes the characters in the range [__pos,__pos + __n1)
2193 : * from this string. In place, the characters of @a __s are
2194 : * inserted. If @a __pos is beyond end of string, out_of_range
2195 : * is thrown. If the length of result exceeds max_size(),
2196 : * length_error is thrown. The value of the string doesn't
2197 : * change if an error is thrown.
2198 : */
2199 : _GLIBCXX20_CONSTEXPR
2200 : basic_string&
2201 : replace(size_type __pos, size_type __n1, const _CharT* __s)
2202 : {
2203 : __glibcxx_requires_string(__s);
2204 : return this->replace(__pos, __n1, __s, traits_type::length(__s));
2205 : }
2206 :
2207 : /**
2208 : * @brief Replace characters with multiple characters.
2209 : * @param __pos Index of first character to replace.
2210 : * @param __n1 Number of characters to be replaced.
2211 : * @param __n2 Number of characters to insert.
2212 : * @param __c Character to insert.
2213 : * @return Reference to this string.
2214 : * @throw std::out_of_range If @a __pos > size().
2215 : * @throw std::length_error If new length exceeds @c max_size().
2216 : *
2217 : * Removes the characters in the range [pos,pos + n1) from this
2218 : * string. In place, @a __n2 copies of @a __c are inserted.
2219 : * If @a __pos is beyond end of string, out_of_range is thrown.
2220 : * If the length of result exceeds max_size(), length_error is
2221 : * thrown. The value of the string doesn't change if an error
2222 : * is thrown.
2223 : */
2224 : _GLIBCXX20_CONSTEXPR
2225 : basic_string&
2226 : replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
2227 : { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
2228 : _M_limit(__pos, __n1), __n2, __c); }
2229 :
2230 : /**
2231 : * @brief Replace range of characters with string.
2232 : * @param __i1 Iterator referencing start of range to replace.
2233 : * @param __i2 Iterator referencing end of range to replace.
2234 : * @param __str String value to insert.
2235 : * @return Reference to this string.
2236 : * @throw std::length_error If new length exceeds @c max_size().
2237 : *
2238 : * Removes the characters in the range [__i1,__i2). In place,
2239 : * the value of @a __str is inserted. If the length of result
2240 : * exceeds max_size(), length_error is thrown. The value of
2241 : * the string doesn't change if an error is thrown.
2242 : */
2243 : _GLIBCXX20_CONSTEXPR
2244 : basic_string&
2245 : replace(__const_iterator __i1, __const_iterator __i2,
2246 : const basic_string& __str)
2247 : { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
2248 :
2249 : /**
2250 : * @brief Replace range of characters with C substring.
2251 : * @param __i1 Iterator referencing start of range to replace.
2252 : * @param __i2 Iterator referencing end of range to replace.
2253 : * @param __s C string value to insert.
2254 : * @param __n Number of characters from s to insert.
2255 : * @return Reference to this string.
2256 : * @throw std::length_error If new length exceeds @c max_size().
2257 : *
2258 : * Removes the characters in the range [__i1,__i2). In place,
2259 : * the first @a __n characters of @a __s are inserted. If the
2260 : * length of result exceeds max_size(), length_error is thrown.
2261 : * The value of the string doesn't change if an error is
2262 : * thrown.
2263 : */
2264 : _GLIBCXX20_CONSTEXPR
2265 : basic_string&
2266 : replace(__const_iterator __i1, __const_iterator __i2,
2267 : const _CharT* __s, size_type __n)
2268 : {
2269 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2270 : && __i2 <= end());
2271 : return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
2272 : }
2273 :
2274 : /**
2275 : * @brief Replace range of characters with C string.
2276 : * @param __i1 Iterator referencing start of range to replace.
2277 : * @param __i2 Iterator referencing end of range to replace.
2278 : * @param __s C string value to insert.
2279 : * @return Reference to this string.
2280 : * @throw std::length_error If new length exceeds @c max_size().
2281 : *
2282 : * Removes the characters in the range [__i1,__i2). In place,
2283 : * the characters of @a __s are inserted. If the length of
2284 : * result exceeds max_size(), length_error is thrown. The
2285 : * value of the string doesn't change if an error is thrown.
2286 : */
2287 : _GLIBCXX20_CONSTEXPR
2288 : basic_string&
2289 : replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
2290 : {
2291 : __glibcxx_requires_string(__s);
2292 : return this->replace(__i1, __i2, __s, traits_type::length(__s));
2293 : }
2294 :
2295 : /**
2296 : * @brief Replace range of characters with multiple characters
2297 : * @param __i1 Iterator referencing start of range to replace.
2298 : * @param __i2 Iterator referencing end of range to replace.
2299 : * @param __n Number of characters to insert.
2300 : * @param __c Character to insert.
2301 : * @return Reference to this string.
2302 : * @throw std::length_error If new length exceeds @c max_size().
2303 : *
2304 : * Removes the characters in the range [__i1,__i2). In place,
2305 : * @a __n copies of @a __c are inserted. If the length of
2306 : * result exceeds max_size(), length_error is thrown. The
2307 : * value of the string doesn't change if an error is thrown.
2308 : */
2309 : _GLIBCXX20_CONSTEXPR
2310 : basic_string&
2311 : replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
2312 : _CharT __c)
2313 : {
2314 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2315 : && __i2 <= end());
2316 : return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
2317 : }
2318 :
2319 : /**
2320 : * @brief Replace range of characters with range.
2321 : * @param __i1 Iterator referencing start of range to replace.
2322 : * @param __i2 Iterator referencing end of range to replace.
2323 : * @param __k1 Iterator referencing start of range to insert.
2324 : * @param __k2 Iterator referencing end of range to insert.
2325 : * @return Reference to this string.
2326 : * @throw std::length_error If new length exceeds @c max_size().
2327 : *
2328 : * Removes the characters in the range [__i1,__i2). In place,
2329 : * characters in the range [__k1,__k2) are inserted. If the
2330 : * length of result exceeds max_size(), length_error is thrown.
2331 : * The value of the string doesn't change if an error is
2332 : * thrown.
2333 : */
2334 : #if __cplusplus >= 201103L
2335 : template<class _InputIterator,
2336 : typename = std::_RequireInputIter<_InputIterator>>
2337 : _GLIBCXX20_CONSTEXPR
2338 : basic_string&
2339 : replace(const_iterator __i1, const_iterator __i2,
2340 : _InputIterator __k1, _InputIterator __k2)
2341 : {
2342 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2343 : && __i2 <= end());
2344 : __glibcxx_requires_valid_range(__k1, __k2);
2345 : return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
2346 : std::__false_type());
2347 : }
2348 : #else
2349 : template<class _InputIterator>
2350 : #ifdef _GLIBCXX_DISAMBIGUATE_REPLACE_INST
2351 : typename __enable_if_not_native_iterator<_InputIterator>::__type
2352 : #else
2353 : basic_string&
2354 : #endif
2355 : replace(iterator __i1, iterator __i2,
2356 : _InputIterator __k1, _InputIterator __k2)
2357 : {
2358 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2359 : && __i2 <= end());
2360 : __glibcxx_requires_valid_range(__k1, __k2);
2361 : typedef typename std::__is_integer<_InputIterator>::__type _Integral;
2362 : return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
2363 : }
2364 : #endif
2365 :
2366 : // Specializations for the common case of pointer and iterator:
2367 : // useful to avoid the overhead of temporary buffering in _M_replace.
2368 : _GLIBCXX20_CONSTEXPR
2369 : basic_string&
2370 : replace(__const_iterator __i1, __const_iterator __i2,
2371 : _CharT* __k1, _CharT* __k2)
2372 : {
2373 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2374 : && __i2 <= end());
2375 : __glibcxx_requires_valid_range(__k1, __k2);
2376 : return this->replace(__i1 - begin(), __i2 - __i1,
2377 : __k1, __k2 - __k1);
2378 : }
2379 :
2380 : _GLIBCXX20_CONSTEXPR
2381 : basic_string&
2382 : replace(__const_iterator __i1, __const_iterator __i2,
2383 : const _CharT* __k1, const _CharT* __k2)
2384 : {
2385 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2386 : && __i2 <= end());
2387 : __glibcxx_requires_valid_range(__k1, __k2);
2388 : return this->replace(__i1 - begin(), __i2 - __i1,
2389 : __k1, __k2 - __k1);
2390 : }
2391 :
2392 : _GLIBCXX20_CONSTEXPR
2393 : basic_string&
2394 : replace(__const_iterator __i1, __const_iterator __i2,
2395 : iterator __k1, iterator __k2)
2396 : {
2397 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2398 : && __i2 <= end());
2399 : __glibcxx_requires_valid_range(__k1, __k2);
2400 : return this->replace(__i1 - begin(), __i2 - __i1,
2401 : __k1.base(), __k2 - __k1);
2402 : }
2403 :
2404 : _GLIBCXX20_CONSTEXPR
2405 : basic_string&
2406 : replace(__const_iterator __i1, __const_iterator __i2,
2407 : const_iterator __k1, const_iterator __k2)
2408 : {
2409 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2410 : && __i2 <= end());
2411 : __glibcxx_requires_valid_range(__k1, __k2);
2412 : return this->replace(__i1 - begin(), __i2 - __i1,
2413 : __k1.base(), __k2 - __k1);
2414 : }
2415 :
2416 : #if __cplusplus >= 201103L
2417 : /**
2418 : * @brief Replace range of characters with initializer_list.
2419 : * @param __i1 Iterator referencing start of range to replace.
2420 : * @param __i2 Iterator referencing end of range to replace.
2421 : * @param __l The initializer_list of characters to insert.
2422 : * @return Reference to this string.
2423 : * @throw std::length_error If new length exceeds @c max_size().
2424 : *
2425 : * Removes the characters in the range [__i1,__i2). In place,
2426 : * characters in the range [__k1,__k2) are inserted. If the
2427 : * length of result exceeds max_size(), length_error is thrown.
2428 : * The value of the string doesn't change if an error is
2429 : * thrown.
2430 : */
2431 : _GLIBCXX20_CONSTEXPR
2432 : basic_string& replace(const_iterator __i1, const_iterator __i2,
2433 : initializer_list<_CharT> __l)
2434 : { return this->replace(__i1, __i2, __l.begin(), __l.size()); }
2435 : #endif // C++11
2436 :
2437 : #if __cplusplus >= 201703L
2438 : /**
2439 : * @brief Replace range of characters with string_view.
2440 : * @param __pos The position to replace at.
2441 : * @param __n The number of characters to replace.
2442 : * @param __svt The object convertible to string_view to insert.
2443 : * @return Reference to this string.
2444 : */
2445 : template<typename _Tp>
2446 : _GLIBCXX20_CONSTEXPR
2447 : _If_sv<_Tp, basic_string&>
2448 : replace(size_type __pos, size_type __n, const _Tp& __svt)
2449 : {
2450 : __sv_type __sv = __svt;
2451 : return this->replace(__pos, __n, __sv.data(), __sv.size());
2452 : }
2453 :
2454 : /**
2455 : * @brief Replace range of characters with string_view.
2456 : * @param __pos1 The position to replace at.
2457 : * @param __n1 The number of characters to replace.
2458 : * @param __svt The object convertible to string_view to insert from.
2459 : * @param __pos2 The position in the string_view to insert from.
2460 : * @param __n2 The number of characters to insert.
2461 : * @return Reference to this string.
2462 : */
2463 : template<typename _Tp>
2464 : _GLIBCXX20_CONSTEXPR
2465 : _If_sv<_Tp, basic_string&>
2466 : replace(size_type __pos1, size_type __n1, const _Tp& __svt,
2467 : size_type __pos2, size_type __n2 = npos)
2468 : {
2469 : __sv_type __sv = __svt;
2470 : return this->replace(__pos1, __n1,
2471 : __sv.data()
2472 : + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"),
2473 : std::__sv_limit(__sv.size(), __pos2, __n2));
2474 : }
2475 :
2476 : /**
2477 : * @brief Replace range of characters with string_view.
2478 : * @param __i1 An iterator referencing the start position
2479 : to replace at.
2480 : * @param __i2 An iterator referencing the end position
2481 : for the replace.
2482 : * @param __svt The object convertible to string_view to insert from.
2483 : * @return Reference to this string.
2484 : */
2485 : template<typename _Tp>
2486 : _GLIBCXX20_CONSTEXPR
2487 : _If_sv<_Tp, basic_string&>
2488 : replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
2489 : {
2490 : __sv_type __sv = __svt;
2491 : return this->replace(__i1 - begin(), __i2 - __i1, __sv);
2492 : }
2493 : #endif // C++17
2494 :
2495 : private:
2496 : template<class _Integer>
2497 : _GLIBCXX20_CONSTEXPR
2498 : basic_string&
2499 : _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
2500 : _Integer __n, _Integer __val, __true_type)
2501 : { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
2502 :
2503 : template<class _InputIterator>
2504 : _GLIBCXX20_CONSTEXPR
2505 : basic_string&
2506 : _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
2507 : _InputIterator __k1, _InputIterator __k2,
2508 : __false_type);
2509 :
2510 : _GLIBCXX20_CONSTEXPR
2511 : basic_string&
2512 : _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
2513 : _CharT __c);
2514 :
2515 : _GLIBCXX20_CONSTEXPR
2516 : basic_string&
2517 : _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
2518 : const size_type __len2);
2519 :
2520 : _GLIBCXX20_CONSTEXPR
2521 : basic_string&
2522 : _M_append(const _CharT* __s, size_type __n);
2523 :
2524 : public:
2525 :
2526 : /**
2527 : * @brief Copy substring into C string.
2528 : * @param __s C string to copy value into.
2529 : * @param __n Number of characters to copy.
2530 : * @param __pos Index of first character to copy.
2531 : * @return Number of characters actually copied
2532 : * @throw std::out_of_range If __pos > size().
2533 : *
2534 : * Copies up to @a __n characters starting at @a __pos into the
2535 : * C string @a __s. If @a __pos is %greater than size(),
2536 : * out_of_range is thrown.
2537 : */
2538 : _GLIBCXX20_CONSTEXPR
2539 : size_type
2540 : copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
2541 :
2542 : /**
2543 : * @brief Swap contents with another string.
2544 : * @param __s String to swap with.
2545 : *
2546 : * Exchanges the contents of this string with that of @a __s in constant
2547 : * time.
2548 : */
2549 : _GLIBCXX20_CONSTEXPR
2550 : void
2551 : swap(basic_string& __s) _GLIBCXX_NOEXCEPT;
2552 :
2553 : // String operations:
2554 : /**
2555 : * @brief Return const pointer to null-terminated contents.
2556 : *
2557 : * This is a handle to internal data. Do not modify or dire things may
2558 : * happen.
2559 : */
2560 : _GLIBCXX20_CONSTEXPR
2561 : const _CharT*
2562 31159 : c_str() const _GLIBCXX_NOEXCEPT
2563 31159 : { return _M_data(); }
2564 :
2565 : /**
2566 : * @brief Return const pointer to contents.
2567 : *
2568 : * This is a pointer to internal data. It is undefined to modify
2569 : * the contents through the returned pointer. To get a pointer that
2570 : * allows modifying the contents use @c &str[0] instead,
2571 : * (or in C++17 the non-const @c str.data() overload).
2572 : */
2573 : _GLIBCXX20_CONSTEXPR
2574 : const _CharT*
2575 6320 : data() const _GLIBCXX_NOEXCEPT
2576 6320 : { return _M_data(); }
2577 :
2578 : #if __cplusplus >= 201703L
2579 : /**
2580 : * @brief Return non-const pointer to contents.
2581 : *
2582 : * This is a pointer to the character sequence held by the string.
2583 : * Modifying the characters in the sequence is allowed.
2584 : */
2585 : _GLIBCXX20_CONSTEXPR
2586 : _CharT*
2587 : data() noexcept
2588 : { return _M_data(); }
2589 : #endif
2590 :
2591 : /**
2592 : * @brief Return copy of allocator used to construct this string.
2593 : */
2594 : _GLIBCXX20_CONSTEXPR
2595 : allocator_type
2596 : get_allocator() const _GLIBCXX_NOEXCEPT
2597 : { return _M_get_allocator(); }
2598 :
2599 : /**
2600 : * @brief Find position of a C substring.
2601 : * @param __s C string to locate.
2602 : * @param __pos Index of character to search from.
2603 : * @param __n Number of characters from @a s to search for.
2604 : * @return Index of start of first occurrence.
2605 : *
2606 : * Starting from @a __pos, searches forward for the first @a
2607 : * __n characters in @a __s within this string. If found,
2608 : * returns the index where it begins. If not found, returns
2609 : * npos.
2610 : */
2611 : _GLIBCXX20_CONSTEXPR
2612 : size_type
2613 : find(const _CharT* __s, size_type __pos, size_type __n) const
2614 : _GLIBCXX_NOEXCEPT;
2615 :
2616 : /**
2617 : * @brief Find position of a string.
2618 : * @param __str String to locate.
2619 : * @param __pos Index of character to search from (default 0).
2620 : * @return Index of start of first occurrence.
2621 : *
2622 : * Starting from @a __pos, searches forward for value of @a __str within
2623 : * this string. If found, returns the index where it begins. If not
2624 : * found, returns npos.
2625 : */
2626 : _GLIBCXX20_CONSTEXPR
2627 : size_type
2628 : find(const basic_string& __str, size_type __pos = 0) const
2629 : _GLIBCXX_NOEXCEPT
2630 : { return this->find(__str.data(), __pos, __str.size()); }
2631 :
2632 : #if __cplusplus >= 201703L
2633 : /**
2634 : * @brief Find position of a string_view.
2635 : * @param __svt The object convertible to string_view to locate.
2636 : * @param __pos Index of character to search from (default 0).
2637 : * @return Index of start of first occurrence.
2638 : */
2639 : template<typename _Tp>
2640 : _GLIBCXX20_CONSTEXPR
2641 : _If_sv<_Tp, size_type>
2642 : find(const _Tp& __svt, size_type __pos = 0) const
2643 : noexcept(is_same<_Tp, __sv_type>::value)
2644 : {
2645 : __sv_type __sv = __svt;
2646 : return this->find(__sv.data(), __pos, __sv.size());
2647 : }
2648 : #endif // C++17
2649 :
2650 : /**
2651 : * @brief Find position of a C string.
2652 : * @param __s C string to locate.
2653 : * @param __pos Index of character to search from (default 0).
2654 : * @return Index of start of first occurrence.
2655 : *
2656 : * Starting from @a __pos, searches forward for the value of @a
2657 : * __s within this string. If found, returns the index where
2658 : * it begins. If not found, returns npos.
2659 : */
2660 : _GLIBCXX20_CONSTEXPR
2661 : size_type
2662 : find(const _CharT* __s, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
2663 : {
2664 : __glibcxx_requires_string(__s);
2665 : return this->find(__s, __pos, traits_type::length(__s));
2666 : }
2667 :
2668 : /**
2669 : * @brief Find position of a character.
2670 : * @param __c Character to locate.
2671 : * @param __pos Index of character to search from (default 0).
2672 : * @return Index of first occurrence.
2673 : *
2674 : * Starting from @a __pos, searches forward for @a __c within
2675 : * this string. If found, returns the index where it was
2676 : * found. If not found, returns npos.
2677 : */
2678 : _GLIBCXX20_CONSTEXPR
2679 : size_type
2680 : find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT;
2681 :
2682 : /**
2683 : * @brief Find last position of a string.
2684 : * @param __str String to locate.
2685 : * @param __pos Index of character to search back from (default end).
2686 : * @return Index of start of last occurrence.
2687 : *
2688 : * Starting from @a __pos, searches backward for value of @a
2689 : * __str within this string. If found, returns the index where
2690 : * it begins. If not found, returns npos.
2691 : */
2692 : _GLIBCXX20_CONSTEXPR
2693 : size_type
2694 : rfind(const basic_string& __str, size_type __pos = npos) const
2695 : _GLIBCXX_NOEXCEPT
2696 : { return this->rfind(__str.data(), __pos, __str.size()); }
2697 :
2698 : #if __cplusplus >= 201703L
2699 : /**
2700 : * @brief Find last position of a string_view.
2701 : * @param __svt The object convertible to string_view to locate.
2702 : * @param __pos Index of character to search back from (default end).
2703 : * @return Index of start of last occurrence.
2704 : */
2705 : template<typename _Tp>
2706 : _GLIBCXX20_CONSTEXPR
2707 : _If_sv<_Tp, size_type>
2708 : rfind(const _Tp& __svt, size_type __pos = npos) const
2709 : noexcept(is_same<_Tp, __sv_type>::value)
2710 : {
2711 : __sv_type __sv = __svt;
2712 : return this->rfind(__sv.data(), __pos, __sv.size());
2713 : }
2714 : #endif // C++17
2715 :
2716 : /**
2717 : * @brief Find last position of a C substring.
2718 : * @param __s C string to locate.
2719 : * @param __pos Index of character to search back from.
2720 : * @param __n Number of characters from s to search for.
2721 : * @return Index of start of last occurrence.
2722 : *
2723 : * Starting from @a __pos, searches backward for the first @a
2724 : * __n characters in @a __s within this string. If found,
2725 : * returns the index where it begins. If not found, returns
2726 : * npos.
2727 : */
2728 : _GLIBCXX20_CONSTEXPR
2729 : size_type
2730 : rfind(const _CharT* __s, size_type __pos, size_type __n) const
2731 : _GLIBCXX_NOEXCEPT;
2732 :
2733 : /**
2734 : * @brief Find last position of a C string.
2735 : * @param __s C string to locate.
2736 : * @param __pos Index of character to start search at (default end).
2737 : * @return Index of start of last occurrence.
2738 : *
2739 : * Starting from @a __pos, searches backward for the value of
2740 : * @a __s within this string. If found, returns the index
2741 : * where it begins. If not found, returns npos.
2742 : */
2743 : _GLIBCXX20_CONSTEXPR
2744 : size_type
2745 : rfind(const _CharT* __s, size_type __pos = npos) const
2746 : {
2747 : __glibcxx_requires_string(__s);
2748 : return this->rfind(__s, __pos, traits_type::length(__s));
2749 : }
2750 :
2751 : /**
2752 : * @brief Find last position of a character.
2753 : * @param __c Character to locate.
2754 : * @param __pos Index of character to search back from (default end).
2755 : * @return Index of last occurrence.
2756 : *
2757 : * Starting from @a __pos, searches backward for @a __c within
2758 : * this string. If found, returns the index where it was
2759 : * found. If not found, returns npos.
2760 : */
2761 : _GLIBCXX20_CONSTEXPR
2762 : size_type
2763 : rfind(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT;
2764 :
2765 : /**
2766 : * @brief Find position of a character of string.
2767 : * @param __str String containing characters to locate.
2768 : * @param __pos Index of character to search from (default 0).
2769 : * @return Index of first occurrence.
2770 : *
2771 : * Starting from @a __pos, searches forward for one of the
2772 : * characters of @a __str within this string. If found,
2773 : * returns the index where it was found. If not found, returns
2774 : * npos.
2775 : */
2776 : _GLIBCXX20_CONSTEXPR
2777 : size_type
2778 : find_first_of(const basic_string& __str, size_type __pos = 0) const
2779 : _GLIBCXX_NOEXCEPT
2780 : { return this->find_first_of(__str.data(), __pos, __str.size()); }
2781 :
2782 : #if __cplusplus >= 201703L
2783 : /**
2784 : * @brief Find position of a character of a string_view.
2785 : * @param __svt An object convertible to string_view containing
2786 : * characters to locate.
2787 : * @param __pos Index of character to search from (default 0).
2788 : * @return Index of first occurrence.
2789 : */
2790 : template<typename _Tp>
2791 : _GLIBCXX20_CONSTEXPR
2792 : _If_sv<_Tp, size_type>
2793 : find_first_of(const _Tp& __svt, size_type __pos = 0) const
2794 : noexcept(is_same<_Tp, __sv_type>::value)
2795 : {
2796 : __sv_type __sv = __svt;
2797 : return this->find_first_of(__sv.data(), __pos, __sv.size());
2798 : }
2799 : #endif // C++17
2800 :
2801 : /**
2802 : * @brief Find position of a character of C substring.
2803 : * @param __s String containing characters to locate.
2804 : * @param __pos Index of character to search from.
2805 : * @param __n Number of characters from s to search for.
2806 : * @return Index of first occurrence.
2807 : *
2808 : * Starting from @a __pos, searches forward for one of the
2809 : * first @a __n characters of @a __s within this string. If
2810 : * found, returns the index where it was found. If not found,
2811 : * returns npos.
2812 : */
2813 : _GLIBCXX20_CONSTEXPR
2814 : size_type
2815 : find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
2816 : _GLIBCXX_NOEXCEPT;
2817 :
2818 : /**
2819 : * @brief Find position of a character of C string.
2820 : * @param __s String containing characters to locate.
2821 : * @param __pos Index of character to search from (default 0).
2822 : * @return Index of first occurrence.
2823 : *
2824 : * Starting from @a __pos, searches forward for one of the
2825 : * characters of @a __s within this string. If found, returns
2826 : * the index where it was found. If not found, returns npos.
2827 : */
2828 : _GLIBCXX20_CONSTEXPR
2829 : size_type
2830 : find_first_of(const _CharT* __s, size_type __pos = 0) const
2831 : _GLIBCXX_NOEXCEPT
2832 : {
2833 : __glibcxx_requires_string(__s);
2834 : return this->find_first_of(__s, __pos, traits_type::length(__s));
2835 : }
2836 :
2837 : /**
2838 : * @brief Find position of a character.
2839 : * @param __c Character to locate.
2840 : * @param __pos Index of character to search from (default 0).
2841 : * @return Index of first occurrence.
2842 : *
2843 : * Starting from @a __pos, searches forward for the character
2844 : * @a __c within this string. If found, returns the index
2845 : * where it was found. If not found, returns npos.
2846 : *
2847 : * Note: equivalent to find(__c, __pos).
2848 : */
2849 : _GLIBCXX20_CONSTEXPR
2850 : size_type
2851 : find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
2852 : { return this->find(__c, __pos); }
2853 :
2854 : /**
2855 : * @brief Find last position of a character of string.
2856 : * @param __str String containing characters to locate.
2857 : * @param __pos Index of character to search back from (default end).
2858 : * @return Index of last occurrence.
2859 : *
2860 : * Starting from @a __pos, searches backward for one of the
2861 : * characters of @a __str within this string. If found,
2862 : * returns the index where it was found. If not found, returns
2863 : * npos.
2864 : */
2865 : _GLIBCXX20_CONSTEXPR
2866 : size_type
2867 : find_last_of(const basic_string& __str, size_type __pos = npos) const
2868 : _GLIBCXX_NOEXCEPT
2869 : { return this->find_last_of(__str.data(), __pos, __str.size()); }
2870 :
2871 : #if __cplusplus >= 201703L
2872 : /**
2873 : * @brief Find last position of a character of string.
2874 : * @param __svt An object convertible to string_view containing
2875 : * characters to locate.
2876 : * @param __pos Index of character to search back from (default end).
2877 : * @return Index of last occurrence.
2878 : */
2879 : template<typename _Tp>
2880 : _GLIBCXX20_CONSTEXPR
2881 : _If_sv<_Tp, size_type>
2882 : find_last_of(const _Tp& __svt, size_type __pos = npos) const
2883 : noexcept(is_same<_Tp, __sv_type>::value)
2884 : {
2885 : __sv_type __sv = __svt;
2886 : return this->find_last_of(__sv.data(), __pos, __sv.size());
2887 : }
2888 : #endif // C++17
2889 :
2890 : /**
2891 : * @brief Find last position of a character of C substring.
2892 : * @param __s C string containing characters to locate.
2893 : * @param __pos Index of character to search back from.
2894 : * @param __n Number of characters from s to search for.
2895 : * @return Index of last occurrence.
2896 : *
2897 : * Starting from @a __pos, searches backward for one of the
2898 : * first @a __n characters of @a __s within this string. If
2899 : * found, returns the index where it was found. If not found,
2900 : * returns npos.
2901 : */
2902 : _GLIBCXX20_CONSTEXPR
2903 : size_type
2904 : find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
2905 : _GLIBCXX_NOEXCEPT;
2906 :
2907 : /**
2908 : * @brief Find last position of a character of C string.
2909 : * @param __s C string containing characters to locate.
2910 : * @param __pos Index of character to search back from (default end).
2911 : * @return Index of last occurrence.
2912 : *
2913 : * Starting from @a __pos, searches backward for one of the
2914 : * characters of @a __s within this string. If found, returns
2915 : * the index where it was found. If not found, returns npos.
2916 : */
2917 : _GLIBCXX20_CONSTEXPR
2918 : size_type
2919 : find_last_of(const _CharT* __s, size_type __pos = npos) const
2920 : _GLIBCXX_NOEXCEPT
2921 : {
2922 : __glibcxx_requires_string(__s);
2923 : return this->find_last_of(__s, __pos, traits_type::length(__s));
2924 : }
2925 :
2926 : /**
2927 : * @brief Find last position of a character.
2928 : * @param __c Character to locate.
2929 : * @param __pos Index of character to search back from (default end).
2930 : * @return Index of last occurrence.
2931 : *
2932 : * Starting from @a __pos, searches backward for @a __c within
2933 : * this string. If found, returns the index where it was
2934 : * found. If not found, returns npos.
2935 : *
2936 : * Note: equivalent to rfind(__c, __pos).
2937 : */
2938 : _GLIBCXX20_CONSTEXPR
2939 : size_type
2940 60 : find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
2941 60 : { return this->rfind(__c, __pos); }
2942 :
2943 : /**
2944 : * @brief Find position of a character not in string.
2945 : * @param __str String containing characters to avoid.
2946 : * @param __pos Index of character to search from (default 0).
2947 : * @return Index of first occurrence.
2948 : *
2949 : * Starting from @a __pos, searches forward for a character not contained
2950 : * in @a __str within this string. If found, returns the index where it
2951 : * was found. If not found, returns npos.
2952 : */
2953 : _GLIBCXX20_CONSTEXPR
2954 : size_type
2955 : find_first_not_of(const basic_string& __str, size_type __pos = 0) const
2956 : _GLIBCXX_NOEXCEPT
2957 : { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
2958 :
2959 : #if __cplusplus >= 201703L
2960 : /**
2961 : * @brief Find position of a character not in a string_view.
2962 : * @param __svt A object convertible to string_view containing
2963 : * characters to avoid.
2964 : * @param __pos Index of character to search from (default 0).
2965 : * @return Index of first occurrence.
2966 : */
2967 : template<typename _Tp>
2968 : _If_sv<_Tp, size_type>
2969 : _GLIBCXX20_CONSTEXPR
2970 : find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
2971 : noexcept(is_same<_Tp, __sv_type>::value)
2972 : {
2973 : __sv_type __sv = __svt;
2974 : return this->find_first_not_of(__sv.data(), __pos, __sv.size());
2975 : }
2976 : #endif // C++17
2977 :
2978 : /**
2979 : * @brief Find position of a character not in C substring.
2980 : * @param __s C string containing characters to avoid.
2981 : * @param __pos Index of character to search from.
2982 : * @param __n Number of characters from __s to consider.
2983 : * @return Index of first occurrence.
2984 : *
2985 : * Starting from @a __pos, searches forward for a character not
2986 : * contained in the first @a __n characters of @a __s within
2987 : * this string. If found, returns the index where it was
2988 : * found. If not found, returns npos.
2989 : */
2990 : _GLIBCXX20_CONSTEXPR
2991 : size_type
2992 : find_first_not_of(const _CharT* __s, size_type __pos,
2993 : size_type __n) const _GLIBCXX_NOEXCEPT;
2994 :
2995 : /**
2996 : * @brief Find position of a character not in C string.
2997 : * @param __s C string containing characters to avoid.
2998 : * @param __pos Index of character to search from (default 0).
2999 : * @return Index of first occurrence.
3000 : *
3001 : * Starting from @a __pos, searches forward for a character not
3002 : * contained in @a __s within this string. If found, returns
3003 : * the index where it was found. If not found, returns npos.
3004 : */
3005 : _GLIBCXX20_CONSTEXPR
3006 : size_type
3007 : find_first_not_of(const _CharT* __s, size_type __pos = 0) const
3008 : _GLIBCXX_NOEXCEPT
3009 : {
3010 : __glibcxx_requires_string(__s);
3011 : return this->find_first_not_of(__s, __pos, traits_type::length(__s));
3012 : }
3013 :
3014 : /**
3015 : * @brief Find position of a different character.
3016 : * @param __c Character to avoid.
3017 : * @param __pos Index of character to search from (default 0).
3018 : * @return Index of first occurrence.
3019 : *
3020 : * Starting from @a __pos, searches forward for a character
3021 : * other than @a __c within this string. If found, returns the
3022 : * index where it was found. If not found, returns npos.
3023 : */
3024 : _GLIBCXX20_CONSTEXPR
3025 : size_type
3026 : find_first_not_of(_CharT __c, size_type __pos = 0) const
3027 : _GLIBCXX_NOEXCEPT;
3028 :
3029 : /**
3030 : * @brief Find last position of a character not in string.
3031 : * @param __str String containing characters to avoid.
3032 : * @param __pos Index of character to search back from (default end).
3033 : * @return Index of last occurrence.
3034 : *
3035 : * Starting from @a __pos, searches backward for a character
3036 : * not contained in @a __str within this string. If found,
3037 : * returns the index where it was found. If not found, returns
3038 : * npos.
3039 : */
3040 : _GLIBCXX20_CONSTEXPR
3041 : size_type
3042 : find_last_not_of(const basic_string& __str, size_type __pos = npos) const
3043 : _GLIBCXX_NOEXCEPT
3044 : { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
3045 :
3046 : #if __cplusplus >= 201703L
3047 : /**
3048 : * @brief Find last position of a character not in a string_view.
3049 : * @param __svt An object convertible to string_view containing
3050 : * characters to avoid.
3051 : * @param __pos Index of character to search back from (default end).
3052 : * @return Index of last occurrence.
3053 : */
3054 : template<typename _Tp>
3055 : _GLIBCXX20_CONSTEXPR
3056 : _If_sv<_Tp, size_type>
3057 : find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
3058 : noexcept(is_same<_Tp, __sv_type>::value)
3059 : {
3060 : __sv_type __sv = __svt;
3061 : return this->find_last_not_of(__sv.data(), __pos, __sv.size());
3062 : }
3063 : #endif // C++17
3064 :
3065 : /**
3066 : * @brief Find last position of a character not in C substring.
3067 : * @param __s C string containing characters to avoid.
3068 : * @param __pos Index of character to search back from.
3069 : * @param __n Number of characters from s to consider.
3070 : * @return Index of last occurrence.
3071 : *
3072 : * Starting from @a __pos, searches backward for a character not
3073 : * contained in the first @a __n characters of @a __s within this string.
3074 : * If found, returns the index where it was found. If not found,
3075 : * returns npos.
3076 : */
3077 : _GLIBCXX20_CONSTEXPR
3078 : size_type
3079 : find_last_not_of(const _CharT* __s, size_type __pos,
3080 : size_type __n) const _GLIBCXX_NOEXCEPT;
3081 : /**
3082 : * @brief Find last position of a character not in C string.
3083 : * @param __s C string containing characters to avoid.
3084 : * @param __pos Index of character to search back from (default end).
3085 : * @return Index of last occurrence.
3086 : *
3087 : * Starting from @a __pos, searches backward for a character
3088 : * not contained in @a __s within this string. If found,
3089 : * returns the index where it was found. If not found, returns
3090 : * npos.
3091 : */
3092 : _GLIBCXX20_CONSTEXPR
3093 : size_type
3094 : find_last_not_of(const _CharT* __s, size_type __pos = npos) const
3095 : _GLIBCXX_NOEXCEPT
3096 : {
3097 : __glibcxx_requires_string(__s);
3098 : return this->find_last_not_of(__s, __pos, traits_type::length(__s));
3099 : }
3100 :
3101 : /**
3102 : * @brief Find last position of a different character.
3103 : * @param __c Character to avoid.
3104 : * @param __pos Index of character to search back from (default end).
3105 : * @return Index of last occurrence.
3106 : *
3107 : * Starting from @a __pos, searches backward for a character other than
3108 : * @a __c within this string. If found, returns the index where it was
3109 : * found. If not found, returns npos.
3110 : */
3111 : _GLIBCXX20_CONSTEXPR
3112 : size_type
3113 : find_last_not_of(_CharT __c, size_type __pos = npos) const
3114 : _GLIBCXX_NOEXCEPT;
3115 :
3116 : /**
3117 : * @brief Get a substring.
3118 : * @param __pos Index of first character (default 0).
3119 : * @param __n Number of characters in substring (default remainder).
3120 : * @return The new string.
3121 : * @throw std::out_of_range If __pos > size().
3122 : *
3123 : * Construct and return a new string using the @a __n
3124 : * characters starting at @a __pos. If the string is too
3125 : * short, use the remainder of the characters. If @a __pos is
3126 : * beyond the end of the string, out_of_range is thrown.
3127 : */
3128 : _GLIBCXX20_CONSTEXPR
3129 : basic_string
3130 : substr(size_type __pos = 0, size_type __n = npos) const
3131 : { return basic_string(*this,
3132 : _M_check(__pos, "basic_string::substr"), __n); }
3133 :
3134 : /**
3135 : * @brief Compare to a string.
3136 : * @param __str String to compare against.
3137 : * @return Integer < 0, 0, or > 0.
3138 : *
3139 : * Returns an integer < 0 if this string is ordered before @a
3140 : * __str, 0 if their values are equivalent, or > 0 if this
3141 : * string is ordered after @a __str. Determines the effective
3142 : * length rlen of the strings to compare as the smallest of
3143 : * size() and str.size(). The function then compares the two
3144 : * strings by calling traits::compare(data(), str.data(),rlen).
3145 : * If the result of the comparison is nonzero returns it,
3146 : * otherwise the shorter one is ordered first.
3147 : */
3148 : _GLIBCXX20_CONSTEXPR
3149 : int
3150 : compare(const basic_string& __str) const
3151 : {
3152 : const size_type __size = this->size();
3153 : const size_type __osize = __str.size();
3154 : const size_type __len = std::min(__size, __osize);
3155 :
3156 : int __r = traits_type::compare(_M_data(), __str.data(), __len);
3157 : if (!__r)
3158 : __r = _S_compare(__size, __osize);
3159 : return __r;
3160 : }
3161 :
3162 : #if __cplusplus >= 201703L
3163 : /**
3164 : * @brief Compare to a string_view.
3165 : * @param __svt An object convertible to string_view to compare against.
3166 : * @return Integer < 0, 0, or > 0.
3167 : */
3168 : template<typename _Tp>
3169 : _GLIBCXX20_CONSTEXPR
3170 : _If_sv<_Tp, int>
3171 : compare(const _Tp& __svt) const
3172 : noexcept(is_same<_Tp, __sv_type>::value)
3173 : {
3174 : __sv_type __sv = __svt;
3175 : const size_type __size = this->size();
3176 : const size_type __osize = __sv.size();
3177 : const size_type __len = std::min(__size, __osize);
3178 :
3179 : int __r = traits_type::compare(_M_data(), __sv.data(), __len);
3180 : if (!__r)
3181 : __r = _S_compare(__size, __osize);
3182 : return __r;
3183 : }
3184 :
3185 : /**
3186 : * @brief Compare to a string_view.
3187 : * @param __pos A position in the string to start comparing from.
3188 : * @param __n The number of characters to compare.
3189 : * @param __svt An object convertible to string_view to compare
3190 : * against.
3191 : * @return Integer < 0, 0, or > 0.
3192 : */
3193 : template<typename _Tp>
3194 : _GLIBCXX20_CONSTEXPR
3195 : _If_sv<_Tp, int>
3196 : compare(size_type __pos, size_type __n, const _Tp& __svt) const
3197 : noexcept(is_same<_Tp, __sv_type>::value)
3198 : {
3199 : __sv_type __sv = __svt;
3200 : return __sv_type(*this).substr(__pos, __n).compare(__sv);
3201 : }
3202 :
3203 : /**
3204 : * @brief Compare to a string_view.
3205 : * @param __pos1 A position in the string to start comparing from.
3206 : * @param __n1 The number of characters to compare.
3207 : * @param __svt An object convertible to string_view to compare
3208 : * against.
3209 : * @param __pos2 A position in the string_view to start comparing from.
3210 : * @param __n2 The number of characters to compare.
3211 : * @return Integer < 0, 0, or > 0.
3212 : */
3213 : template<typename _Tp>
3214 : _GLIBCXX20_CONSTEXPR
3215 : _If_sv<_Tp, int>
3216 : compare(size_type __pos1, size_type __n1, const _Tp& __svt,
3217 : size_type __pos2, size_type __n2 = npos) const
3218 : noexcept(is_same<_Tp, __sv_type>::value)
3219 : {
3220 : __sv_type __sv = __svt;
3221 : return __sv_type(*this)
3222 : .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
3223 : }
3224 : #endif // C++17
3225 :
3226 : /**
3227 : * @brief Compare substring to a string.
3228 : * @param __pos Index of first character of substring.
3229 : * @param __n Number of characters in substring.
3230 : * @param __str String to compare against.
3231 : * @return Integer < 0, 0, or > 0.
3232 : *
3233 : * Form the substring of this string from the @a __n characters
3234 : * starting at @a __pos. Returns an integer < 0 if the
3235 : * substring is ordered before @a __str, 0 if their values are
3236 : * equivalent, or > 0 if the substring is ordered after @a
3237 : * __str. Determines the effective length rlen of the strings
3238 : * to compare as the smallest of the length of the substring
3239 : * and @a __str.size(). The function then compares the two
3240 : * strings by calling
3241 : * traits::compare(substring.data(),str.data(),rlen). If the
3242 : * result of the comparison is nonzero returns it, otherwise
3243 : * the shorter one is ordered first.
3244 : */
3245 : _GLIBCXX20_CONSTEXPR
3246 : int
3247 : compare(size_type __pos, size_type __n, const basic_string& __str) const;
3248 :
3249 : /**
3250 : * @brief Compare substring to a substring.
3251 : * @param __pos1 Index of first character of substring.
3252 : * @param __n1 Number of characters in substring.
3253 : * @param __str String to compare against.
3254 : * @param __pos2 Index of first character of substring of str.
3255 : * @param __n2 Number of characters in substring of str.
3256 : * @return Integer < 0, 0, or > 0.
3257 : *
3258 : * Form the substring of this string from the @a __n1
3259 : * characters starting at @a __pos1. Form the substring of @a
3260 : * __str from the @a __n2 characters starting at @a __pos2.
3261 : * Returns an integer < 0 if this substring is ordered before
3262 : * the substring of @a __str, 0 if their values are equivalent,
3263 : * or > 0 if this substring is ordered after the substring of
3264 : * @a __str. Determines the effective length rlen of the
3265 : * strings to compare as the smallest of the lengths of the
3266 : * substrings. The function then compares the two strings by
3267 : * calling
3268 : * traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
3269 : * If the result of the comparison is nonzero returns it,
3270 : * otherwise the shorter one is ordered first.
3271 : */
3272 : _GLIBCXX20_CONSTEXPR
3273 : int
3274 : compare(size_type __pos1, size_type __n1, const basic_string& __str,
3275 : size_type __pos2, size_type __n2 = npos) const;
3276 :
3277 : /**
3278 : * @brief Compare to a C string.
3279 : * @param __s C string to compare against.
3280 : * @return Integer < 0, 0, or > 0.
3281 : *
3282 : * Returns an integer < 0 if this string is ordered before @a __s, 0 if
3283 : * their values are equivalent, or > 0 if this string is ordered after
3284 : * @a __s. Determines the effective length rlen of the strings to
3285 : * compare as the smallest of size() and the length of a string
3286 : * constructed from @a __s. The function then compares the two strings
3287 : * by calling traits::compare(data(),s,rlen). If the result of the
3288 : * comparison is nonzero returns it, otherwise the shorter one is
3289 : * ordered first.
3290 : */
3291 : _GLIBCXX20_CONSTEXPR
3292 : int
3293 : compare(const _CharT* __s) const _GLIBCXX_NOEXCEPT;
3294 :
3295 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
3296 : // 5 String::compare specification questionable
3297 : /**
3298 : * @brief Compare substring to a C string.
3299 : * @param __pos Index of first character of substring.
3300 : * @param __n1 Number of characters in substring.
3301 : * @param __s C string to compare against.
3302 : * @return Integer < 0, 0, or > 0.
3303 : *
3304 : * Form the substring of this string from the @a __n1
3305 : * characters starting at @a pos. Returns an integer < 0 if
3306 : * the substring is ordered before @a __s, 0 if their values
3307 : * are equivalent, or > 0 if the substring is ordered after @a
3308 : * __s. Determines the effective length rlen of the strings to
3309 : * compare as the smallest of the length of the substring and
3310 : * the length of a string constructed from @a __s. The
3311 : * function then compares the two string by calling
3312 : * traits::compare(substring.data(),__s,rlen). If the result of
3313 : * the comparison is nonzero returns it, otherwise the shorter
3314 : * one is ordered first.
3315 : */
3316 : _GLIBCXX20_CONSTEXPR
3317 : int
3318 : compare(size_type __pos, size_type __n1, const _CharT* __s) const;
3319 :
3320 : /**
3321 : * @brief Compare substring against a character %array.
3322 : * @param __pos Index of first character of substring.
3323 : * @param __n1 Number of characters in substring.
3324 : * @param __s character %array to compare against.
3325 : * @param __n2 Number of characters of s.
3326 : * @return Integer < 0, 0, or > 0.
3327 : *
3328 : * Form the substring of this string from the @a __n1
3329 : * characters starting at @a __pos. Form a string from the
3330 : * first @a __n2 characters of @a __s. Returns an integer < 0
3331 : * if this substring is ordered before the string from @a __s,
3332 : * 0 if their values are equivalent, or > 0 if this substring
3333 : * is ordered after the string from @a __s. Determines the
3334 : * effective length rlen of the strings to compare as the
3335 : * smallest of the length of the substring and @a __n2. The
3336 : * function then compares the two strings by calling
3337 : * traits::compare(substring.data(),s,rlen). If the result of
3338 : * the comparison is nonzero returns it, otherwise the shorter
3339 : * one is ordered first.
3340 : *
3341 : * NB: s must have at least n2 characters, '\\0' has
3342 : * no special meaning.
3343 : */
3344 : _GLIBCXX20_CONSTEXPR
3345 : int
3346 : compare(size_type __pos, size_type __n1, const _CharT* __s,
3347 : size_type __n2) const;
3348 :
3349 : #if __cplusplus >= 202002L
3350 : constexpr bool
3351 : starts_with(basic_string_view<_CharT, _Traits> __x) const noexcept
3352 : { return __sv_type(this->data(), this->size()).starts_with(__x); }
3353 :
3354 : constexpr bool
3355 : starts_with(_CharT __x) const noexcept
3356 : { return __sv_type(this->data(), this->size()).starts_with(__x); }
3357 :
3358 : constexpr bool
3359 : starts_with(const _CharT* __x) const noexcept
3360 : { return __sv_type(this->data(), this->size()).starts_with(__x); }
3361 :
3362 : constexpr bool
3363 : ends_with(basic_string_view<_CharT, _Traits> __x) const noexcept
3364 : { return __sv_type(this->data(), this->size()).ends_with(__x); }
3365 :
3366 : constexpr bool
3367 : ends_with(_CharT __x) const noexcept
3368 : { return __sv_type(this->data(), this->size()).ends_with(__x); }
3369 :
3370 : constexpr bool
3371 : ends_with(const _CharT* __x) const noexcept
3372 : { return __sv_type(this->data(), this->size()).ends_with(__x); }
3373 : #endif // C++20
3374 :
3375 : #if __cplusplus > 202002L
3376 : constexpr bool
3377 : contains(basic_string_view<_CharT, _Traits> __x) const noexcept
3378 : { return __sv_type(this->data(), this->size()).contains(__x); }
3379 :
3380 : constexpr bool
3381 : contains(_CharT __x) const noexcept
3382 : { return __sv_type(this->data(), this->size()).contains(__x); }
3383 :
3384 : constexpr bool
3385 : contains(const _CharT* __x) const noexcept
3386 : { return __sv_type(this->data(), this->size()).contains(__x); }
3387 : #endif // C++23
3388 :
3389 : // Allow basic_stringbuf::__xfer_bufptrs to call _M_length:
3390 : template<typename, typename, typename> friend class basic_stringbuf;
3391 : };
3392 : _GLIBCXX_END_NAMESPACE_CXX11
3393 : _GLIBCXX_END_NAMESPACE_VERSION
3394 : } // namespace std
3395 : #endif // _GLIBCXX_USE_CXX11_ABI
3396 :
3397 : namespace std _GLIBCXX_VISIBILITY(default)
3398 : {
3399 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
3400 :
3401 : #if __cpp_deduction_guides >= 201606
3402 : _GLIBCXX_BEGIN_NAMESPACE_CXX11
3403 : template<typename _InputIterator, typename _CharT
3404 : = typename iterator_traits<_InputIterator>::value_type,
3405 : typename _Allocator = allocator<_CharT>,
3406 : typename = _RequireInputIter<_InputIterator>,
3407 : typename = _RequireAllocator<_Allocator>>
3408 : basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
3409 : -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
3410 :
3411 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
3412 : // 3075. basic_string needs deduction guides from basic_string_view
3413 : template<typename _CharT, typename _Traits,
3414 : typename _Allocator = allocator<_CharT>,
3415 : typename = _RequireAllocator<_Allocator>>
3416 : basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
3417 : -> basic_string<_CharT, _Traits, _Allocator>;
3418 :
3419 : template<typename _CharT, typename _Traits,
3420 : typename _Allocator = allocator<_CharT>,
3421 : typename = _RequireAllocator<_Allocator>>
3422 : basic_string(basic_string_view<_CharT, _Traits>,
3423 : typename basic_string<_CharT, _Traits, _Allocator>::size_type,
3424 : typename basic_string<_CharT, _Traits, _Allocator>::size_type,
3425 : const _Allocator& = _Allocator())
3426 : -> basic_string<_CharT, _Traits, _Allocator>;
3427 : _GLIBCXX_END_NAMESPACE_CXX11
3428 : #endif
3429 :
3430 : // operator+
3431 : /**
3432 : * @brief Concatenate two strings.
3433 : * @param __lhs First string.
3434 : * @param __rhs Last string.
3435 : * @return New string with value of @a __lhs followed by @a __rhs.
3436 : */
3437 : template<typename _CharT, typename _Traits, typename _Alloc>
3438 : _GLIBCXX20_CONSTEXPR
3439 : basic_string<_CharT, _Traits, _Alloc>
3440 : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3441 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3442 : {
3443 : basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
3444 : __str.append(__rhs);
3445 : return __str;
3446 : }
3447 :
3448 : /**
3449 : * @brief Concatenate C string and string.
3450 : * @param __lhs First string.
3451 : * @param __rhs Last string.
3452 : * @return New string with value of @a __lhs followed by @a __rhs.
3453 : */
3454 : template<typename _CharT, typename _Traits, typename _Alloc>
3455 : _GLIBCXX20_CONSTEXPR
3456 : basic_string<_CharT,_Traits,_Alloc>
3457 : operator+(const _CharT* __lhs,
3458 : const basic_string<_CharT,_Traits,_Alloc>& __rhs);
3459 :
3460 : /**
3461 : * @brief Concatenate character and string.
3462 : * @param __lhs First string.
3463 : * @param __rhs Last string.
3464 : * @return New string with @a __lhs followed by @a __rhs.
3465 : */
3466 : template<typename _CharT, typename _Traits, typename _Alloc>
3467 : _GLIBCXX20_CONSTEXPR
3468 : basic_string<_CharT,_Traits,_Alloc>
3469 : operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
3470 :
3471 : /**
3472 : * @brief Concatenate string and C string.
3473 : * @param __lhs First string.
3474 : * @param __rhs Last string.
3475 : * @return New string with @a __lhs followed by @a __rhs.
3476 : */
3477 : template<typename _CharT, typename _Traits, typename _Alloc>
3478 : _GLIBCXX20_CONSTEXPR
3479 : inline basic_string<_CharT, _Traits, _Alloc>
3480 : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3481 : const _CharT* __rhs)
3482 : {
3483 : basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
3484 : __str.append(__rhs);
3485 : return __str;
3486 : }
3487 :
3488 : /**
3489 : * @brief Concatenate string and character.
3490 : * @param __lhs First string.
3491 : * @param __rhs Last string.
3492 : * @return New string with @a __lhs followed by @a __rhs.
3493 : */
3494 : template<typename _CharT, typename _Traits, typename _Alloc>
3495 : _GLIBCXX20_CONSTEXPR
3496 : inline basic_string<_CharT, _Traits, _Alloc>
3497 : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
3498 : {
3499 : typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
3500 : typedef typename __string_type::size_type __size_type;
3501 : __string_type __str(__lhs);
3502 : __str.append(__size_type(1), __rhs);
3503 : return __str;
3504 : }
3505 :
3506 : #if __cplusplus >= 201103L
3507 : template<typename _CharT, typename _Traits, typename _Alloc>
3508 : _GLIBCXX20_CONSTEXPR
3509 : inline basic_string<_CharT, _Traits, _Alloc>
3510 : operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
3511 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3512 : { return std::move(__lhs.append(__rhs)); }
3513 :
3514 : template<typename _CharT, typename _Traits, typename _Alloc>
3515 : _GLIBCXX20_CONSTEXPR
3516 : inline basic_string<_CharT, _Traits, _Alloc>
3517 : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3518 : basic_string<_CharT, _Traits, _Alloc>&& __rhs)
3519 : { return std::move(__rhs.insert(0, __lhs)); }
3520 :
3521 : template<typename _CharT, typename _Traits, typename _Alloc>
3522 : _GLIBCXX20_CONSTEXPR
3523 : inline basic_string<_CharT, _Traits, _Alloc>
3524 : operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
3525 : basic_string<_CharT, _Traits, _Alloc>&& __rhs)
3526 : {
3527 : #if _GLIBCXX_USE_CXX11_ABI
3528 : using _Alloc_traits = allocator_traits<_Alloc>;
3529 : bool __use_rhs = false;
3530 : if _GLIBCXX17_CONSTEXPR (typename _Alloc_traits::is_always_equal{})
3531 : __use_rhs = true;
3532 : else if (__lhs.get_allocator() == __rhs.get_allocator())
3533 : __use_rhs = true;
3534 : if (__use_rhs)
3535 : #endif
3536 : {
3537 : const auto __size = __lhs.size() + __rhs.size();
3538 : if (__size > __lhs.capacity() && __size <= __rhs.capacity())
3539 : return std::move(__rhs.insert(0, __lhs));
3540 : }
3541 : return std::move(__lhs.append(__rhs));
3542 : }
3543 :
3544 : template<typename _CharT, typename _Traits, typename _Alloc>
3545 : _GLIBCXX20_CONSTEXPR
3546 : inline basic_string<_CharT, _Traits, _Alloc>
3547 : operator+(const _CharT* __lhs,
3548 : basic_string<_CharT, _Traits, _Alloc>&& __rhs)
3549 : { return std::move(__rhs.insert(0, __lhs)); }
3550 :
3551 : template<typename _CharT, typename _Traits, typename _Alloc>
3552 : _GLIBCXX20_CONSTEXPR
3553 : inline basic_string<_CharT, _Traits, _Alloc>
3554 : operator+(_CharT __lhs,
3555 : basic_string<_CharT, _Traits, _Alloc>&& __rhs)
3556 : { return std::move(__rhs.insert(0, 1, __lhs)); }
3557 :
3558 : template<typename _CharT, typename _Traits, typename _Alloc>
3559 : _GLIBCXX20_CONSTEXPR
3560 : inline basic_string<_CharT, _Traits, _Alloc>
3561 : operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
3562 : const _CharT* __rhs)
3563 : { return std::move(__lhs.append(__rhs)); }
3564 :
3565 : template<typename _CharT, typename _Traits, typename _Alloc>
3566 : _GLIBCXX20_CONSTEXPR
3567 : inline basic_string<_CharT, _Traits, _Alloc>
3568 : operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
3569 : _CharT __rhs)
3570 : { return std::move(__lhs.append(1, __rhs)); }
3571 : #endif
3572 :
3573 : // operator ==
3574 : /**
3575 : * @brief Test equivalence of two strings.
3576 : * @param __lhs First string.
3577 : * @param __rhs Second string.
3578 : * @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise.
3579 : */
3580 : template<typename _CharT, typename _Traits, typename _Alloc>
3581 : _GLIBCXX20_CONSTEXPR
3582 : inline bool
3583 : operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3584 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3585 : _GLIBCXX_NOEXCEPT
3586 : { return __lhs.compare(__rhs) == 0; }
3587 :
3588 : template<typename _CharT>
3589 : _GLIBCXX20_CONSTEXPR
3590 : inline
3591 : typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
3592 0 : operator==(const basic_string<_CharT>& __lhs,
3593 : const basic_string<_CharT>& __rhs) _GLIBCXX_NOEXCEPT
3594 0 : { return (__lhs.size() == __rhs.size()
3595 0 : && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
3596 0 : __lhs.size())); }
3597 :
3598 : /**
3599 : * @brief Test equivalence of string and C string.
3600 : * @param __lhs String.
3601 : * @param __rhs C string.
3602 : * @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise.
3603 : */
3604 : template<typename _CharT, typename _Traits, typename _Alloc>
3605 : _GLIBCXX20_CONSTEXPR
3606 : inline bool
3607 2891 : operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3608 : const _CharT* __rhs)
3609 18 : { return __lhs.compare(__rhs) == 0; }
3610 :
3611 : #if __cpp_lib_three_way_comparison
3612 : /**
3613 : * @brief Three-way comparison of a string and a C string.
3614 : * @param __lhs A string.
3615 : * @param __rhs A null-terminated string.
3616 : * @return A value indicating whether `__lhs` is less than, equal to,
3617 : * greater than, or incomparable with `__rhs`.
3618 : */
3619 : template<typename _CharT, typename _Traits, typename _Alloc>
3620 : constexpr auto
3621 : operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3622 : const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept
3623 : -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
3624 : { return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
3625 :
3626 : /**
3627 : * @brief Three-way comparison of a string and a C string.
3628 : * @param __lhs A string.
3629 : * @param __rhs A null-terminated string.
3630 : * @return A value indicating whether `__lhs` is less than, equal to,
3631 : * greater than, or incomparable with `__rhs`.
3632 : */
3633 : template<typename _CharT, typename _Traits, typename _Alloc>
3634 : constexpr auto
3635 : operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3636 : const _CharT* __rhs) noexcept
3637 : -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
3638 : { return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
3639 : #else
3640 : /**
3641 : * @brief Test equivalence of C string and string.
3642 : * @param __lhs C string.
3643 : * @param __rhs String.
3644 : * @return True if @a __rhs.compare(@a __lhs) == 0. False otherwise.
3645 : */
3646 : template<typename _CharT, typename _Traits, typename _Alloc>
3647 : inline bool
3648 : operator==(const _CharT* __lhs,
3649 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3650 : { return __rhs.compare(__lhs) == 0; }
3651 :
3652 : // operator !=
3653 : /**
3654 : * @brief Test difference of two strings.
3655 : * @param __lhs First string.
3656 : * @param __rhs Second string.
3657 : * @return True if @a __lhs.compare(@a __rhs) != 0. False otherwise.
3658 : */
3659 : template<typename _CharT, typename _Traits, typename _Alloc>
3660 : inline bool
3661 0 : operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3662 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3663 : _GLIBCXX_NOEXCEPT
3664 0 : { return !(__lhs == __rhs); }
3665 :
3666 : /**
3667 : * @brief Test difference of C string and string.
3668 : * @param __lhs C string.
3669 : * @param __rhs String.
3670 : * @return True if @a __rhs.compare(@a __lhs) != 0. False otherwise.
3671 : */
3672 : template<typename _CharT, typename _Traits, typename _Alloc>
3673 : inline bool
3674 : operator!=(const _CharT* __lhs,
3675 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3676 : { return !(__lhs == __rhs); }
3677 :
3678 : /**
3679 : * @brief Test difference of string and C string.
3680 : * @param __lhs String.
3681 : * @param __rhs C string.
3682 : * @return True if @a __lhs.compare(@a __rhs) != 0. False otherwise.
3683 : */
3684 : template<typename _CharT, typename _Traits, typename _Alloc>
3685 : inline bool
3686 2873 : operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3687 : const _CharT* __rhs)
3688 2873 : { return !(__lhs == __rhs); }
3689 :
3690 : // operator <
3691 : /**
3692 : * @brief Test if string precedes string.
3693 : * @param __lhs First string.
3694 : * @param __rhs Second string.
3695 : * @return True if @a __lhs precedes @a __rhs. False otherwise.
3696 : */
3697 : template<typename _CharT, typename _Traits, typename _Alloc>
3698 : inline bool
3699 383379 : operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3700 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3701 : _GLIBCXX_NOEXCEPT
3702 383379 : { return __lhs.compare(__rhs) < 0; }
3703 :
3704 : /**
3705 : * @brief Test if string precedes C string.
3706 : * @param __lhs String.
3707 : * @param __rhs C string.
3708 : * @return True if @a __lhs precedes @a __rhs. False otherwise.
3709 : */
3710 : template<typename _CharT, typename _Traits, typename _Alloc>
3711 : inline bool
3712 : operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3713 : const _CharT* __rhs)
3714 : { return __lhs.compare(__rhs) < 0; }
3715 :
3716 : /**
3717 : * @brief Test if C string precedes string.
3718 : * @param __lhs C string.
3719 : * @param __rhs String.
3720 : * @return True if @a __lhs precedes @a __rhs. False otherwise.
3721 : */
3722 : template<typename _CharT, typename _Traits, typename _Alloc>
3723 : inline bool
3724 : operator<(const _CharT* __lhs,
3725 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3726 : { return __rhs.compare(__lhs) > 0; }
3727 :
3728 : // operator >
3729 : /**
3730 : * @brief Test if string follows string.
3731 : * @param __lhs First string.
3732 : * @param __rhs Second string.
3733 : * @return True if @a __lhs follows @a __rhs. False otherwise.
3734 : */
3735 : template<typename _CharT, typename _Traits, typename _Alloc>
3736 : inline bool
3737 : operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3738 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3739 : _GLIBCXX_NOEXCEPT
3740 : { return __lhs.compare(__rhs) > 0; }
3741 :
3742 : /**
3743 : * @brief Test if string follows C string.
3744 : * @param __lhs String.
3745 : * @param __rhs C string.
3746 : * @return True if @a __lhs follows @a __rhs. False otherwise.
3747 : */
3748 : template<typename _CharT, typename _Traits, typename _Alloc>
3749 : inline bool
3750 : operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3751 : const _CharT* __rhs)
3752 : { return __lhs.compare(__rhs) > 0; }
3753 :
3754 : /**
3755 : * @brief Test if C string follows string.
3756 : * @param __lhs C string.
3757 : * @param __rhs String.
3758 : * @return True if @a __lhs follows @a __rhs. False otherwise.
3759 : */
3760 : template<typename _CharT, typename _Traits, typename _Alloc>
3761 : inline bool
3762 : operator>(const _CharT* __lhs,
3763 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3764 : { return __rhs.compare(__lhs) < 0; }
3765 :
3766 : // operator <=
3767 : /**
3768 : * @brief Test if string doesn't follow string.
3769 : * @param __lhs First string.
3770 : * @param __rhs Second string.
3771 : * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
3772 : */
3773 : template<typename _CharT, typename _Traits, typename _Alloc>
3774 : inline bool
3775 : operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3776 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3777 : _GLIBCXX_NOEXCEPT
3778 : { return __lhs.compare(__rhs) <= 0; }
3779 :
3780 : /**
3781 : * @brief Test if string doesn't follow C string.
3782 : * @param __lhs String.
3783 : * @param __rhs C string.
3784 : * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
3785 : */
3786 : template<typename _CharT, typename _Traits, typename _Alloc>
3787 : inline bool
3788 : operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3789 : const _CharT* __rhs)
3790 : { return __lhs.compare(__rhs) <= 0; }
3791 :
3792 : /**
3793 : * @brief Test if C string doesn't follow string.
3794 : * @param __lhs C string.
3795 : * @param __rhs String.
3796 : * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
3797 : */
3798 : template<typename _CharT, typename _Traits, typename _Alloc>
3799 : inline bool
3800 : operator<=(const _CharT* __lhs,
3801 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3802 : { return __rhs.compare(__lhs) >= 0; }
3803 :
3804 : // operator >=
3805 : /**
3806 : * @brief Test if string doesn't precede string.
3807 : * @param __lhs First string.
3808 : * @param __rhs Second string.
3809 : * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
3810 : */
3811 : template<typename _CharT, typename _Traits, typename _Alloc>
3812 : inline bool
3813 : operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3814 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3815 : _GLIBCXX_NOEXCEPT
3816 : { return __lhs.compare(__rhs) >= 0; }
3817 :
3818 : /**
3819 : * @brief Test if string doesn't precede C string.
3820 : * @param __lhs String.
3821 : * @param __rhs C string.
3822 : * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
3823 : */
3824 : template<typename _CharT, typename _Traits, typename _Alloc>
3825 : inline bool
3826 : operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
3827 : const _CharT* __rhs)
3828 : { return __lhs.compare(__rhs) >= 0; }
3829 :
3830 : /**
3831 : * @brief Test if C string doesn't precede string.
3832 : * @param __lhs C string.
3833 : * @param __rhs String.
3834 : * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
3835 : */
3836 : template<typename _CharT, typename _Traits, typename _Alloc>
3837 : inline bool
3838 : operator>=(const _CharT* __lhs,
3839 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
3840 : { return __rhs.compare(__lhs) <= 0; }
3841 : #endif // three-way comparison
3842 :
3843 : /**
3844 : * @brief Swap contents of two strings.
3845 : * @param __lhs First string.
3846 : * @param __rhs Second string.
3847 : *
3848 : * Exchanges the contents of @a __lhs and @a __rhs in constant time.
3849 : */
3850 : template<typename _CharT, typename _Traits, typename _Alloc>
3851 : _GLIBCXX20_CONSTEXPR
3852 : inline void
3853 : swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
3854 : basic_string<_CharT, _Traits, _Alloc>& __rhs)
3855 : _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
3856 : { __lhs.swap(__rhs); }
3857 :
3858 :
3859 : /**
3860 : * @brief Read stream into a string.
3861 : * @param __is Input stream.
3862 : * @param __str Buffer to store into.
3863 : * @return Reference to the input stream.
3864 : *
3865 : * Stores characters from @a __is into @a __str until whitespace is
3866 : * found, the end of the stream is encountered, or str.max_size()
3867 : * is reached. If is.width() is non-zero, that is the limit on the
3868 : * number of characters stored into @a __str. Any previous
3869 : * contents of @a __str are erased.
3870 : */
3871 : template<typename _CharT, typename _Traits, typename _Alloc>
3872 : basic_istream<_CharT, _Traits>&
3873 : operator>>(basic_istream<_CharT, _Traits>& __is,
3874 : basic_string<_CharT, _Traits, _Alloc>& __str);
3875 :
3876 : template<>
3877 : basic_istream<char>&
3878 : operator>>(basic_istream<char>& __is, basic_string<char>& __str);
3879 :
3880 : /**
3881 : * @brief Write string to a stream.
3882 : * @param __os Output stream.
3883 : * @param __str String to write out.
3884 : * @return Reference to the output stream.
3885 : *
3886 : * Output characters of @a __str into os following the same rules as for
3887 : * writing a C string.
3888 : */
3889 : template<typename _CharT, typename _Traits, typename _Alloc>
3890 : inline basic_ostream<_CharT, _Traits>&
3891 : operator<<(basic_ostream<_CharT, _Traits>& __os,
3892 : const basic_string<_CharT, _Traits, _Alloc>& __str)
3893 : {
3894 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
3895 : // 586. string inserter not a formatted function
3896 : return __ostream_insert(__os, __str.data(), __str.size());
3897 : }
3898 :
3899 : /**
3900 : * @brief Read a line from stream into a string.
3901 : * @param __is Input stream.
3902 : * @param __str Buffer to store into.
3903 : * @param __delim Character marking end of line.
3904 : * @return Reference to the input stream.
3905 : *
3906 : * Stores characters from @a __is into @a __str until @a __delim is
3907 : * found, the end of the stream is encountered, or str.max_size()
3908 : * is reached. Any previous contents of @a __str are erased. If
3909 : * @a __delim is encountered, it is extracted but not stored into
3910 : * @a __str.
3911 : */
3912 : template<typename _CharT, typename _Traits, typename _Alloc>
3913 : basic_istream<_CharT, _Traits>&
3914 : getline(basic_istream<_CharT, _Traits>& __is,
3915 : basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
3916 :
3917 : /**
3918 : * @brief Read a line from stream into a string.
3919 : * @param __is Input stream.
3920 : * @param __str Buffer to store into.
3921 : * @return Reference to the input stream.
3922 : *
3923 : * Stores characters from is into @a __str until '\n' is
3924 : * found, the end of the stream is encountered, or str.max_size()
3925 : * is reached. Any previous contents of @a __str are erased. If
3926 : * end of line is encountered, it is extracted but not stored into
3927 : * @a __str.
3928 : */
3929 : template<typename _CharT, typename _Traits, typename _Alloc>
3930 : inline basic_istream<_CharT, _Traits>&
3931 : getline(basic_istream<_CharT, _Traits>& __is,
3932 : basic_string<_CharT, _Traits, _Alloc>& __str)
3933 : { return std::getline(__is, __str, __is.widen('\n')); }
3934 :
3935 : #if __cplusplus >= 201103L
3936 : /// Read a line from an rvalue stream into a string.
3937 : template<typename _CharT, typename _Traits, typename _Alloc>
3938 : inline basic_istream<_CharT, _Traits>&
3939 : getline(basic_istream<_CharT, _Traits>&& __is,
3940 : basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
3941 : { return std::getline(__is, __str, __delim); }
3942 :
3943 : /// Read a line from an rvalue stream into a string.
3944 : template<typename _CharT, typename _Traits, typename _Alloc>
3945 : inline basic_istream<_CharT, _Traits>&
3946 : getline(basic_istream<_CharT, _Traits>&& __is,
3947 : basic_string<_CharT, _Traits, _Alloc>& __str)
3948 : { return std::getline(__is, __str); }
3949 : #endif
3950 :
3951 : template<>
3952 : basic_istream<char>&
3953 : getline(basic_istream<char>& __in, basic_string<char>& __str,
3954 : char __delim);
3955 :
3956 : #ifdef _GLIBCXX_USE_WCHAR_T
3957 : template<>
3958 : basic_istream<wchar_t>&
3959 : getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
3960 : wchar_t __delim);
3961 : #endif
3962 :
3963 : _GLIBCXX_END_NAMESPACE_VERSION
3964 : } // namespace
3965 :
3966 : #if __cplusplus >= 201103L
3967 :
3968 : #include <ext/string_conversions.h>
3969 : #include <bits/charconv.h>
3970 :
3971 : namespace std _GLIBCXX_VISIBILITY(default)
3972 : {
3973 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
3974 : _GLIBCXX_BEGIN_NAMESPACE_CXX11
3975 :
3976 : #if _GLIBCXX_USE_C99_STDLIB
3977 : // 21.4 Numeric Conversions [string.conversions].
3978 : inline int
3979 : stoi(const string& __str, size_t* __idx = 0, int __base = 10)
3980 : { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
3981 : __idx, __base); }
3982 :
3983 : inline long
3984 : stol(const string& __str, size_t* __idx = 0, int __base = 10)
3985 : { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
3986 : __idx, __base); }
3987 :
3988 : inline unsigned long
3989 : stoul(const string& __str, size_t* __idx = 0, int __base = 10)
3990 : { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
3991 : __idx, __base); }
3992 :
3993 : inline long long
3994 : stoll(const string& __str, size_t* __idx = 0, int __base = 10)
3995 : { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
3996 : __idx, __base); }
3997 :
3998 : inline unsigned long long
3999 : stoull(const string& __str, size_t* __idx = 0, int __base = 10)
4000 : { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
4001 : __idx, __base); }
4002 :
4003 : // NB: strtof vs strtod.
4004 : inline float
4005 : stof(const string& __str, size_t* __idx = 0)
4006 : { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
4007 :
4008 : inline double
4009 : stod(const string& __str, size_t* __idx = 0)
4010 : { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
4011 :
4012 : inline long double
4013 : stold(const string& __str, size_t* __idx = 0)
4014 : { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
4015 : #endif // _GLIBCXX_USE_C99_STDLIB
4016 :
4017 : // DR 1261. Insufficent overloads for to_string / to_wstring
4018 :
4019 : inline string
4020 : to_string(int __val)
4021 : #if _GLIBCXX_USE_CXX11_ABI && (__CHAR_BIT__ * __SIZEOF_INT__) <= 32
4022 : noexcept // any 32-bit value fits in the SSO buffer
4023 : #endif
4024 : {
4025 : const bool __neg = __val < 0;
4026 : const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val;
4027 : const auto __len = __detail::__to_chars_len(__uval);
4028 : string __str(__neg + __len, '-');
4029 : __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
4030 : return __str;
4031 : }
4032 :
4033 : inline string
4034 : to_string(unsigned __val)
4035 : #if _GLIBCXX_USE_CXX11_ABI && (__CHAR_BIT__ * __SIZEOF_INT__) <= 32
4036 : noexcept // any 32-bit value fits in the SSO buffer
4037 : #endif
4038 : {
4039 : string __str(__detail::__to_chars_len(__val), '\0');
4040 : __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
4041 : return __str;
4042 : }
4043 :
4044 : inline string
4045 : to_string(long __val)
4046 : #if _GLIBCXX_USE_CXX11_ABI && (__CHAR_BIT__ * __SIZEOF_LONG__) <= 32
4047 : noexcept // any 32-bit value fits in the SSO buffer
4048 : #endif
4049 : {
4050 : const bool __neg = __val < 0;
4051 : const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val;
4052 : const auto __len = __detail::__to_chars_len(__uval);
4053 : string __str(__neg + __len, '-');
4054 : __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
4055 : return __str;
4056 : }
4057 :
4058 : inline string
4059 : to_string(unsigned long __val)
4060 : #if _GLIBCXX_USE_CXX11_ABI && (__CHAR_BIT__ * __SIZEOF_LONG__) <= 32
4061 : noexcept // any 32-bit value fits in the SSO buffer
4062 : #endif
4063 : {
4064 : string __str(__detail::__to_chars_len(__val), '\0');
4065 : __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
4066 : return __str;
4067 : }
4068 :
4069 : inline string
4070 : to_string(long long __val)
4071 : {
4072 : const bool __neg = __val < 0;
4073 : const unsigned long long __uval
4074 : = __neg ? (unsigned long long)~__val + 1ull : __val;
4075 : const auto __len = __detail::__to_chars_len(__uval);
4076 : string __str(__neg + __len, '-');
4077 : __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
4078 : return __str;
4079 : }
4080 :
4081 : inline string
4082 : to_string(unsigned long long __val)
4083 : {
4084 : string __str(__detail::__to_chars_len(__val), '\0');
4085 : __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
4086 : return __str;
4087 : }
4088 :
4089 : #if _GLIBCXX_USE_C99_STDIO
4090 : // NB: (v)snprintf vs sprintf.
4091 :
4092 : inline string
4093 : to_string(float __val)
4094 : {
4095 : const int __n =
4096 : __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
4097 : return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
4098 : "%f", __val);
4099 : }
4100 :
4101 : inline string
4102 : to_string(double __val)
4103 : {
4104 : const int __n =
4105 : __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
4106 : return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
4107 : "%f", __val);
4108 : }
4109 :
4110 : inline string
4111 : to_string(long double __val)
4112 : {
4113 : const int __n =
4114 : __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
4115 : return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
4116 : "%Lf", __val);
4117 : }
4118 : #endif // _GLIBCXX_USE_C99_STDIO
4119 :
4120 : #if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_WCHAR
4121 : inline int
4122 : stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
4123 : { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
4124 : __idx, __base); }
4125 :
4126 : inline long
4127 : stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
4128 : { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
4129 : __idx, __base); }
4130 :
4131 : inline unsigned long
4132 : stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
4133 : { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
4134 : __idx, __base); }
4135 :
4136 : inline long long
4137 : stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
4138 : { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
4139 : __idx, __base); }
4140 :
4141 : inline unsigned long long
4142 : stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
4143 : { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
4144 : __idx, __base); }
4145 :
4146 : // NB: wcstof vs wcstod.
4147 : inline float
4148 : stof(const wstring& __str, size_t* __idx = 0)
4149 : { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
4150 :
4151 : inline double
4152 : stod(const wstring& __str, size_t* __idx = 0)
4153 : { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
4154 :
4155 : inline long double
4156 : stold(const wstring& __str, size_t* __idx = 0)
4157 : { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
4158 :
4159 : #ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF
4160 : // DR 1261.
4161 : inline wstring
4162 : to_wstring(int __val)
4163 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
4164 : L"%d", __val); }
4165 :
4166 : inline wstring
4167 : to_wstring(unsigned __val)
4168 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4169 : 4 * sizeof(unsigned),
4170 : L"%u", __val); }
4171 :
4172 : inline wstring
4173 : to_wstring(long __val)
4174 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
4175 : L"%ld", __val); }
4176 :
4177 : inline wstring
4178 : to_wstring(unsigned long __val)
4179 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4180 : 4 * sizeof(unsigned long),
4181 : L"%lu", __val); }
4182 :
4183 : inline wstring
4184 : to_wstring(long long __val)
4185 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4186 : 4 * sizeof(long long),
4187 : L"%lld", __val); }
4188 :
4189 : inline wstring
4190 : to_wstring(unsigned long long __val)
4191 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
4192 : 4 * sizeof(unsigned long long),
4193 : L"%llu", __val); }
4194 :
4195 : inline wstring
4196 : to_wstring(float __val)
4197 : {
4198 : const int __n =
4199 : __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
4200 : return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
4201 : L"%f", __val);
4202 : }
4203 :
4204 : inline wstring
4205 : to_wstring(double __val)
4206 : {
4207 : const int __n =
4208 : __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
4209 : return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
4210 : L"%f", __val);
4211 : }
4212 :
4213 : inline wstring
4214 : to_wstring(long double __val)
4215 : {
4216 : const int __n =
4217 : __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
4218 : return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
4219 : L"%Lf", __val);
4220 : }
4221 : #endif // _GLIBCXX_HAVE_BROKEN_VSWPRINTF
4222 : #endif // _GLIBCXX_USE_WCHAR_T && _GLIBCXX_USE_C99_WCHAR
4223 :
4224 : _GLIBCXX_END_NAMESPACE_CXX11
4225 : _GLIBCXX_END_NAMESPACE_VERSION
4226 : } // namespace
4227 :
4228 : #endif /* C++11 */
4229 :
4230 : #if __cplusplus >= 201103L
4231 :
4232 : #include <bits/functional_hash.h>
4233 :
4234 : namespace std _GLIBCXX_VISIBILITY(default)
4235 : {
4236 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
4237 :
4238 : // DR 1182.
4239 :
4240 : #ifndef _GLIBCXX_COMPATIBILITY_CXX0X
4241 : /// std::hash specialization for string.
4242 : template<>
4243 : struct hash<string>
4244 : : public __hash_base<size_t, string>
4245 : {
4246 : size_t
4247 : operator()(const string& __s) const noexcept
4248 : { return std::_Hash_impl::hash(__s.data(), __s.length()); }
4249 : };
4250 :
4251 : template<>
4252 : struct __is_fast_hash<hash<string>> : std::false_type
4253 : { };
4254 :
4255 : /// std::hash specialization for wstring.
4256 : template<>
4257 : struct hash<wstring>
4258 : : public __hash_base<size_t, wstring>
4259 : {
4260 : size_t
4261 : operator()(const wstring& __s) const noexcept
4262 : { return std::_Hash_impl::hash(__s.data(),
4263 : __s.length() * sizeof(wchar_t)); }
4264 : };
4265 :
4266 : template<>
4267 : struct __is_fast_hash<hash<wstring>> : std::false_type
4268 : { };
4269 : #endif /* _GLIBCXX_COMPATIBILITY_CXX0X */
4270 :
4271 : #ifdef _GLIBCXX_USE_CHAR8_T
4272 : /// std::hash specialization for u8string.
4273 : template<>
4274 : struct hash<u8string>
4275 : : public __hash_base<size_t, u8string>
4276 : {
4277 : size_t
4278 : operator()(const u8string& __s) const noexcept
4279 : { return std::_Hash_impl::hash(__s.data(),
4280 : __s.length() * sizeof(char8_t)); }
4281 : };
4282 :
4283 : template<>
4284 : struct __is_fast_hash<hash<u8string>> : std::false_type
4285 : { };
4286 : #endif
4287 :
4288 : /// std::hash specialization for u16string.
4289 : template<>
4290 : struct hash<u16string>
4291 : : public __hash_base<size_t, u16string>
4292 : {
4293 : size_t
4294 : operator()(const u16string& __s) const noexcept
4295 : { return std::_Hash_impl::hash(__s.data(),
4296 : __s.length() * sizeof(char16_t)); }
4297 : };
4298 :
4299 : template<>
4300 : struct __is_fast_hash<hash<u16string>> : std::false_type
4301 : { };
4302 :
4303 : /// std::hash specialization for u32string.
4304 : template<>
4305 : struct hash<u32string>
4306 : : public __hash_base<size_t, u32string>
4307 : {
4308 : size_t
4309 : operator()(const u32string& __s) const noexcept
4310 : { return std::_Hash_impl::hash(__s.data(),
4311 : __s.length() * sizeof(char32_t)); }
4312 : };
4313 :
4314 : template<>
4315 : struct __is_fast_hash<hash<u32string>> : std::false_type
4316 : { };
4317 :
4318 : #if __cplusplus >= 201402L
4319 :
4320 : #define __cpp_lib_string_udls 201304L
4321 :
4322 : inline namespace literals
4323 : {
4324 : inline namespace string_literals
4325 : {
4326 : #pragma GCC diagnostic push
4327 : #pragma GCC diagnostic ignored "-Wliteral-suffix"
4328 :
4329 : #if __cpp_lib_constexpr_string >= 201907L
4330 : # define _GLIBCXX_STRING_CONSTEXPR constexpr
4331 : #else
4332 : # define _GLIBCXX_STRING_CONSTEXPR
4333 : #endif
4334 :
4335 : _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_STRING_CONSTEXPR
4336 : inline basic_string<char>
4337 : operator""s(const char* __str, size_t __len)
4338 : { return basic_string<char>{__str, __len}; }
4339 :
4340 : _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_STRING_CONSTEXPR
4341 : inline basic_string<wchar_t>
4342 : operator""s(const wchar_t* __str, size_t __len)
4343 : { return basic_string<wchar_t>{__str, __len}; }
4344 :
4345 : #ifdef _GLIBCXX_USE_CHAR8_T
4346 : _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_STRING_CONSTEXPR
4347 : inline basic_string<char8_t>
4348 : operator""s(const char8_t* __str, size_t __len)
4349 : { return basic_string<char8_t>{__str, __len}; }
4350 : #endif
4351 :
4352 : _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_STRING_CONSTEXPR
4353 : inline basic_string<char16_t>
4354 : operator""s(const char16_t* __str, size_t __len)
4355 : { return basic_string<char16_t>{__str, __len}; }
4356 :
4357 : _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_STRING_CONSTEXPR
4358 : inline basic_string<char32_t>
4359 : operator""s(const char32_t* __str, size_t __len)
4360 : { return basic_string<char32_t>{__str, __len}; }
4361 :
4362 : #undef _GLIBCXX_STRING_CONSTEXPR
4363 : #pragma GCC diagnostic pop
4364 : } // inline namespace string_literals
4365 : } // inline namespace literals
4366 :
4367 : #if __cplusplus >= 201703L
4368 : namespace __detail::__variant
4369 : {
4370 : template<typename> struct _Never_valueless_alt; // see <variant>
4371 :
4372 : // Provide the strong exception-safety guarantee when emplacing a
4373 : // basic_string into a variant, but only if moving the string cannot throw.
4374 : template<typename _Tp, typename _Traits, typename _Alloc>
4375 : struct _Never_valueless_alt<std::basic_string<_Tp, _Traits, _Alloc>>
4376 : : __and_<
4377 : is_nothrow_move_constructible<std::basic_string<_Tp, _Traits, _Alloc>>,
4378 : is_nothrow_move_assignable<std::basic_string<_Tp, _Traits, _Alloc>>
4379 : >::type
4380 : { };
4381 : } // namespace __detail::__variant
4382 : #endif // C++17
4383 : #endif // C++14
4384 :
4385 : _GLIBCXX_END_NAMESPACE_VERSION
4386 : } // namespace std
4387 :
4388 : #endif // C++11
4389 :
4390 : #endif /* _BASIC_STRING_H */
|
