Line data Source code
1 : // Components for manipulating sequences of characters -*- C++ -*-
2 :
3 : // Copyright (C) 1997-2018 Free Software Foundation, Inc.
4 : //
5 : // This file is part of the GNU ISO C++ Library. This library is free
6 : // software; you can redistribute it and/or modify it under the
7 : // terms of the GNU General Public License as published by the
8 : // Free Software Foundation; either version 3, or (at your option)
9 : // any later version.
10 :
11 : // This library is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 :
16 : // Under Section 7 of GPL version 3, you are granted additional
17 : // permissions described in the GCC Runtime Library Exception, version
18 : // 3.1, as published by the Free Software Foundation.
19 :
20 : // You should have received a copy of the GNU General Public License and
21 : // a copy of the GCC Runtime Library Exception along with this program;
22 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 : // <http://www.gnu.org/licenses/>.
24 :
25 : /** @file 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/atomicity.h>
40 : #include <ext/alloc_traits.h>
41 : #include <debug/debug.h>
42 :
43 : #if __cplusplus >= 201103L
44 : #include <initializer_list>
45 : #endif
46 :
47 : #if __cplusplus > 201402L
48 : # include <string_view>
49 : #endif
50 :
51 :
52 : namespace std _GLIBCXX_VISIBILITY(default)
53 : {
54 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
55 :
56 : #if _GLIBCXX_USE_CXX11_ABI
57 : _GLIBCXX_BEGIN_NAMESPACE_CXX11
58 : /**
59 : * @class basic_string basic_string.h <string>
60 : * @brief Managing sequences of characters and character-like objects.
61 : *
62 : * @ingroup strings
63 : * @ingroup sequences
64 : *
65 : * @tparam _CharT Type of character
66 : * @tparam _Traits Traits for character type, defaults to
67 : * char_traits<_CharT>.
68 : * @tparam _Alloc Allocator type, defaults to allocator<_CharT>.
69 : *
70 : * Meets the requirements of a <a href="tables.html#65">container</a>, a
71 : * <a href="tables.html#66">reversible container</a>, and a
72 : * <a href="tables.html#67">sequence</a>. Of the
73 : * <a href="tables.html#68">optional sequence requirements</a>, only
74 : * @c push_back, @c at, and @c %array access are supported.
75 : */
76 : template<typename _CharT, typename _Traits, typename _Alloc>
77 : class basic_string
78 : {
79 : typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
80 : rebind<_CharT>::other _Char_alloc_type;
81 : typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
82 :
83 : // Types:
84 : public:
85 : typedef _Traits traits_type;
86 : typedef typename _Traits::char_type value_type;
87 : typedef _Char_alloc_type allocator_type;
88 : typedef typename _Alloc_traits::size_type size_type;
89 : typedef typename _Alloc_traits::difference_type difference_type;
90 : typedef typename _Alloc_traits::reference reference;
91 : typedef typename _Alloc_traits::const_reference const_reference;
92 : typedef typename _Alloc_traits::pointer pointer;
93 : typedef typename _Alloc_traits::const_pointer const_pointer;
94 : typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
95 : typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
96 : const_iterator;
97 : typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
98 : typedef std::reverse_iterator<iterator> reverse_iterator;
99 :
100 : /// Value returned by various member functions when they fail.
101 : static const size_type npos = static_cast<size_type>(-1);
102 :
103 : private:
104 : // type used for positions in insert, erase etc.
105 : #if __cplusplus < 201103L
106 : typedef iterator __const_iterator;
107 : #else
108 : typedef const_iterator __const_iterator;
109 : #endif
110 :
111 : #if __cplusplus > 201402L
112 : // A helper type for avoiding boiler-plate.
113 : typedef basic_string_view<_CharT, _Traits> __sv_type;
114 :
115 : template<typename _Tp, typename _Res>
116 : using _If_sv = enable_if_t<
117 : __and_<is_convertible<const _Tp&, __sv_type>,
118 : __not_<is_convertible<const _Tp*, const basic_string*>>,
119 : __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
120 : _Res>;
121 :
122 : // Allows an implicit conversion to __sv_type.
123 : static __sv_type
124 : _S_to_string_view(__sv_type __svt) noexcept
125 : { return __svt; }
126 :
127 : // Wraps a string_view by explicit conversion and thus
128 : // allows to add an internal constructor that does not
129 : // participate in overload resolution when a string_view
130 : // is provided.
131 : struct __sv_wrapper
132 : {
133 : explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }
134 : __sv_type _M_sv;
135 : };
136 : #endif
137 :
138 : // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
139 : struct _Alloc_hider : allocator_type // TODO check __is_final
140 : {
141 : #if __cplusplus < 201103L
142 : _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
143 : : allocator_type(__a), _M_p(__dat) { }
144 : #else
145 1013752 : _Alloc_hider(pointer __dat, const _Alloc& __a)
146 1013752 : : allocator_type(__a), _M_p(__dat) { }
147 :
148 8300 : _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
149 8300 : : allocator_type(std::move(__a)), _M_p(__dat) { }
150 : #endif
151 :
152 : pointer _M_p; // The actual data.
153 : };
154 :
155 : _Alloc_hider _M_dataplus;
156 : size_type _M_string_length;
157 :
158 : enum { _S_local_capacity = 15 / sizeof(_CharT) };
159 :
160 : union
161 : {
162 : _CharT _M_local_buf[_S_local_capacity + 1];
163 : size_type _M_allocated_capacity;
164 : };
165 :
166 : void
167 998891 : _M_data(pointer __p)
168 998891 : { _M_dataplus._M_p = __p; }
169 :
170 : void
171 1029770 : _M_length(size_type __length)
172 1029770 : { _M_string_length = __length; }
173 :
174 : pointer
175 4099744 : _M_data() const
176 4099744 : { return _M_dataplus._M_p; }
177 :
178 : pointer
179 1025066 : _M_local_data()
180 : {
181 : #if __cplusplus >= 201103L
182 1025066 : return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
183 : #else
184 : return pointer(_M_local_buf);
185 : #endif
186 : }
187 :
188 : const_pointer
189 1033545 : _M_local_data() const
190 : {
191 : #if __cplusplus >= 201103L
192 1033545 : return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
193 : #else
194 : return const_pointer(_M_local_buf);
195 : #endif
196 : }
197 :
198 : void
199 995797 : _M_capacity(size_type __capacity)
200 995797 : { _M_allocated_capacity = __capacity; }
201 :
202 : void
203 1026677 : _M_set_length(size_type __n)
204 : {
205 1026677 : _M_length(__n);
206 1026676 : traits_type::assign(_M_data()[__n], _CharT());
207 1026675 : }
208 :
209 : bool
210 1033544 : _M_is_local() const
211 1033544 : { return _M_data() == _M_local_data(); }
212 :
213 : // Create & Destroy
214 : pointer
215 : _M_create(size_type&, size_type);
216 :
217 : void
218 1024254 : _M_dispose()
219 : {
220 1024254 : if (!_M_is_local())
221 994906 : _M_destroy(_M_allocated_capacity);
222 1024254 : }
223 :
224 : void
225 994906 : _M_destroy(size_type __size) throw()
226 994906 : { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
227 :
228 : // _M_construct_aux is used to implement the 21.3.1 para 15 which
229 : // requires special behaviour if _InIterator is an integral type
230 : template<typename _InIterator>
231 : void
232 1017747 : _M_construct_aux(_InIterator __beg, _InIterator __end,
233 : std::__false_type)
234 : {
235 : typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
236 1017747 : _M_construct(__beg, __end, _Tag());
237 1017746 : }
238 :
239 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
240 : // 438. Ambiguity in the "do the right thing" clause
241 : template<typename _Integer>
242 : void
243 : _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
244 : { _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
245 :
246 : void
247 : _M_construct_aux_2(size_type __req, _CharT __c)
248 : { _M_construct(__req, __c); }
249 :
250 : template<typename _InIterator>
251 : void
252 1017747 : _M_construct(_InIterator __beg, _InIterator __end)
253 : {
254 : typedef typename std::__is_integer<_InIterator>::__type _Integral;
255 1017747 : _M_construct_aux(__beg, __end, _Integral());
256 1017746 : }
257 :
258 : // For Input Iterators, used in istreambuf_iterators, etc.
259 : template<typename _InIterator>
260 : void
261 : _M_construct(_InIterator __beg, _InIterator __end,
262 : std::input_iterator_tag);
263 :
264 : // For forward_iterators up to random_access_iterators, used for
265 : // string::iterator, _CharT*, etc.
266 : template<typename _FwdIterator>
267 : void
268 : _M_construct(_FwdIterator __beg, _FwdIterator __end,
269 : std::forward_iterator_tag);
270 :
271 : void
272 : _M_construct(size_type __req, _CharT __c);
273 :
274 : allocator_type&
275 1993305 : _M_get_allocator()
276 1993305 : { return _M_dataplus; }
277 :
278 : const allocator_type&
279 1001826 : _M_get_allocator() const
280 1001826 : { return _M_dataplus; }
281 :
282 : private:
283 :
284 : #ifdef _GLIBCXX_DISAMBIGUATE_REPLACE_INST
285 : // The explicit instantiations in misc-inst.cc require this due to
286 : // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64063
287 : template<typename _Tp, bool _Requires =
288 : !__are_same<_Tp, _CharT*>::__value
289 : && !__are_same<_Tp, const _CharT*>::__value
290 : && !__are_same<_Tp, iterator>::__value
291 : && !__are_same<_Tp, const_iterator>::__value>
292 : struct __enable_if_not_native_iterator
293 : { typedef basic_string& __type; };
294 : template<typename _Tp>
295 : struct __enable_if_not_native_iterator<_Tp, false> { };
296 : #endif
297 :
298 : size_type
299 638 : _M_check(size_type __pos, const char* __s) const
300 : {
301 638 : if (__pos > this->size())
302 0 : __throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > "
303 : "this->size() (which is %zu)"),
304 : __s, __pos, this->size());
305 638 : return __pos;
306 : }
307 :
308 : void
309 2047 : _M_check_length(size_type __n1, size_type __n2, const char* __s) const
310 : {
311 2047 : if (this->max_size() - (this->size() - __n1) < __n2)
312 0 : __throw_length_error(__N(__s));
313 2047 : }
314 :
315 :
316 : // NB: _M_limit doesn't check for a bad __pos value.
317 : size_type
318 638 : _M_limit(size_type __pos, size_type __off) const _GLIBCXX_NOEXCEPT
319 : {
320 638 : const bool __testoff = __off < this->size() - __pos;
321 638 : return __testoff ? __off : this->size() - __pos;
322 : }
323 :
324 : // True if _Rep and source do not overlap.
325 : bool
326 657 : _M_disjunct(const _CharT* __s) const _GLIBCXX_NOEXCEPT
327 : {
328 657 : return (less<const _CharT*>()(__s, _M_data())
329 657 : || less<const _CharT*>()(_M_data() + this->size(), __s));
330 : }
331 :
332 : // When __n = 1 way faster than the general multichar
333 : // traits_type::copy/move/assign.
334 : static void
335 1023071 : _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
336 : {
337 1023071 : if (__n == 1)
338 5135 : traits_type::assign(*__d, *__s);
339 : else
340 1017936 : traits_type::copy(__d, __s, __n);
341 1023072 : }
342 :
343 : static void
344 182 : _S_move(_CharT* __d, const _CharT* __s, size_type __n)
345 : {
346 182 : if (__n == 1)
347 31 : traits_type::assign(*__d, *__s);
348 : else
349 151 : traits_type::move(__d, __s, __n);
350 182 : }
351 :
352 : static void
353 : _S_assign(_CharT* __d, size_type __n, _CharT __c)
354 : {
355 : if (__n == 1)
356 : traits_type::assign(*__d, __c);
357 : else
358 : traits_type::assign(__d, __n, __c);
359 : }
360 :
361 : // _S_copy_chars is a separate template to permit specialization
362 : // to optimize for the common case of pointers as iterators.
363 : template<class _Iterator>
364 : static void
365 : _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
366 : {
367 : for (; __k1 != __k2; ++__k1, (void)++__p)
368 : traits_type::assign(*__p, *__k1); // These types are off.
369 : }
370 :
371 : static void
372 : _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) _GLIBCXX_NOEXCEPT
373 : { _S_copy_chars(__p, __k1.base(), __k2.base()); }
374 :
375 : static void
376 : _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
377 : _GLIBCXX_NOEXCEPT
378 : { _S_copy_chars(__p, __k1.base(), __k2.base()); }
379 :
380 : static void
381 4630 : _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) _GLIBCXX_NOEXCEPT
382 4630 : { _S_copy(__p, __k1, __k2 - __k1); }
383 :
384 : static void
385 1013118 : _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
386 : _GLIBCXX_NOEXCEPT
387 1013118 : { _S_copy(__p, __k1, __k2 - __k1); }
388 :
389 : static int
390 : _S_compare(size_type __n1, size_type __n2) _GLIBCXX_NOEXCEPT
391 : {
392 : const difference_type __d = difference_type(__n1 - __n2);
393 :
394 : if (__d > __gnu_cxx::__numeric_traits<int>::__max)
395 : return __gnu_cxx::__numeric_traits<int>::__max;
396 : else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
397 : return __gnu_cxx::__numeric_traits<int>::__min;
398 : else
399 : return int(__d);
400 : }
401 :
402 : void
403 : _M_assign(const basic_string&);
404 :
405 : void
406 : _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
407 : size_type __len2);
408 :
409 : void
410 : _M_erase(size_type __pos, size_type __n);
411 :
412 : public:
413 : // Construct/copy/destroy:
414 : // NB: We overload ctors in some cases instead of using default
415 : // arguments, per 17.4.4.4 para. 2 item 2.
416 :
417 : /**
418 : * @brief Default constructor creates an empty string.
419 : */
420 1298 : basic_string()
421 : _GLIBCXX_NOEXCEPT_IF(is_nothrow_default_constructible<_Alloc>::value)
422 1298 : : _M_dataplus(_M_local_data())
423 1298 : { _M_set_length(0); }
424 :
425 : /**
426 : * @brief Construct an empty string using allocator @a a.
427 : */
428 : explicit
429 : basic_string(const _Alloc& __a) _GLIBCXX_NOEXCEPT
430 : : _M_dataplus(_M_local_data(), __a)
431 : { _M_set_length(0); }
432 :
433 : /**
434 : * @brief Construct string with copy of value of @a __str.
435 : * @param __str Source string.
436 : */
437 3991 : basic_string(const basic_string& __str)
438 : : _M_dataplus(_M_local_data(),
439 3991 : _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
440 3991 : { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
441 :
442 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
443 : // 2583. no way to supply an allocator for basic_string(str, pos)
444 : /**
445 : * @brief Construct string as copy of a substring.
446 : * @param __str Source string.
447 : * @param __pos Index of first character to copy from.
448 : * @param __a Allocator to use.
449 : */
450 : basic_string(const basic_string& __str, size_type __pos,
451 : const _Alloc& __a = _Alloc())
452 : : _M_dataplus(_M_local_data(), __a)
453 : {
454 : const _CharT* __start = __str._M_data()
455 : + __str._M_check(__pos, "basic_string::basic_string");
456 : _M_construct(__start, __start + __str._M_limit(__pos, npos));
457 : }
458 :
459 : /**
460 : * @brief Construct string as copy of a substring.
461 : * @param __str Source string.
462 : * @param __pos Index of first character to copy from.
463 : * @param __n Number of characters to copy.
464 : */
465 0 : basic_string(const basic_string& __str, size_type __pos,
466 : size_type __n)
467 0 : : _M_dataplus(_M_local_data())
468 : {
469 0 : const _CharT* __start = __str._M_data()
470 0 : + __str._M_check(__pos, "basic_string::basic_string");
471 0 : _M_construct(__start, __start + __str._M_limit(__pos, __n));
472 0 : }
473 :
474 : /**
475 : * @brief Construct string as copy of a substring.
476 : * @param __str Source string.
477 : * @param __pos Index of first character to copy from.
478 : * @param __n Number of characters to copy.
479 : * @param __a Allocator to use.
480 : */
481 : basic_string(const basic_string& __str, size_type __pos,
482 : size_type __n, const _Alloc& __a)
483 : : _M_dataplus(_M_local_data(), __a)
484 : {
485 : const _CharT* __start
486 : = __str._M_data() + __str._M_check(__pos, "string::string");
487 : _M_construct(__start, __start + __str._M_limit(__pos, __n));
488 : }
489 :
490 : /**
491 : * @brief Construct string initialized by a character %array.
492 : * @param __s Source character %array.
493 : * @param __n Number of characters to copy.
494 : * @param __a Allocator to use (default is default allocator).
495 : *
496 : * NB: @a __s must have at least @a __n characters, '\\0'
497 : * has no special meaning.
498 : */
499 : basic_string(const _CharT* __s, size_type __n,
500 : const _Alloc& __a = _Alloc())
501 : : _M_dataplus(_M_local_data(), __a)
502 : { _M_construct(__s, __s + __n); }
503 :
504 : /**
505 : * @brief Construct string as copy of a C string.
506 : * @param __s Source C string.
507 : * @param __a Allocator to use (default is default allocator).
508 : */
509 : #if __cpp_deduction_guides && ! defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
510 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
511 : // 3076. basic_string CTAD ambiguity
512 : template<typename = _RequireAllocator<_Alloc>>
513 : #endif
514 1013117 : basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
515 1013117 : : _M_dataplus(_M_local_data(), __a)
516 1013114 : { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); }
517 :
518 : /**
519 : * @brief Construct string as multiple characters.
520 : * @param __n Number of characters.
521 : * @param __c Character to use.
522 : * @param __a Allocator to use (default is default allocator).
523 : */
524 : #if __cpp_deduction_guides && ! defined _GLIBCXX_DEFINING_STRING_INSTANTIATIONS
525 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
526 : // 3076. basic_string CTAD ambiguity
527 : template<typename = _RequireAllocator<_Alloc>>
528 : #endif
529 : basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
530 : : _M_dataplus(_M_local_data(), __a)
531 : { _M_construct(__n, __c); }
532 :
533 : #if __cplusplus >= 201103L
534 : /**
535 : * @brief Move construct string.
536 : * @param __str Source string.
537 : *
538 : * The newly-created string contains the exact contents of @a __str.
539 : * @a __str is a valid, but unspecified string.
540 : **/
541 3011 : basic_string(basic_string&& __str) noexcept
542 3011 : : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
543 : {
544 3011 : if (__str._M_is_local())
545 : {
546 2327 : traits_type::copy(_M_local_buf, __str._M_local_buf,
547 : _S_local_capacity + 1);
548 : }
549 : else
550 : {
551 684 : _M_data(__str._M_data());
552 684 : _M_capacity(__str._M_allocated_capacity);
553 : }
554 :
555 : // Must use _M_length() here not _M_set_length() because
556 : // basic_stringbuf relies on writing into unallocated capacity so
557 : // we mess up the contents if we put a '\0' in the string.
558 3011 : _M_length(__str.length());
559 3011 : __str._M_data(__str._M_local_data());
560 3011 : __str._M_set_length(0);
561 3011 : }
562 :
563 : /**
564 : * @brief Construct string from an initializer %list.
565 : * @param __l std::initializer_list of characters.
566 : * @param __a Allocator to use (default is default allocator).
567 : */
568 : basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
569 : : _M_dataplus(_M_local_data(), __a)
570 : { _M_construct(__l.begin(), __l.end()); }
571 :
572 : basic_string(const basic_string& __str, const _Alloc& __a)
573 : : _M_dataplus(_M_local_data(), __a)
574 : { _M_construct(__str.begin(), __str.end()); }
575 :
576 : basic_string(basic_string&& __str, const _Alloc& __a)
577 : noexcept(_Alloc_traits::_S_always_equal())
578 : : _M_dataplus(_M_local_data(), __a)
579 : {
580 : if (__str._M_is_local())
581 : {
582 : traits_type::copy(_M_local_buf, __str._M_local_buf,
583 : _S_local_capacity + 1);
584 : _M_length(__str.length());
585 : __str._M_set_length(0);
586 : }
587 : else if (_Alloc_traits::_S_always_equal()
588 : || __str.get_allocator() == __a)
589 : {
590 : _M_data(__str._M_data());
591 : _M_length(__str.length());
592 : _M_capacity(__str._M_allocated_capacity);
593 : __str._M_data(__str._M_local_buf);
594 : __str._M_set_length(0);
595 : }
596 : else
597 : _M_construct(__str.begin(), __str.end());
598 : }
599 :
600 : #endif // C++11
601 :
602 : /**
603 : * @brief Construct string as copy of a range.
604 : * @param __beg Start of range.
605 : * @param __end End of range.
606 : * @param __a Allocator to use (default is default allocator).
607 : */
608 : #if __cplusplus >= 201103L
609 : template<typename _InputIterator,
610 : typename = std::_RequireInputIter<_InputIterator>>
611 : #else
612 : template<typename _InputIterator>
613 : #endif
614 639 : basic_string(_InputIterator __beg, _InputIterator __end,
615 : const _Alloc& __a = _Alloc())
616 639 : : _M_dataplus(_M_local_data(), __a)
617 639 : { _M_construct(__beg, __end); }
618 :
619 : #if __cplusplus > 201402L
620 : /**
621 : * @brief Construct string from a substring of a string_view.
622 : * @param __t Source object convertible to string view.
623 : * @param __pos The index of the first character to copy from __t.
624 : * @param __n The number of characters to copy from __t.
625 : * @param __a Allocator to use.
626 : */
627 : template<typename _Tp, typename = _If_sv<_Tp, void>>
628 : basic_string(const _Tp& __t, size_type __pos, size_type __n,
629 : const _Alloc& __a = _Alloc())
630 : : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }
631 :
632 : /**
633 : * @brief Construct string from a string_view.
634 : * @param __t Source object convertible to string view.
635 : * @param __a Allocator to use (default is default allocator).
636 : */
637 : template<typename _Tp, typename = _If_sv<_Tp, void>>
638 : explicit
639 : basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
640 : : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }
641 :
642 : /**
643 : * @brief Only internally used: Construct string from a string view
644 : * wrapper.
645 : * @param __svw string view wrapper.
646 : * @param __a Allocator to use.
647 : */
648 : explicit
649 : basic_string(__sv_wrapper __svw, const _Alloc& __a)
650 : : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }
651 : #endif // C++17
652 :
653 : /**
654 : * @brief Destroy the string instance.
655 : */
656 1022185 : ~basic_string()
657 1022185 : { _M_dispose(); }
658 :
659 : /**
660 : * @brief Assign the value of @a str to this string.
661 : * @param __str Source string.
662 : */
663 : basic_string&
664 1757 : operator=(const basic_string& __str)
665 : {
666 : #if __cplusplus >= 201103L
667 1757 : if (_Alloc_traits::_S_propagate_on_copy_assign())
668 : {
669 0 : if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
670 0 : && _M_get_allocator() != __str._M_get_allocator())
671 : {
672 : // Propagating allocator cannot free existing storage so must
673 : // deallocate it before replacing current allocator.
674 0 : if (__str.size() <= _S_local_capacity)
675 : {
676 0 : _M_destroy(_M_allocated_capacity);
677 0 : _M_data(_M_local_data());
678 0 : _M_set_length(0);
679 : }
680 : else
681 : {
682 0 : const auto __len = __str.size();
683 0 : auto __alloc = __str._M_get_allocator();
684 : // If this allocation throws there are no effects:
685 0 : auto __ptr = _Alloc_traits::allocate(__alloc, __len + 1);
686 0 : _M_destroy(_M_allocated_capacity);
687 0 : _M_data(__ptr);
688 0 : _M_capacity(__len);
689 0 : _M_set_length(__len);
690 : }
691 : }
692 0 : std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
693 : }
694 : #endif
695 1757 : return this->assign(__str);
696 : }
697 :
698 : /**
699 : * @brief Copy contents of @a s into this string.
700 : * @param __s Source null-terminated string.
701 : */
702 : basic_string&
703 : operator=(const _CharT* __s)
704 : { return this->assign(__s); }
705 :
706 : /**
707 : * @brief Set value to string of length 1.
708 : * @param __c Source character.
709 : *
710 : * Assigning to a character makes this string length 1 and
711 : * (*this)[0] == @a c.
712 : */
713 : basic_string&
714 : operator=(_CharT __c)
715 : {
716 : this->assign(1, __c);
717 : return *this;
718 : }
719 :
720 : #if __cplusplus >= 201103L
721 : /**
722 : * @brief Move assign the value of @a str to this string.
723 : * @param __str Source string.
724 : *
725 : * The contents of @a str are moved into this string (without copying).
726 : * @a str is a valid, but unspecified string.
727 : **/
728 : // PR 58265, this should be noexcept.
729 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
730 : // 2063. Contradictory requirements for string move assignment
731 : basic_string&
732 180 : operator=(basic_string&& __str)
733 : noexcept(_Alloc_traits::_S_nothrow_move())
734 : {
735 180 : if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
736 0 : && !_Alloc_traits::_S_always_equal()
737 180 : && _M_get_allocator() != __str._M_get_allocator())
738 : {
739 : // Destroy existing storage before replacing allocator.
740 0 : _M_destroy(_M_allocated_capacity);
741 0 : _M_data(_M_local_data());
742 0 : _M_set_length(0);
743 : }
744 : // Replace allocator if POCMA is true.
745 180 : std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
746 :
747 180 : if (__str._M_is_local())
748 : {
749 : // We've always got room for a short string, just copy it.
750 97 : if (__str.size())
751 97 : this->_S_copy(_M_data(), __str._M_data(), __str.size());
752 97 : _M_set_length(__str.size());
753 : }
754 83 : else if (_Alloc_traits::_S_propagate_on_move_assign()
755 0 : || _Alloc_traits::_S_always_equal()
756 83 : || _M_get_allocator() == __str._M_get_allocator())
757 : {
758 : // Just move the allocated pointer, our allocator can free it.
759 83 : pointer __data = nullptr;
760 : size_type __capacity;
761 83 : if (!_M_is_local())
762 : {
763 0 : if (_Alloc_traits::_S_always_equal())
764 : {
765 : // __str can reuse our existing storage.
766 0 : __data = _M_data();
767 0 : __capacity = _M_allocated_capacity;
768 : }
769 : else // __str can't use it, so free it.
770 0 : _M_destroy(_M_allocated_capacity);
771 : }
772 :
773 83 : _M_data(__str._M_data());
774 83 : _M_length(__str.length());
775 83 : _M_capacity(__str._M_allocated_capacity);
776 83 : if (__data)
777 : {
778 0 : __str._M_data(__data);
779 0 : __str._M_capacity(__capacity);
780 : }
781 : else
782 83 : __str._M_data(__str._M_local_buf);
783 : }
784 : else // Need to do a deep copy
785 0 : assign(__str);
786 180 : __str.clear();
787 180 : return *this;
788 : }
789 :
790 : /**
791 : * @brief Set value to string constructed from initializer %list.
792 : * @param __l std::initializer_list.
793 : */
794 : basic_string&
795 : operator=(initializer_list<_CharT> __l)
796 : {
797 : this->assign(__l.begin(), __l.size());
798 : return *this;
799 : }
800 : #endif // C++11
801 :
802 : #if __cplusplus > 201402L
803 : /**
804 : * @brief Set value to string constructed from a string_view.
805 : * @param __svt An object convertible to string_view.
806 : */
807 : template<typename _Tp>
808 : _If_sv<_Tp, basic_string&>
809 : operator=(const _Tp& __svt)
810 : { return this->assign(__svt); }
811 :
812 : /**
813 : * @brief Convert to a string_view.
814 : * @return A string_view.
815 : */
816 : operator __sv_type() const noexcept
817 : { return __sv_type(data(), size()); }
818 : #endif // C++17
819 :
820 : // Iterators:
821 : /**
822 : * Returns a read/write iterator that points to the first character in
823 : * the %string.
824 : */
825 : iterator
826 : begin() _GLIBCXX_NOEXCEPT
827 : { return iterator(_M_data()); }
828 :
829 : /**
830 : * Returns a read-only (constant) iterator that points to the first
831 : * character in the %string.
832 : */
833 : const_iterator
834 : begin() const _GLIBCXX_NOEXCEPT
835 : { return const_iterator(_M_data()); }
836 :
837 : /**
838 : * Returns a read/write iterator that points one past the last
839 : * character in the %string.
840 : */
841 : iterator
842 : end() _GLIBCXX_NOEXCEPT
843 : { return iterator(_M_data() + this->size()); }
844 :
845 : /**
846 : * Returns a read-only (constant) iterator that points one past the
847 : * last character in the %string.
848 : */
849 : const_iterator
850 : end() const _GLIBCXX_NOEXCEPT
851 : { return const_iterator(_M_data() + this->size()); }
852 :
853 : /**
854 : * Returns a read/write reverse iterator that points to the last
855 : * character in the %string. Iteration is done in reverse element
856 : * order.
857 : */
858 : reverse_iterator
859 : rbegin() _GLIBCXX_NOEXCEPT
860 : { return reverse_iterator(this->end()); }
861 :
862 : /**
863 : * Returns a read-only (constant) reverse iterator that points
864 : * to the last character in the %string. Iteration is done in
865 : * reverse element order.
866 : */
867 : const_reverse_iterator
868 : rbegin() const _GLIBCXX_NOEXCEPT
869 : { return const_reverse_iterator(this->end()); }
870 :
871 : /**
872 : * Returns a read/write reverse iterator that points to one before the
873 : * first character in the %string. Iteration is done in reverse
874 : * element order.
875 : */
876 : reverse_iterator
877 : rend() _GLIBCXX_NOEXCEPT
878 : { return reverse_iterator(this->begin()); }
879 :
880 : /**
881 : * Returns a read-only (constant) reverse iterator that points
882 : * to one before the first character in the %string. Iteration
883 : * is done in reverse element order.
884 : */
885 : const_reverse_iterator
886 : rend() const _GLIBCXX_NOEXCEPT
887 : { return const_reverse_iterator(this->begin()); }
888 :
889 : #if __cplusplus >= 201103L
890 : /**
891 : * Returns a read-only (constant) iterator that points to the first
892 : * character in the %string.
893 : */
894 : const_iterator
895 : cbegin() const noexcept
896 : { return const_iterator(this->_M_data()); }
897 :
898 : /**
899 : * Returns a read-only (constant) iterator that points one past the
900 : * last character in the %string.
901 : */
902 : const_iterator
903 : cend() const noexcept
904 : { return const_iterator(this->_M_data() + this->size()); }
905 :
906 : /**
907 : * Returns a read-only (constant) reverse iterator that points
908 : * to the last character in the %string. Iteration is done in
909 : * reverse element order.
910 : */
911 : const_reverse_iterator
912 : crbegin() const noexcept
913 : { return const_reverse_iterator(this->end()); }
914 :
915 : /**
916 : * Returns a read-only (constant) reverse iterator that points
917 : * to one before the first character in the %string. Iteration
918 : * is done in reverse element order.
919 : */
920 : const_reverse_iterator
921 : crend() const noexcept
922 : { return const_reverse_iterator(this->begin()); }
923 : #endif
924 :
925 : public:
926 : // Capacity:
927 : /// Returns the number of characters in the string, not including any
928 : /// null-termination.
929 : size_type
930 20315 : size() const _GLIBCXX_NOEXCEPT
931 20315 : { return _M_string_length; }
932 :
933 : /// Returns the number of characters in the string, not including any
934 : /// null-termination.
935 : size_type
936 13506 : length() const _GLIBCXX_NOEXCEPT
937 13506 : { return _M_string_length; }
938 :
939 : /// Returns the size() of the largest possible %string.
940 : size_type
941 997835 : max_size() const _GLIBCXX_NOEXCEPT
942 997835 : { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
943 :
944 : /**
945 : * @brief Resizes the %string to the specified number of characters.
946 : * @param __n Number of characters the %string should contain.
947 : * @param __c Character to fill any new elements.
948 : *
949 : * This function will %resize the %string to the specified
950 : * number of characters. If the number is smaller than the
951 : * %string's current size the %string is truncated, otherwise
952 : * the %string is extended and new elements are %set to @a __c.
953 : */
954 : void
955 : resize(size_type __n, _CharT __c);
956 :
957 : /**
958 : * @brief Resizes the %string to the specified number of characters.
959 : * @param __n Number of characters the %string should contain.
960 : *
961 : * This function will resize the %string to the specified length. If
962 : * the new size is smaller than the %string's current size the %string
963 : * is truncated, otherwise the %string is extended and new characters
964 : * are default-constructed. For basic types such as char, this means
965 : * setting them to 0.
966 : */
967 : void
968 : resize(size_type __n)
969 : { this->resize(__n, _CharT()); }
970 :
971 : #if __cplusplus >= 201103L
972 : /// A non-binding request to reduce capacity() to size().
973 : void
974 : shrink_to_fit() noexcept
975 : {
976 : #if __cpp_exceptions
977 : if (capacity() > size())
978 : {
979 : try
980 : { reserve(0); }
981 : catch(...)
982 : { }
983 : }
984 : #endif
985 : }
986 : #endif
987 :
988 : /**
989 : * Returns the total number of characters that the %string can hold
990 : * before needing to allocate more memory.
991 : */
992 : size_type
993 5838 : capacity() const _GLIBCXX_NOEXCEPT
994 : {
995 5838 : return _M_is_local() ? size_type(_S_local_capacity)
996 5838 : : _M_allocated_capacity;
997 : }
998 :
999 : /**
1000 : * @brief Attempt to preallocate enough memory for specified number of
1001 : * characters.
1002 : * @param __res_arg Number of characters required.
1003 : * @throw std::length_error If @a __res_arg exceeds @c max_size().
1004 : *
1005 : * This function attempts to reserve enough memory for the
1006 : * %string to hold the specified number of characters. If the
1007 : * number requested is more than max_size(), length_error is
1008 : * thrown.
1009 : *
1010 : * The advantage of this function is that if optimal code is a
1011 : * necessity and the user can determine the string length that will be
1012 : * required, the user can reserve the memory in %advance, and thus
1013 : * prevent a possible reallocation of memory and copying of %string
1014 : * data.
1015 : */
1016 : void
1017 : reserve(size_type __res_arg = 0);
1018 :
1019 : /**
1020 : * Erases the string, making it empty.
1021 : */
1022 : void
1023 180 : clear() _GLIBCXX_NOEXCEPT
1024 180 : { _M_set_length(0); }
1025 :
1026 : /**
1027 : * Returns true if the %string is empty. Equivalent to
1028 : * <code>*this == ""</code>.
1029 : */
1030 : bool
1031 : empty() const _GLIBCXX_NOEXCEPT
1032 : { return this->size() == 0; }
1033 :
1034 : // Element access:
1035 : /**
1036 : * @brief Subscript access to the data contained in the %string.
1037 : * @param __pos The index of the character to access.
1038 : * @return Read-only (constant) reference to the character.
1039 : *
1040 : * This operator allows for easy, array-style, data access.
1041 : * Note that data access with this operator is unchecked and
1042 : * out_of_range lookups are not defined. (For checked lookups
1043 : * see at().)
1044 : */
1045 : const_reference
1046 : operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
1047 : {
1048 : __glibcxx_assert(__pos <= size());
1049 : return _M_data()[__pos];
1050 : }
1051 :
1052 : /**
1053 : * @brief Subscript access to the data contained in the %string.
1054 : * @param __pos The index of the character to access.
1055 : * @return Read/write reference to the character.
1056 : *
1057 : * This operator allows for easy, array-style, data access.
1058 : * Note that data access with this operator is unchecked and
1059 : * out_of_range lookups are not defined. (For checked lookups
1060 : * see at().)
1061 : */
1062 : reference
1063 : operator[](size_type __pos)
1064 : {
1065 : // Allow pos == size() both in C++98 mode, as v3 extension,
1066 : // and in C++11 mode.
1067 : __glibcxx_assert(__pos <= size());
1068 : // In pedantic mode be strict in C++98 mode.
1069 : _GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L || __pos < size());
1070 : return _M_data()[__pos];
1071 : }
1072 :
1073 : /**
1074 : * @brief Provides access to the data contained in the %string.
1075 : * @param __n The index of the character to access.
1076 : * @return Read-only (const) reference to the character.
1077 : * @throw std::out_of_range If @a n is an invalid index.
1078 : *
1079 : * This function provides for safer data access. The parameter is
1080 : * first checked that it is in the range of the string. The function
1081 : * throws out_of_range if the check fails.
1082 : */
1083 : const_reference
1084 : at(size_type __n) const
1085 : {
1086 : if (__n >= this->size())
1087 : __throw_out_of_range_fmt(__N("basic_string::at: __n "
1088 : "(which is %zu) >= this->size() "
1089 : "(which is %zu)"),
1090 : __n, this->size());
1091 : return _M_data()[__n];
1092 : }
1093 :
1094 : /**
1095 : * @brief Provides access to the data contained in the %string.
1096 : * @param __n The index of the character to access.
1097 : * @return Read/write reference to the character.
1098 : * @throw std::out_of_range If @a n is an invalid index.
1099 : *
1100 : * This function provides for safer data access. The parameter is
1101 : * first checked that it is in the range of the string. The function
1102 : * throws out_of_range if the check fails.
1103 : */
1104 : reference
1105 599 : at(size_type __n)
1106 : {
1107 599 : if (__n >= size())
1108 0 : __throw_out_of_range_fmt(__N("basic_string::at: __n "
1109 : "(which is %zu) >= this->size() "
1110 : "(which is %zu)"),
1111 : __n, this->size());
1112 599 : return _M_data()[__n];
1113 : }
1114 :
1115 : #if __cplusplus >= 201103L
1116 : /**
1117 : * Returns a read/write reference to the data at the first
1118 : * element of the %string.
1119 : */
1120 : reference
1121 : front() noexcept
1122 : {
1123 : __glibcxx_assert(!empty());
1124 : return operator[](0);
1125 : }
1126 :
1127 : /**
1128 : * Returns a read-only (constant) reference to the data at the first
1129 : * element of the %string.
1130 : */
1131 : const_reference
1132 : front() const noexcept
1133 : {
1134 : __glibcxx_assert(!empty());
1135 : return operator[](0);
1136 : }
1137 :
1138 : /**
1139 : * Returns a read/write reference to the data at the last
1140 : * element of the %string.
1141 : */
1142 : reference
1143 : back() noexcept
1144 : {
1145 : __glibcxx_assert(!empty());
1146 : return operator[](this->size() - 1);
1147 : }
1148 :
1149 : /**
1150 : * Returns a read-only (constant) reference to the data at the
1151 : * last element of the %string.
1152 : */
1153 : const_reference
1154 : back() const noexcept
1155 : {
1156 : __glibcxx_assert(!empty());
1157 : return operator[](this->size() - 1);
1158 : }
1159 : #endif
1160 :
1161 : // Modifiers:
1162 : /**
1163 : * @brief Append a string to this string.
1164 : * @param __str The string to append.
1165 : * @return Reference to this string.
1166 : */
1167 : basic_string&
1168 : operator+=(const basic_string& __str)
1169 : { return this->append(__str); }
1170 :
1171 : /**
1172 : * @brief Append a C string.
1173 : * @param __s The C string to append.
1174 : * @return Reference to this string.
1175 : */
1176 : basic_string&
1177 : operator+=(const _CharT* __s)
1178 : { return this->append(__s); }
1179 :
1180 : /**
1181 : * @brief Append a character.
1182 : * @param __c The character to append.
1183 : * @return Reference to this string.
1184 : */
1185 : basic_string&
1186 : operator+=(_CharT __c)
1187 : {
1188 : this->push_back(__c);
1189 : return *this;
1190 : }
1191 :
1192 : #if __cplusplus >= 201103L
1193 : /**
1194 : * @brief Append an initializer_list of characters.
1195 : * @param __l The initializer_list of characters to be appended.
1196 : * @return Reference to this string.
1197 : */
1198 : basic_string&
1199 : operator+=(initializer_list<_CharT> __l)
1200 : { return this->append(__l.begin(), __l.size()); }
1201 : #endif // C++11
1202 :
1203 : #if __cplusplus > 201402L
1204 : /**
1205 : * @brief Append a string_view.
1206 : * @param __svt An object convertible to string_view to be appended.
1207 : * @return Reference to this string.
1208 : */
1209 : template<typename _Tp>
1210 : _If_sv<_Tp, basic_string&>
1211 : operator+=(const _Tp& __svt)
1212 : { return this->append(__svt); }
1213 : #endif // C++17
1214 :
1215 : /**
1216 : * @brief Append a string to this string.
1217 : * @param __str The string to append.
1218 : * @return Reference to this string.
1219 : */
1220 : basic_string&
1221 540 : append(const basic_string& __str)
1222 540 : { return _M_append(__str._M_data(), __str.size()); }
1223 :
1224 : /**
1225 : * @brief Append a substring.
1226 : * @param __str The string to append.
1227 : * @param __pos Index of the first character of str to append.
1228 : * @param __n The number of characters to append.
1229 : * @return Reference to this string.
1230 : * @throw std::out_of_range if @a __pos is not a valid index.
1231 : *
1232 : * This function appends @a __n characters from @a __str
1233 : * starting at @a __pos to this string. If @a __n is is larger
1234 : * than the number of available characters in @a __str, the
1235 : * remainder of @a __str is appended.
1236 : */
1237 : basic_string&
1238 : append(const basic_string& __str, size_type __pos, size_type __n = npos)
1239 : { return _M_append(__str._M_data()
1240 : + __str._M_check(__pos, "basic_string::append"),
1241 : __str._M_limit(__pos, __n)); }
1242 :
1243 : /**
1244 : * @brief Append a C substring.
1245 : * @param __s The C string to append.
1246 : * @param __n The number of characters to append.
1247 : * @return Reference to this string.
1248 : */
1249 : basic_string&
1250 0 : append(const _CharT* __s, size_type __n)
1251 : {
1252 : __glibcxx_requires_string_len(__s, __n);
1253 0 : _M_check_length(size_type(0), __n, "basic_string::append");
1254 0 : return _M_append(__s, __n);
1255 : }
1256 :
1257 : /**
1258 : * @brief Append a C string.
1259 : * @param __s The C string to append.
1260 : * @return Reference to this string.
1261 : */
1262 : basic_string&
1263 1159 : append(const _CharT* __s)
1264 : {
1265 : __glibcxx_requires_string(__s);
1266 1159 : const size_type __n = traits_type::length(__s);
1267 1159 : _M_check_length(size_type(0), __n, "basic_string::append");
1268 1159 : return _M_append(__s, __n);
1269 : }
1270 :
1271 : /**
1272 : * @brief Append multiple characters.
1273 : * @param __n The number of characters to append.
1274 : * @param __c The character to use.
1275 : * @return Reference to this string.
1276 : *
1277 : * Appends __n copies of __c to this string.
1278 : */
1279 : basic_string&
1280 : append(size_type __n, _CharT __c)
1281 : { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
1282 :
1283 : #if __cplusplus >= 201103L
1284 : /**
1285 : * @brief Append an initializer_list of characters.
1286 : * @param __l The initializer_list of characters to append.
1287 : * @return Reference to this string.
1288 : */
1289 : basic_string&
1290 : append(initializer_list<_CharT> __l)
1291 : { return this->append(__l.begin(), __l.size()); }
1292 : #endif // C++11
1293 :
1294 : /**
1295 : * @brief Append a range of characters.
1296 : * @param __first Iterator referencing the first character to append.
1297 : * @param __last Iterator marking the end of the range.
1298 : * @return Reference to this string.
1299 : *
1300 : * Appends characters in the range [__first,__last) to this string.
1301 : */
1302 : #if __cplusplus >= 201103L
1303 : template<class _InputIterator,
1304 : typename = std::_RequireInputIter<_InputIterator>>
1305 : #else
1306 : template<class _InputIterator>
1307 : #endif
1308 : basic_string&
1309 : append(_InputIterator __first, _InputIterator __last)
1310 : { return this->replace(end(), end(), __first, __last); }
1311 :
1312 : #if __cplusplus > 201402L
1313 : /**
1314 : * @brief Append a string_view.
1315 : * @param __svt An object convertible to string_view to be appended.
1316 : * @return Reference to this string.
1317 : */
1318 : template<typename _Tp>
1319 : _If_sv<_Tp, basic_string&>
1320 : append(const _Tp& __svt)
1321 : {
1322 : __sv_type __sv = __svt;
1323 : return this->append(__sv.data(), __sv.size());
1324 : }
1325 :
1326 : /**
1327 : * @brief Append a range of characters from a string_view.
1328 : * @param __svt An object convertible to string_view to be appended from.
1329 : * @param __pos The position in the string_view to append from.
1330 : * @param __n The number of characters to append from the string_view.
1331 : * @return Reference to this string.
1332 : */
1333 : template<typename _Tp>
1334 : _If_sv<_Tp, basic_string&>
1335 : append(const _Tp& __svt, size_type __pos, size_type __n = npos)
1336 : {
1337 : __sv_type __sv = __svt;
1338 : return _M_append(__sv.data()
1339 : + __sv._M_check(__pos, "basic_string::append"),
1340 : __sv._M_limit(__pos, __n));
1341 : }
1342 : #endif // C++17
1343 :
1344 : /**
1345 : * @brief Append a single character.
1346 : * @param __c Character to append.
1347 : */
1348 : void
1349 : push_back(_CharT __c)
1350 : {
1351 : const size_type __size = this->size();
1352 : if (__size + 1 > this->capacity())
1353 : this->_M_mutate(__size, size_type(0), 0, size_type(1));
1354 : traits_type::assign(this->_M_data()[__size], __c);
1355 : this->_M_set_length(__size + 1);
1356 : }
1357 :
1358 : /**
1359 : * @brief Set value to contents of another string.
1360 : * @param __str Source string to use.
1361 : * @return Reference to this string.
1362 : */
1363 : basic_string&
1364 1757 : assign(const basic_string& __str)
1365 : {
1366 1757 : this->_M_assign(__str);
1367 1757 : return *this;
1368 : }
1369 :
1370 : #if __cplusplus >= 201103L
1371 : /**
1372 : * @brief Set value to contents of another string.
1373 : * @param __str Source string to use.
1374 : * @return Reference to this string.
1375 : *
1376 : * This function sets this string to the exact contents of @a __str.
1377 : * @a __str is a valid, but unspecified string.
1378 : */
1379 : basic_string&
1380 : assign(basic_string&& __str)
1381 : noexcept(_Alloc_traits::_S_nothrow_move())
1382 : {
1383 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1384 : // 2063. Contradictory requirements for string move assignment
1385 : return *this = std::move(__str);
1386 : }
1387 : #endif // C++11
1388 :
1389 : /**
1390 : * @brief Set value to a substring of a string.
1391 : * @param __str The string to use.
1392 : * @param __pos Index of the first character of str.
1393 : * @param __n Number of characters to use.
1394 : * @return Reference to this string.
1395 : * @throw std::out_of_range if @a pos is not a valid index.
1396 : *
1397 : * This function sets this string to the substring of @a __str
1398 : * consisting of @a __n characters at @a __pos. If @a __n is
1399 : * is larger than the number of available characters in @a
1400 : * __str, the remainder of @a __str is used.
1401 : */
1402 : basic_string&
1403 : assign(const basic_string& __str, size_type __pos, size_type __n = npos)
1404 : { return _M_replace(size_type(0), this->size(), __str._M_data()
1405 : + __str._M_check(__pos, "basic_string::assign"),
1406 : __str._M_limit(__pos, __n)); }
1407 :
1408 : /**
1409 : * @brief Set value to a C substring.
1410 : * @param __s The C string to use.
1411 : * @param __n Number of characters to use.
1412 : * @return Reference to this string.
1413 : *
1414 : * This function sets the value of this string to the first @a __n
1415 : * characters of @a __s. If @a __n is is larger than the number of
1416 : * available characters in @a __s, the remainder of @a __s is used.
1417 : */
1418 : basic_string&
1419 : assign(const _CharT* __s, size_type __n)
1420 : {
1421 : __glibcxx_requires_string_len(__s, __n);
1422 : return _M_replace(size_type(0), this->size(), __s, __n);
1423 : }
1424 :
1425 : /**
1426 : * @brief Set value to contents of a C string.
1427 : * @param __s The C string to use.
1428 : * @return Reference to this string.
1429 : *
1430 : * This function sets the value of this string to the value of @a __s.
1431 : * The data is copied, so there is no dependence on @a __s once the
1432 : * function returns.
1433 : */
1434 : basic_string&
1435 : assign(const _CharT* __s)
1436 : {
1437 : __glibcxx_requires_string(__s);
1438 : return _M_replace(size_type(0), this->size(), __s,
1439 : traits_type::length(__s));
1440 : }
1441 :
1442 : /**
1443 : * @brief Set value to multiple characters.
1444 : * @param __n Length of the resulting string.
1445 : * @param __c The character to use.
1446 : * @return Reference to this string.
1447 : *
1448 : * This function sets the value of this string to @a __n copies of
1449 : * character @a __c.
1450 : */
1451 : basic_string&
1452 : assign(size_type __n, _CharT __c)
1453 : { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
1454 :
1455 : /**
1456 : * @brief Set value to a range of characters.
1457 : * @param __first Iterator referencing the first character to append.
1458 : * @param __last Iterator marking the end of the range.
1459 : * @return Reference to this string.
1460 : *
1461 : * Sets value of string to characters in the range [__first,__last).
1462 : */
1463 : #if __cplusplus >= 201103L
1464 : template<class _InputIterator,
1465 : typename = std::_RequireInputIter<_InputIterator>>
1466 : #else
1467 : template<class _InputIterator>
1468 : #endif
1469 : basic_string&
1470 : assign(_InputIterator __first, _InputIterator __last)
1471 : { return this->replace(begin(), end(), __first, __last); }
1472 :
1473 : #if __cplusplus >= 201103L
1474 : /**
1475 : * @brief Set value to an initializer_list of characters.
1476 : * @param __l The initializer_list of characters to assign.
1477 : * @return Reference to this string.
1478 : */
1479 : basic_string&
1480 : assign(initializer_list<_CharT> __l)
1481 : { return this->assign(__l.begin(), __l.size()); }
1482 : #endif // C++11
1483 :
1484 : #if __cplusplus > 201402L
1485 : /**
1486 : * @brief Set value from a string_view.
1487 : * @param __svt The source object convertible to string_view.
1488 : * @return Reference to this string.
1489 : */
1490 : template<typename _Tp>
1491 : _If_sv<_Tp, basic_string&>
1492 : assign(const _Tp& __svt)
1493 : {
1494 : __sv_type __sv = __svt;
1495 : return this->assign(__sv.data(), __sv.size());
1496 : }
1497 :
1498 : /**
1499 : * @brief Set value from a range of characters in a string_view.
1500 : * @param __svt The source object convertible to string_view.
1501 : * @param __pos The position in the string_view to assign from.
1502 : * @param __n The number of characters to assign.
1503 : * @return Reference to this string.
1504 : */
1505 : template<typename _Tp>
1506 : _If_sv<_Tp, basic_string&>
1507 : assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
1508 : {
1509 : __sv_type __sv = __svt;
1510 : return _M_replace(size_type(0), this->size(), __sv.data()
1511 : + __sv._M_check(__pos, "basic_string::assign"),
1512 : __sv._M_limit(__pos, __n));
1513 : }
1514 : #endif // C++17
1515 :
1516 : #if __cplusplus >= 201103L
1517 : /**
1518 : * @brief Insert multiple characters.
1519 : * @param __p Const_iterator referencing location in string to
1520 : * insert at.
1521 : * @param __n Number of characters to insert
1522 : * @param __c The character to insert.
1523 : * @return Iterator referencing the first inserted char.
1524 : * @throw std::length_error If new length exceeds @c max_size().
1525 : *
1526 : * Inserts @a __n copies of character @a __c starting at the
1527 : * position referenced by iterator @a __p. If adding
1528 : * characters causes the length to exceed max_size(),
1529 : * length_error is thrown. The value of the string doesn't
1530 : * change if an error is thrown.
1531 : */
1532 : iterator
1533 : insert(const_iterator __p, size_type __n, _CharT __c)
1534 : {
1535 : _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1536 : const size_type __pos = __p - begin();
1537 : this->replace(__p, __p, __n, __c);
1538 : return iterator(this->_M_data() + __pos);
1539 : }
1540 : #else
1541 : /**
1542 : * @brief Insert multiple characters.
1543 : * @param __p Iterator referencing location in string to insert at.
1544 : * @param __n Number of characters to insert
1545 : * @param __c The character to insert.
1546 : * @throw std::length_error If new length exceeds @c max_size().
1547 : *
1548 : * Inserts @a __n copies of character @a __c starting at the
1549 : * position referenced by iterator @a __p. If adding
1550 : * characters causes the length to exceed max_size(),
1551 : * length_error is thrown. The value of the string doesn't
1552 : * change if an error is thrown.
1553 : */
1554 : void
1555 : insert(iterator __p, size_type __n, _CharT __c)
1556 : { this->replace(__p, __p, __n, __c); }
1557 : #endif
1558 :
1559 : #if __cplusplus >= 201103L
1560 : /**
1561 : * @brief Insert a range of characters.
1562 : * @param __p Const_iterator referencing location in string to
1563 : * insert at.
1564 : * @param __beg Start of range.
1565 : * @param __end End of range.
1566 : * @return Iterator referencing the first inserted char.
1567 : * @throw std::length_error If new length exceeds @c max_size().
1568 : *
1569 : * Inserts characters in range [beg,end). If adding characters
1570 : * causes the length to exceed max_size(), length_error is
1571 : * thrown. The value of the string doesn't change if an error
1572 : * is thrown.
1573 : */
1574 : template<class _InputIterator,
1575 : typename = std::_RequireInputIter<_InputIterator>>
1576 : iterator
1577 : insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
1578 : {
1579 : _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1580 : const size_type __pos = __p - begin();
1581 : this->replace(__p, __p, __beg, __end);
1582 : return iterator(this->_M_data() + __pos);
1583 : }
1584 : #else
1585 : /**
1586 : * @brief Insert a range of characters.
1587 : * @param __p Iterator referencing location in string to insert at.
1588 : * @param __beg Start of range.
1589 : * @param __end End of range.
1590 : * @throw std::length_error If new length exceeds @c max_size().
1591 : *
1592 : * Inserts characters in range [__beg,__end). If adding
1593 : * characters causes the length to exceed max_size(),
1594 : * length_error is thrown. The value of the string doesn't
1595 : * change if an error is thrown.
1596 : */
1597 : template<class _InputIterator>
1598 : void
1599 : insert(iterator __p, _InputIterator __beg, _InputIterator __end)
1600 : { this->replace(__p, __p, __beg, __end); }
1601 : #endif
1602 :
1603 : #if __cplusplus >= 201103L
1604 : /**
1605 : * @brief Insert an initializer_list of characters.
1606 : * @param __p Iterator referencing location in string to insert at.
1607 : * @param __l The initializer_list of characters to insert.
1608 : * @throw std::length_error If new length exceeds @c max_size().
1609 : */
1610 : void
1611 : insert(iterator __p, initializer_list<_CharT> __l)
1612 : {
1613 : _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1614 : this->insert(__p - begin(), __l.begin(), __l.size());
1615 : }
1616 : #endif // C++11
1617 :
1618 : /**
1619 : * @brief Insert value of a string.
1620 : * @param __pos1 Iterator referencing location in string to insert at.
1621 : * @param __str The string to insert.
1622 : * @return Reference to this string.
1623 : * @throw std::length_error If new length exceeds @c max_size().
1624 : *
1625 : * Inserts value of @a __str starting at @a __pos1. If adding
1626 : * characters causes the length to exceed max_size(),
1627 : * length_error is thrown. The value of the string doesn't
1628 : * change if an error is thrown.
1629 : */
1630 : basic_string&
1631 0 : insert(size_type __pos1, const basic_string& __str)
1632 : { return this->replace(__pos1, size_type(0),
1633 0 : __str._M_data(), __str.size()); }
1634 :
1635 : /**
1636 : * @brief Insert a substring.
1637 : * @param __pos1 Iterator referencing location in string to insert at.
1638 : * @param __str The string to insert.
1639 : * @param __pos2 Start of characters in str to insert.
1640 : * @param __n Number of characters to insert.
1641 : * @return Reference to this string.
1642 : * @throw std::length_error If new length exceeds @c max_size().
1643 : * @throw std::out_of_range If @a pos1 > size() or
1644 : * @a __pos2 > @a str.size().
1645 : *
1646 : * Starting at @a pos1, insert @a __n character of @a __str
1647 : * beginning with @a __pos2. If adding characters causes the
1648 : * length to exceed max_size(), length_error is thrown. If @a
1649 : * __pos1 is beyond the end of this string or @a __pos2 is
1650 : * beyond the end of @a __str, out_of_range is thrown. The
1651 : * value of the string doesn't change if an error is thrown.
1652 : */
1653 : basic_string&
1654 : insert(size_type __pos1, const basic_string& __str,
1655 : size_type __pos2, size_type __n = npos)
1656 : { return this->replace(__pos1, size_type(0), __str._M_data()
1657 : + __str._M_check(__pos2, "basic_string::insert"),
1658 : __str._M_limit(__pos2, __n)); }
1659 :
1660 : /**
1661 : * @brief Insert a C substring.
1662 : * @param __pos Iterator referencing location in string to insert at.
1663 : * @param __s The C string to insert.
1664 : * @param __n The number of characters to insert.
1665 : * @return Reference to this string.
1666 : * @throw std::length_error If new length exceeds @c max_size().
1667 : * @throw std::out_of_range If @a __pos is beyond the end of this
1668 : * string.
1669 : *
1670 : * Inserts the first @a __n characters of @a __s starting at @a
1671 : * __pos. If adding characters causes the length to exceed
1672 : * max_size(), length_error is thrown. If @a __pos is beyond
1673 : * end(), out_of_range is thrown. The value of the string
1674 : * doesn't change if an error is thrown.
1675 : */
1676 : basic_string&
1677 : insert(size_type __pos, const _CharT* __s, size_type __n)
1678 : { return this->replace(__pos, size_type(0), __s, __n); }
1679 :
1680 : /**
1681 : * @brief Insert a C string.
1682 : * @param __pos Iterator referencing location in string to insert at.
1683 : * @param __s The C string to insert.
1684 : * @return Reference to this string.
1685 : * @throw std::length_error If new length exceeds @c max_size().
1686 : * @throw std::out_of_range If @a pos is beyond the end of this
1687 : * string.
1688 : *
1689 : * Inserts the first @a n characters of @a __s starting at @a __pos. If
1690 : * adding characters causes the length to exceed max_size(),
1691 : * length_error is thrown. If @a __pos is beyond end(), out_of_range is
1692 : * thrown. The value of the string doesn't change if an error is
1693 : * thrown.
1694 : */
1695 : basic_string&
1696 99 : insert(size_type __pos, const _CharT* __s)
1697 : {
1698 : __glibcxx_requires_string(__s);
1699 : return this->replace(__pos, size_type(0), __s,
1700 99 : traits_type::length(__s));
1701 : }
1702 :
1703 : /**
1704 : * @brief Insert multiple characters.
1705 : * @param __pos Index in string to insert at.
1706 : * @param __n Number of characters to insert
1707 : * @param __c The character to insert.
1708 : * @return Reference to this string.
1709 : * @throw std::length_error If new length exceeds @c max_size().
1710 : * @throw std::out_of_range If @a __pos is beyond the end of this
1711 : * string.
1712 : *
1713 : * Inserts @a __n copies of character @a __c starting at index
1714 : * @a __pos. If adding characters causes the length to exceed
1715 : * max_size(), length_error is thrown. If @a __pos > length(),
1716 : * out_of_range is thrown. The value of the string doesn't
1717 : * change if an error is thrown.
1718 : */
1719 : basic_string&
1720 : insert(size_type __pos, size_type __n, _CharT __c)
1721 : { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
1722 : size_type(0), __n, __c); }
1723 :
1724 : /**
1725 : * @brief Insert one character.
1726 : * @param __p Iterator referencing position in string to insert at.
1727 : * @param __c The character to insert.
1728 : * @return Iterator referencing newly inserted char.
1729 : * @throw std::length_error If new length exceeds @c max_size().
1730 : *
1731 : * Inserts character @a __c at position referenced by @a __p.
1732 : * If adding character causes the length to exceed max_size(),
1733 : * length_error is thrown. If @a __p is beyond end of string,
1734 : * out_of_range is thrown. The value of the string doesn't
1735 : * change if an error is thrown.
1736 : */
1737 : iterator
1738 : insert(__const_iterator __p, _CharT __c)
1739 : {
1740 : _GLIBCXX_DEBUG_PEDASSERT(__p >= begin() && __p <= end());
1741 : const size_type __pos = __p - begin();
1742 : _M_replace_aux(__pos, size_type(0), size_type(1), __c);
1743 : return iterator(_M_data() + __pos);
1744 : }
1745 :
1746 : #if __cplusplus > 201402L
1747 : /**
1748 : * @brief Insert a string_view.
1749 : * @param __pos Iterator referencing position in string to insert at.
1750 : * @param __svt The object convertible to string_view to insert.
1751 : * @return Reference to this string.
1752 : */
1753 : template<typename _Tp>
1754 : _If_sv<_Tp, basic_string&>
1755 : insert(size_type __pos, const _Tp& __svt)
1756 : {
1757 : __sv_type __sv = __svt;
1758 : return this->insert(__pos, __sv.data(), __sv.size());
1759 : }
1760 :
1761 : /**
1762 : * @brief Insert a string_view.
1763 : * @param __pos Iterator referencing position in string to insert at.
1764 : * @param __svt The object convertible to string_view to insert from.
1765 : * @param __pos Iterator referencing position in string_view to insert
1766 : * from.
1767 : * @param __n The number of characters to insert.
1768 : * @return Reference to this string.
1769 : */
1770 : template<typename _Tp>
1771 : _If_sv<_Tp, basic_string&>
1772 : insert(size_type __pos1, const _Tp& __svt,
1773 : size_type __pos2, size_type __n = npos)
1774 : {
1775 : __sv_type __sv = __svt;
1776 : return this->replace(__pos1, size_type(0), __sv.data()
1777 : + __sv._M_check(__pos2, "basic_string::insert"),
1778 : __sv._M_limit(__pos2, __n));
1779 : }
1780 : #endif // C++17
1781 :
1782 : /**
1783 : * @brief Remove characters.
1784 : * @param __pos Index of first character to remove (default 0).
1785 : * @param __n Number of characters to remove (default remainder).
1786 : * @return Reference to this string.
1787 : * @throw std::out_of_range If @a pos is beyond the end of this
1788 : * string.
1789 : *
1790 : * Removes @a __n characters from this string starting at @a
1791 : * __pos. The length of the string is reduced by @a __n. If
1792 : * there are < @a __n characters to remove, the remainder of
1793 : * the string is truncated. If @a __p is beyond end of string,
1794 : * out_of_range is thrown. The value of the string doesn't
1795 : * change if an error is thrown.
1796 : */
1797 : basic_string&
1798 : erase(size_type __pos = 0, size_type __n = npos)
1799 : {
1800 : _M_check(__pos, "basic_string::erase");
1801 : if (__n == npos)
1802 : this->_M_set_length(__pos);
1803 : else if (__n != 0)
1804 : this->_M_erase(__pos, _M_limit(__pos, __n));
1805 : return *this;
1806 : }
1807 :
1808 : /**
1809 : * @brief Remove one character.
1810 : * @param __position Iterator referencing the character to remove.
1811 : * @return iterator referencing same location after removal.
1812 : *
1813 : * Removes the character at @a __position from this string. The value
1814 : * of the string doesn't change if an error is thrown.
1815 : */
1816 : iterator
1817 : erase(__const_iterator __position)
1818 : {
1819 : _GLIBCXX_DEBUG_PEDASSERT(__position >= begin()
1820 : && __position < end());
1821 : const size_type __pos = __position - begin();
1822 : this->_M_erase(__pos, size_type(1));
1823 : return iterator(_M_data() + __pos);
1824 : }
1825 :
1826 : /**
1827 : * @brief Remove a range of characters.
1828 : * @param __first Iterator referencing the first character to remove.
1829 : * @param __last Iterator referencing the end of the range.
1830 : * @return Iterator referencing location of first after removal.
1831 : *
1832 : * Removes the characters in the range [first,last) from this string.
1833 : * The value of the string doesn't change if an error is thrown.
1834 : */
1835 : iterator
1836 : erase(__const_iterator __first, __const_iterator __last)
1837 : {
1838 : _GLIBCXX_DEBUG_PEDASSERT(__first >= begin() && __first <= __last
1839 : && __last <= end());
1840 : const size_type __pos = __first - begin();
1841 : if (__last == end())
1842 : this->_M_set_length(__pos);
1843 : else
1844 : this->_M_erase(__pos, __last - __first);
1845 : return iterator(this->_M_data() + __pos);
1846 : }
1847 :
1848 : #if __cplusplus >= 201103L
1849 : /**
1850 : * @brief Remove the last character.
1851 : *
1852 : * The string must be non-empty.
1853 : */
1854 : void
1855 : pop_back() noexcept
1856 : {
1857 : __glibcxx_assert(!empty());
1858 : _M_erase(size() - 1, 1);
1859 : }
1860 : #endif // C++11
1861 :
1862 : /**
1863 : * @brief Replace characters with value from another string.
1864 : * @param __pos Index of first character to replace.
1865 : * @param __n Number of characters to be replaced.
1866 : * @param __str String to insert.
1867 : * @return Reference to this string.
1868 : * @throw std::out_of_range If @a pos is beyond the end of this
1869 : * string.
1870 : * @throw std::length_error If new length exceeds @c max_size().
1871 : *
1872 : * Removes the characters in the range [__pos,__pos+__n) from
1873 : * this string. In place, the value of @a __str is inserted.
1874 : * If @a __pos is beyond end of string, out_of_range is thrown.
1875 : * If the length of the result exceeds max_size(), length_error
1876 : * is thrown. The value of the string doesn't change if an
1877 : * error is thrown.
1878 : */
1879 : basic_string&
1880 539 : replace(size_type __pos, size_type __n, const basic_string& __str)
1881 539 : { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
1882 :
1883 : /**
1884 : * @brief Replace characters with value from another string.
1885 : * @param __pos1 Index of first character to replace.
1886 : * @param __n1 Number of characters to be replaced.
1887 : * @param __str String to insert.
1888 : * @param __pos2 Index of first character of str to use.
1889 : * @param __n2 Number of characters from str to use.
1890 : * @return Reference to this string.
1891 : * @throw std::out_of_range If @a __pos1 > size() or @a __pos2 >
1892 : * __str.size().
1893 : * @throw std::length_error If new length exceeds @c max_size().
1894 : *
1895 : * Removes the characters in the range [__pos1,__pos1 + n) from this
1896 : * string. In place, the value of @a __str is inserted. If @a __pos is
1897 : * beyond end of string, out_of_range is thrown. If the length of the
1898 : * result exceeds max_size(), length_error is thrown. The value of the
1899 : * string doesn't change if an error is thrown.
1900 : */
1901 : basic_string&
1902 : replace(size_type __pos1, size_type __n1, const basic_string& __str,
1903 : size_type __pos2, size_type __n2 = npos)
1904 : { return this->replace(__pos1, __n1, __str._M_data()
1905 : + __str._M_check(__pos2, "basic_string::replace"),
1906 : __str._M_limit(__pos2, __n2)); }
1907 :
1908 : /**
1909 : * @brief Replace characters with value of a C substring.
1910 : * @param __pos Index of first character to replace.
1911 : * @param __n1 Number of characters to be replaced.
1912 : * @param __s C string to insert.
1913 : * @param __n2 Number of characters from @a s to use.
1914 : * @return Reference to this string.
1915 : * @throw std::out_of_range If @a pos1 > size().
1916 : * @throw std::length_error If new length exceeds @c max_size().
1917 : *
1918 : * Removes the characters in the range [__pos,__pos + __n1)
1919 : * from this string. In place, the first @a __n2 characters of
1920 : * @a __s are inserted, or all of @a __s if @a __n2 is too large. If
1921 : * @a __pos is beyond end of string, out_of_range is thrown. If
1922 : * the length of result exceeds max_size(), length_error is
1923 : * thrown. The value of the string doesn't change if an error
1924 : * is thrown.
1925 : */
1926 : basic_string&
1927 638 : replace(size_type __pos, size_type __n1, const _CharT* __s,
1928 : size_type __n2)
1929 : {
1930 : __glibcxx_requires_string_len(__s, __n2);
1931 : return _M_replace(_M_check(__pos, "basic_string::replace"),
1932 638 : _M_limit(__pos, __n1), __s, __n2);
1933 : }
1934 :
1935 : /**
1936 : * @brief Replace characters with value of a C string.
1937 : * @param __pos Index of first character to replace.
1938 : * @param __n1 Number of characters to be replaced.
1939 : * @param __s C string to insert.
1940 : * @return Reference to this string.
1941 : * @throw std::out_of_range If @a pos > size().
1942 : * @throw std::length_error If new length exceeds @c max_size().
1943 : *
1944 : * Removes the characters in the range [__pos,__pos + __n1)
1945 : * from this string. In place, the characters of @a __s are
1946 : * inserted. If @a __pos is beyond end of string, out_of_range
1947 : * is thrown. If the length of result exceeds max_size(),
1948 : * length_error is thrown. The value of the string doesn't
1949 : * change if an error is thrown.
1950 : */
1951 : basic_string&
1952 : replace(size_type __pos, size_type __n1, const _CharT* __s)
1953 : {
1954 : __glibcxx_requires_string(__s);
1955 : return this->replace(__pos, __n1, __s, traits_type::length(__s));
1956 : }
1957 :
1958 : /**
1959 : * @brief Replace characters with multiple characters.
1960 : * @param __pos Index of first character to replace.
1961 : * @param __n1 Number of characters to be replaced.
1962 : * @param __n2 Number of characters to insert.
1963 : * @param __c Character to insert.
1964 : * @return Reference to this string.
1965 : * @throw std::out_of_range If @a __pos > size().
1966 : * @throw std::length_error If new length exceeds @c max_size().
1967 : *
1968 : * Removes the characters in the range [pos,pos + n1) from this
1969 : * string. In place, @a __n2 copies of @a __c are inserted.
1970 : * If @a __pos is beyond end of string, out_of_range is thrown.
1971 : * If the length of result exceeds max_size(), length_error is
1972 : * thrown. The value of the string doesn't change if an error
1973 : * is thrown.
1974 : */
1975 : basic_string&
1976 : replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
1977 : { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
1978 : _M_limit(__pos, __n1), __n2, __c); }
1979 :
1980 : /**
1981 : * @brief Replace range of characters with string.
1982 : * @param __i1 Iterator referencing start of range to replace.
1983 : * @param __i2 Iterator referencing end of range to replace.
1984 : * @param __str String value to insert.
1985 : * @return Reference to this string.
1986 : * @throw std::length_error If new length exceeds @c max_size().
1987 : *
1988 : * Removes the characters in the range [__i1,__i2). In place,
1989 : * the value of @a __str is inserted. If the length of result
1990 : * exceeds max_size(), length_error is thrown. The value of
1991 : * the string doesn't change if an error is thrown.
1992 : */
1993 : basic_string&
1994 : replace(__const_iterator __i1, __const_iterator __i2,
1995 : const basic_string& __str)
1996 : { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
1997 :
1998 : /**
1999 : * @brief Replace range of characters with C substring.
2000 : * @param __i1 Iterator referencing start of range to replace.
2001 : * @param __i2 Iterator referencing end of range to replace.
2002 : * @param __s C string value to insert.
2003 : * @param __n Number of characters from s to insert.
2004 : * @return Reference to this string.
2005 : * @throw std::length_error If new length exceeds @c max_size().
2006 : *
2007 : * Removes the characters in the range [__i1,__i2). In place,
2008 : * the first @a __n characters of @a __s are inserted. If the
2009 : * length of result exceeds max_size(), length_error is thrown.
2010 : * The value of the string doesn't change if an error is
2011 : * thrown.
2012 : */
2013 : basic_string&
2014 : replace(__const_iterator __i1, __const_iterator __i2,
2015 : const _CharT* __s, size_type __n)
2016 : {
2017 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2018 : && __i2 <= end());
2019 : return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
2020 : }
2021 :
2022 : /**
2023 : * @brief Replace range of characters with C string.
2024 : * @param __i1 Iterator referencing start of range to replace.
2025 : * @param __i2 Iterator referencing end of range to replace.
2026 : * @param __s C string value to insert.
2027 : * @return Reference to this string.
2028 : * @throw std::length_error If new length exceeds @c max_size().
2029 : *
2030 : * Removes the characters in the range [__i1,__i2). In place,
2031 : * the characters of @a __s are inserted. If the length of
2032 : * result exceeds max_size(), length_error is thrown. The
2033 : * value of the string doesn't change if an error is thrown.
2034 : */
2035 : basic_string&
2036 : replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
2037 : {
2038 : __glibcxx_requires_string(__s);
2039 : return this->replace(__i1, __i2, __s, traits_type::length(__s));
2040 : }
2041 :
2042 : /**
2043 : * @brief Replace range of characters with multiple characters
2044 : * @param __i1 Iterator referencing start of range to replace.
2045 : * @param __i2 Iterator referencing end of range to replace.
2046 : * @param __n Number of characters to insert.
2047 : * @param __c Character to insert.
2048 : * @return Reference to this string.
2049 : * @throw std::length_error If new length exceeds @c max_size().
2050 : *
2051 : * Removes the characters in the range [__i1,__i2). In place,
2052 : * @a __n copies of @a __c are inserted. If the length of
2053 : * result exceeds max_size(), length_error is thrown. The
2054 : * value of the string doesn't change if an error is thrown.
2055 : */
2056 : basic_string&
2057 : replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
2058 : _CharT __c)
2059 : {
2060 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2061 : && __i2 <= end());
2062 : return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
2063 : }
2064 :
2065 : /**
2066 : * @brief Replace range of characters with range.
2067 : * @param __i1 Iterator referencing start of range to replace.
2068 : * @param __i2 Iterator referencing end of range to replace.
2069 : * @param __k1 Iterator referencing start of range to insert.
2070 : * @param __k2 Iterator referencing end of range to insert.
2071 : * @return Reference to this string.
2072 : * @throw std::length_error If new length exceeds @c max_size().
2073 : *
2074 : * Removes the characters in the range [__i1,__i2). In place,
2075 : * characters in the range [__k1,__k2) are inserted. If the
2076 : * length of result exceeds max_size(), length_error is thrown.
2077 : * The value of the string doesn't change if an error is
2078 : * thrown.
2079 : */
2080 : #if __cplusplus >= 201103L
2081 : template<class _InputIterator,
2082 : typename = std::_RequireInputIter<_InputIterator>>
2083 : basic_string&
2084 : replace(const_iterator __i1, const_iterator __i2,
2085 : _InputIterator __k1, _InputIterator __k2)
2086 : {
2087 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2088 : && __i2 <= end());
2089 : __glibcxx_requires_valid_range(__k1, __k2);
2090 : return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
2091 : std::__false_type());
2092 : }
2093 : #else
2094 : template<class _InputIterator>
2095 : #ifdef _GLIBCXX_DISAMBIGUATE_REPLACE_INST
2096 : typename __enable_if_not_native_iterator<_InputIterator>::__type
2097 : #else
2098 : basic_string&
2099 : #endif
2100 : replace(iterator __i1, iterator __i2,
2101 : _InputIterator __k1, _InputIterator __k2)
2102 : {
2103 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2104 : && __i2 <= end());
2105 : __glibcxx_requires_valid_range(__k1, __k2);
2106 : typedef typename std::__is_integer<_InputIterator>::__type _Integral;
2107 : return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
2108 : }
2109 : #endif
2110 :
2111 : // Specializations for the common case of pointer and iterator:
2112 : // useful to avoid the overhead of temporary buffering in _M_replace.
2113 : basic_string&
2114 : replace(__const_iterator __i1, __const_iterator __i2,
2115 : _CharT* __k1, _CharT* __k2)
2116 : {
2117 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2118 : && __i2 <= end());
2119 : __glibcxx_requires_valid_range(__k1, __k2);
2120 : return this->replace(__i1 - begin(), __i2 - __i1,
2121 : __k1, __k2 - __k1);
2122 : }
2123 :
2124 : basic_string&
2125 : replace(__const_iterator __i1, __const_iterator __i2,
2126 : const _CharT* __k1, const _CharT* __k2)
2127 : {
2128 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2129 : && __i2 <= end());
2130 : __glibcxx_requires_valid_range(__k1, __k2);
2131 : return this->replace(__i1 - begin(), __i2 - __i1,
2132 : __k1, __k2 - __k1);
2133 : }
2134 :
2135 : basic_string&
2136 : replace(__const_iterator __i1, __const_iterator __i2,
2137 : iterator __k1, iterator __k2)
2138 : {
2139 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2140 : && __i2 <= end());
2141 : __glibcxx_requires_valid_range(__k1, __k2);
2142 : return this->replace(__i1 - begin(), __i2 - __i1,
2143 : __k1.base(), __k2 - __k1);
2144 : }
2145 :
2146 : basic_string&
2147 : replace(__const_iterator __i1, __const_iterator __i2,
2148 : const_iterator __k1, const_iterator __k2)
2149 : {
2150 : _GLIBCXX_DEBUG_PEDASSERT(begin() <= __i1 && __i1 <= __i2
2151 : && __i2 <= end());
2152 : __glibcxx_requires_valid_range(__k1, __k2);
2153 : return this->replace(__i1 - begin(), __i2 - __i1,
2154 : __k1.base(), __k2 - __k1);
2155 : }
2156 :
2157 : #if __cplusplus >= 201103L
2158 : /**
2159 : * @brief Replace range of characters with initializer_list.
2160 : * @param __i1 Iterator referencing start of range to replace.
2161 : * @param __i2 Iterator referencing end of range to replace.
2162 : * @param __l The initializer_list of characters to insert.
2163 : * @return Reference to this string.
2164 : * @throw std::length_error If new length exceeds @c max_size().
2165 : *
2166 : * Removes the characters in the range [__i1,__i2). In place,
2167 : * characters in the range [__k1,__k2) are inserted. If the
2168 : * length of result exceeds max_size(), length_error is thrown.
2169 : * The value of the string doesn't change if an error is
2170 : * thrown.
2171 : */
2172 : basic_string& replace(const_iterator __i1, const_iterator __i2,
2173 : initializer_list<_CharT> __l)
2174 : { return this->replace(__i1, __i2, __l.begin(), __l.size()); }
2175 : #endif // C++11
2176 :
2177 : #if __cplusplus > 201402L
2178 : /**
2179 : * @brief Replace range of characters with string_view.
2180 : * @param __pos The position to replace at.
2181 : * @param __n The number of characters to replace.
2182 : * @param __svt The object convertible to string_view to insert.
2183 : * @return Reference to this string.
2184 : */
2185 : template<typename _Tp>
2186 : _If_sv<_Tp, basic_string&>
2187 : replace(size_type __pos, size_type __n, const _Tp& __svt)
2188 : {
2189 : __sv_type __sv = __svt;
2190 : return this->replace(__pos, __n, __sv.data(), __sv.size());
2191 : }
2192 :
2193 : /**
2194 : * @brief Replace range of characters with string_view.
2195 : * @param __pos1 The position to replace at.
2196 : * @param __n1 The number of characters to replace.
2197 : * @param __svt The object convertible to string_view to insert from.
2198 : * @param __pos2 The position in the string_view to insert from.
2199 : * @param __n2 The number of characters to insert.
2200 : * @return Reference to this string.
2201 : */
2202 : template<typename _Tp>
2203 : _If_sv<_Tp, basic_string&>
2204 : replace(size_type __pos1, size_type __n1, const _Tp& __svt,
2205 : size_type __pos2, size_type __n2 = npos)
2206 : {
2207 : __sv_type __sv = __svt;
2208 : return this->replace(__pos1, __n1, __sv.data()
2209 : + __sv._M_check(__pos2, "basic_string::replace"),
2210 : __sv._M_limit(__pos2, __n2));
2211 : }
2212 :
2213 : /**
2214 : * @brief Replace range of characters with string_view.
2215 : * @param __i1 An iterator referencing the start position
2216 : to replace at.
2217 : * @param __i2 An iterator referencing the end position
2218 : for the replace.
2219 : * @param __svt The object convertible to string_view to insert from.
2220 : * @return Reference to this string.
2221 : */
2222 : template<typename _Tp>
2223 : _If_sv<_Tp, basic_string&>
2224 : replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
2225 : {
2226 : __sv_type __sv = __svt;
2227 : return this->replace(__i1 - begin(), __i2 - __i1, __sv);
2228 : }
2229 : #endif // C++17
2230 :
2231 : private:
2232 : template<class _Integer>
2233 : basic_string&
2234 : _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
2235 : _Integer __n, _Integer __val, __true_type)
2236 : { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
2237 :
2238 : template<class _InputIterator>
2239 : basic_string&
2240 : _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
2241 : _InputIterator __k1, _InputIterator __k2,
2242 : __false_type);
2243 :
2244 : basic_string&
2245 : _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
2246 : _CharT __c);
2247 :
2248 : basic_string&
2249 : _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
2250 : const size_type __len2);
2251 :
2252 : basic_string&
2253 : _M_append(const _CharT* __s, size_type __n);
2254 :
2255 : public:
2256 :
2257 : /**
2258 : * @brief Copy substring into C string.
2259 : * @param __s C string to copy value into.
2260 : * @param __n Number of characters to copy.
2261 : * @param __pos Index of first character to copy.
2262 : * @return Number of characters actually copied
2263 : * @throw std::out_of_range If __pos > size().
2264 : *
2265 : * Copies up to @a __n characters starting at @a __pos into the
2266 : * C string @a __s. If @a __pos is %greater than size(),
2267 : * out_of_range is thrown.
2268 : */
2269 : size_type
2270 : copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
2271 :
2272 : /**
2273 : * @brief Swap contents with another string.
2274 : * @param __s String to swap with.
2275 : *
2276 : * Exchanges the contents of this string with that of @a __s in constant
2277 : * time.
2278 : */
2279 : void
2280 : swap(basic_string& __s) _GLIBCXX_NOEXCEPT;
2281 :
2282 : // String operations:
2283 : /**
2284 : * @brief Return const pointer to null-terminated contents.
2285 : *
2286 : * This is a handle to internal data. Do not modify or dire things may
2287 : * happen.
2288 : */
2289 : const _CharT*
2290 : c_str() const _GLIBCXX_NOEXCEPT
2291 : { return _M_data(); }
2292 :
2293 : /**
2294 : * @brief Return const pointer to contents.
2295 : *
2296 : * This is a pointer to internal data. It is undefined to modify
2297 : * the contents through the returned pointer. To get a pointer that
2298 : * allows modifying the contents use @c &str[0] instead,
2299 : * (or in C++17 the non-const @c str.data() overload).
2300 : */
2301 : const _CharT*
2302 8865 : data() const _GLIBCXX_NOEXCEPT
2303 8865 : { return _M_data(); }
2304 :
2305 : #if __cplusplus > 201402L
2306 : /**
2307 : * @brief Return non-const pointer to contents.
2308 : *
2309 : * This is a pointer to the character sequence held by the string.
2310 : * Modifying the characters in the sequence is allowed.
2311 : */
2312 : _CharT*
2313 : data() noexcept
2314 : { return _M_data(); }
2315 : #endif
2316 :
2317 : /**
2318 : * @brief Return copy of allocator used to construct this string.
2319 : */
2320 : allocator_type
2321 : get_allocator() const _GLIBCXX_NOEXCEPT
2322 : { return _M_get_allocator(); }
2323 :
2324 : /**
2325 : * @brief Find position of a C substring.
2326 : * @param __s C string to locate.
2327 : * @param __pos Index of character to search from.
2328 : * @param __n Number of characters from @a s to search for.
2329 : * @return Index of start of first occurrence.
2330 : *
2331 : * Starting from @a __pos, searches forward for the first @a
2332 : * __n characters in @a __s within this string. If found,
2333 : * returns the index where it begins. If not found, returns
2334 : * npos.
2335 : */
2336 : size_type
2337 : find(const _CharT* __s, size_type __pos, size_type __n) const
2338 : _GLIBCXX_NOEXCEPT;
2339 :
2340 : /**
2341 : * @brief Find position of a string.
2342 : * @param __str String to locate.
2343 : * @param __pos Index of character to search from (default 0).
2344 : * @return Index of start of first occurrence.
2345 : *
2346 : * Starting from @a __pos, searches forward for value of @a __str within
2347 : * this string. If found, returns the index where it begins. If not
2348 : * found, returns npos.
2349 : */
2350 : size_type
2351 2336 : find(const basic_string& __str, size_type __pos = 0) const
2352 : _GLIBCXX_NOEXCEPT
2353 2336 : { return this->find(__str.data(), __pos, __str.size()); }
2354 :
2355 : #if __cplusplus > 201402L
2356 : /**
2357 : * @brief Find position of a string_view.
2358 : * @param __svt The object convertible to string_view to locate.
2359 : * @param __pos Index of character to search from (default 0).
2360 : * @return Index of start of first occurrence.
2361 : */
2362 : template<typename _Tp>
2363 : _If_sv<_Tp, size_type>
2364 : find(const _Tp& __svt, size_type __pos = 0) const
2365 : noexcept(is_same<_Tp, __sv_type>::value)
2366 : {
2367 : __sv_type __sv = __svt;
2368 : return this->find(__sv.data(), __pos, __sv.size());
2369 : }
2370 : #endif // C++17
2371 :
2372 : /**
2373 : * @brief Find position of a C string.
2374 : * @param __s C string to locate.
2375 : * @param __pos Index of character to search from (default 0).
2376 : * @return Index of start of first occurrence.
2377 : *
2378 : * Starting from @a __pos, searches forward for the value of @a
2379 : * __s within this string. If found, returns the index where
2380 : * it begins. If not found, returns npos.
2381 : */
2382 : size_type
2383 599 : find(const _CharT* __s, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
2384 : {
2385 : __glibcxx_requires_string(__s);
2386 599 : return this->find(__s, __pos, traits_type::length(__s));
2387 : }
2388 :
2389 : /**
2390 : * @brief Find position of a character.
2391 : * @param __c Character to locate.
2392 : * @param __pos Index of character to search from (default 0).
2393 : * @return Index of first occurrence.
2394 : *
2395 : * Starting from @a __pos, searches forward for @a __c within
2396 : * this string. If found, returns the index where it was
2397 : * found. If not found, returns npos.
2398 : */
2399 : size_type
2400 : find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT;
2401 :
2402 : /**
2403 : * @brief Find last position of a string.
2404 : * @param __str String to locate.
2405 : * @param __pos Index of character to search back from (default end).
2406 : * @return Index of start of last occurrence.
2407 : *
2408 : * Starting from @a __pos, searches backward for value of @a
2409 : * __str within this string. If found, returns the index where
2410 : * it begins. If not found, returns npos.
2411 : */
2412 : size_type
2413 : rfind(const basic_string& __str, size_type __pos = npos) const
2414 : _GLIBCXX_NOEXCEPT
2415 : { return this->rfind(__str.data(), __pos, __str.size()); }
2416 :
2417 : #if __cplusplus > 201402L
2418 : /**
2419 : * @brief Find last position of a string_view.
2420 : * @param __svt The object convertible to string_view to locate.
2421 : * @param __pos Index of character to search back from (default end).
2422 : * @return Index of start of last occurrence.
2423 : */
2424 : template<typename _Tp>
2425 : _If_sv<_Tp, size_type>
2426 : rfind(const _Tp& __svt, size_type __pos = npos) const
2427 : noexcept(is_same<_Tp, __sv_type>::value)
2428 : {
2429 : __sv_type __sv = __svt;
2430 : return this->rfind(__sv.data(), __pos, __sv.size());
2431 : }
2432 : #endif // C++17
2433 :
2434 : /**
2435 : * @brief Find last position of a C substring.
2436 : * @param __s C string to locate.
2437 : * @param __pos Index of character to search back from.
2438 : * @param __n Number of characters from s to search for.
2439 : * @return Index of start of last occurrence.
2440 : *
2441 : * Starting from @a __pos, searches backward for the first @a
2442 : * __n characters in @a __s within this string. If found,
2443 : * returns the index where it begins. If not found, returns
2444 : * npos.
2445 : */
2446 : size_type
2447 : rfind(const _CharT* __s, size_type __pos, size_type __n) const
2448 : _GLIBCXX_NOEXCEPT;
2449 :
2450 : /**
2451 : * @brief Find last position of a C string.
2452 : * @param __s C string to locate.
2453 : * @param __pos Index of character to start search at (default end).
2454 : * @return Index of start of last occurrence.
2455 : *
2456 : * Starting from @a __pos, searches backward for the value of
2457 : * @a __s within this string. If found, returns the index
2458 : * where it begins. If not found, returns npos.
2459 : */
2460 : size_type
2461 : rfind(const _CharT* __s, size_type __pos = npos) const
2462 : {
2463 : __glibcxx_requires_string(__s);
2464 : return this->rfind(__s, __pos, traits_type::length(__s));
2465 : }
2466 :
2467 : /**
2468 : * @brief Find last position of a character.
2469 : * @param __c Character to locate.
2470 : * @param __pos Index of character to search back from (default end).
2471 : * @return Index of last occurrence.
2472 : *
2473 : * Starting from @a __pos, searches backward for @a __c within
2474 : * this string. If found, returns the index where it was
2475 : * found. If not found, returns npos.
2476 : */
2477 : size_type
2478 : rfind(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT;
2479 :
2480 : /**
2481 : * @brief Find position of a character of string.
2482 : * @param __str String containing characters to locate.
2483 : * @param __pos Index of character to search from (default 0).
2484 : * @return Index of first occurrence.
2485 : *
2486 : * Starting from @a __pos, searches forward for one of the
2487 : * characters of @a __str within this string. If found,
2488 : * returns the index where it was found. If not found, returns
2489 : * npos.
2490 : */
2491 : size_type
2492 : find_first_of(const basic_string& __str, size_type __pos = 0) const
2493 : _GLIBCXX_NOEXCEPT
2494 : { return this->find_first_of(__str.data(), __pos, __str.size()); }
2495 :
2496 : #if __cplusplus > 201402L
2497 : /**
2498 : * @brief Find position of a character of a string_view.
2499 : * @param __svt An object convertible to string_view containing
2500 : * characters to locate.
2501 : * @param __pos Index of character to search from (default 0).
2502 : * @return Index of first occurrence.
2503 : */
2504 : template<typename _Tp>
2505 : _If_sv<_Tp, size_type>
2506 : find_first_of(const _Tp& __svt, size_type __pos = 0) const
2507 : noexcept(is_same<_Tp, __sv_type>::value)
2508 : {
2509 : __sv_type __sv = __svt;
2510 : return this->find_first_of(__sv.data(), __pos, __sv.size());
2511 : }
2512 : #endif // C++17
2513 :
2514 : /**
2515 : * @brief Find position of a character of C substring.
2516 : * @param __s String containing characters to locate.
2517 : * @param __pos Index of character to search from.
2518 : * @param __n Number of characters from s to search for.
2519 : * @return Index of first occurrence.
2520 : *
2521 : * Starting from @a __pos, searches forward for one of the
2522 : * first @a __n characters of @a __s within this string. If
2523 : * found, returns the index where it was found. If not found,
2524 : * returns npos.
2525 : */
2526 : size_type
2527 : find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
2528 : _GLIBCXX_NOEXCEPT;
2529 :
2530 : /**
2531 : * @brief Find position of a character of C string.
2532 : * @param __s String containing characters to locate.
2533 : * @param __pos Index of character to search from (default 0).
2534 : * @return Index of first occurrence.
2535 : *
2536 : * Starting from @a __pos, searches forward for one of the
2537 : * characters of @a __s within this string. If found, returns
2538 : * the index where it was found. If not found, returns npos.
2539 : */
2540 : size_type
2541 : find_first_of(const _CharT* __s, size_type __pos = 0) const
2542 : _GLIBCXX_NOEXCEPT
2543 : {
2544 : __glibcxx_requires_string(__s);
2545 : return this->find_first_of(__s, __pos, traits_type::length(__s));
2546 : }
2547 :
2548 : /**
2549 : * @brief Find position of a character.
2550 : * @param __c Character to locate.
2551 : * @param __pos Index of character to search from (default 0).
2552 : * @return Index of first occurrence.
2553 : *
2554 : * Starting from @a __pos, searches forward for the character
2555 : * @a __c within this string. If found, returns the index
2556 : * where it was found. If not found, returns npos.
2557 : *
2558 : * Note: equivalent to find(__c, __pos).
2559 : */
2560 : size_type
2561 : find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
2562 : { return this->find(__c, __pos); }
2563 :
2564 : /**
2565 : * @brief Find last position of a character of string.
2566 : * @param __str String containing characters to locate.
2567 : * @param __pos Index of character to search back from (default end).
2568 : * @return Index of last occurrence.
2569 : *
2570 : * Starting from @a __pos, searches backward for one of the
2571 : * characters of @a __str within this string. If found,
2572 : * returns the index where it was found. If not found, returns
2573 : * npos.
2574 : */
2575 : size_type
2576 : find_last_of(const basic_string& __str, size_type __pos = npos) const
2577 : _GLIBCXX_NOEXCEPT
2578 : { return this->find_last_of(__str.data(), __pos, __str.size()); }
2579 :
2580 : #if __cplusplus > 201402L
2581 : /**
2582 : * @brief Find last position of a character of string.
2583 : * @param __svt An object convertible to string_view containing
2584 : * characters to locate.
2585 : * @param __pos Index of character to search back from (default end).
2586 : * @return Index of last occurrence.
2587 : */
2588 : template<typename _Tp>
2589 : _If_sv<_Tp, size_type>
2590 : find_last_of(const _Tp& __svt, size_type __pos = npos) const
2591 : noexcept(is_same<_Tp, __sv_type>::value)
2592 : {
2593 : __sv_type __sv = __svt;
2594 : return this->find_last_of(__sv.data(), __pos, __sv.size());
2595 : }
2596 : #endif // C++17
2597 :
2598 : /**
2599 : * @brief Find last position of a character of C substring.
2600 : * @param __s C string containing characters to locate.
2601 : * @param __pos Index of character to search back from.
2602 : * @param __n Number of characters from s to search for.
2603 : * @return Index of last occurrence.
2604 : *
2605 : * Starting from @a __pos, searches backward for one of the
2606 : * first @a __n characters of @a __s within this string. If
2607 : * found, returns the index where it was found. If not found,
2608 : * returns npos.
2609 : */
2610 : size_type
2611 : find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
2612 : _GLIBCXX_NOEXCEPT;
2613 :
2614 : /**
2615 : * @brief Find last position of a character of C string.
2616 : * @param __s C string containing characters to locate.
2617 : * @param __pos Index of character to search back from (default end).
2618 : * @return Index of last occurrence.
2619 : *
2620 : * Starting from @a __pos, searches backward for one of the
2621 : * characters of @a __s within this string. If found, returns
2622 : * the index where it was found. If not found, returns npos.
2623 : */
2624 : size_type
2625 : find_last_of(const _CharT* __s, size_type __pos = npos) const
2626 : _GLIBCXX_NOEXCEPT
2627 : {
2628 : __glibcxx_requires_string(__s);
2629 : return this->find_last_of(__s, __pos, traits_type::length(__s));
2630 : }
2631 :
2632 : /**
2633 : * @brief Find last position of a character.
2634 : * @param __c Character to locate.
2635 : * @param __pos Index of character to search back from (default end).
2636 : * @return Index of last occurrence.
2637 : *
2638 : * Starting from @a __pos, searches backward for @a __c within
2639 : * this string. If found, returns the index where it was
2640 : * found. If not found, returns npos.
2641 : *
2642 : * Note: equivalent to rfind(__c, __pos).
2643 : */
2644 : size_type
2645 : find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
2646 : { return this->rfind(__c, __pos); }
2647 :
2648 : /**
2649 : * @brief Find position of a character not in string.
2650 : * @param __str String containing characters to avoid.
2651 : * @param __pos Index of character to search from (default 0).
2652 : * @return Index of first occurrence.
2653 : *
2654 : * Starting from @a __pos, searches forward for a character not contained
2655 : * in @a __str within this string. If found, returns the index where it
2656 : * was found. If not found, returns npos.
2657 : */
2658 : size_type
2659 : find_first_not_of(const basic_string& __str, size_type __pos = 0) const
2660 : _GLIBCXX_NOEXCEPT
2661 : { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
2662 :
2663 : #if __cplusplus > 201402L
2664 : /**
2665 : * @brief Find position of a character not in a string_view.
2666 : * @param __svt A object convertible to string_view containing
2667 : * characters to avoid.
2668 : * @param __pos Index of character to search from (default 0).
2669 : * @return Index of first occurrence.
2670 : */
2671 : template<typename _Tp>
2672 : _If_sv<_Tp, size_type>
2673 : find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
2674 : noexcept(is_same<_Tp, __sv_type>::value)
2675 : {
2676 : __sv_type __sv = __svt;
2677 : return this->find_first_not_of(__sv.data(), __pos, __sv.size());
2678 : }
2679 : #endif // C++17
2680 :
2681 : /**
2682 : * @brief Find position of a character not in C substring.
2683 : * @param __s C string containing characters to avoid.
2684 : * @param __pos Index of character to search from.
2685 : * @param __n Number of characters from __s to consider.
2686 : * @return Index of first occurrence.
2687 : *
2688 : * Starting from @a __pos, searches forward for a character not
2689 : * contained in the first @a __n characters of @a __s within
2690 : * this string. If found, returns the index where it was
2691 : * found. If not found, returns npos.
2692 : */
2693 : size_type
2694 : find_first_not_of(const _CharT* __s, size_type __pos,
2695 : size_type __n) const _GLIBCXX_NOEXCEPT;
2696 :
2697 : /**
2698 : * @brief Find position of a character not in C string.
2699 : * @param __s C string containing characters to avoid.
2700 : * @param __pos Index of character to search from (default 0).
2701 : * @return Index of first occurrence.
2702 : *
2703 : * Starting from @a __pos, searches forward for a character not
2704 : * contained in @a __s within this string. If found, returns
2705 : * the index where it was found. If not found, returns npos.
2706 : */
2707 : size_type
2708 : find_first_not_of(const _CharT* __s, size_type __pos = 0) const
2709 : _GLIBCXX_NOEXCEPT
2710 : {
2711 : __glibcxx_requires_string(__s);
2712 : return this->find_first_not_of(__s, __pos, traits_type::length(__s));
2713 : }
2714 :
2715 : /**
2716 : * @brief Find position of a different character.
2717 : * @param __c Character to avoid.
2718 : * @param __pos Index of character to search from (default 0).
2719 : * @return Index of first occurrence.
2720 : *
2721 : * Starting from @a __pos, searches forward for a character
2722 : * other than @a __c within this string. If found, returns the
2723 : * index where it was found. If not found, returns npos.
2724 : */
2725 : size_type
2726 : find_first_not_of(_CharT __c, size_type __pos = 0) const
2727 : _GLIBCXX_NOEXCEPT;
2728 :
2729 : /**
2730 : * @brief Find last position of a character not in string.
2731 : * @param __str String containing characters to avoid.
2732 : * @param __pos Index of character to search back from (default end).
2733 : * @return Index of last occurrence.
2734 : *
2735 : * Starting from @a __pos, searches backward for a character
2736 : * not contained in @a __str within this string. If found,
2737 : * returns the index where it was found. If not found, returns
2738 : * npos.
2739 : */
2740 : size_type
2741 : find_last_not_of(const basic_string& __str, size_type __pos = npos) const
2742 : _GLIBCXX_NOEXCEPT
2743 : { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
2744 :
2745 : #if __cplusplus > 201402L
2746 : /**
2747 : * @brief Find last position of a character not in a string_view.
2748 : * @param __svt An object convertible to string_view containing
2749 : * characters to avoid.
2750 : * @param __pos Index of character to search back from (default end).
2751 : * @return Index of last occurrence.
2752 : */
2753 : template<typename _Tp>
2754 : _If_sv<_Tp, size_type>
2755 : find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
2756 : noexcept(is_same<_Tp, __sv_type>::value)
2757 : {
2758 : __sv_type __sv = __svt;
2759 : return this->find_last_not_of(__sv.data(), __pos, __sv.size());
2760 : }
2761 : #endif // C++17
2762 :
2763 : /**
2764 : * @brief Find last position of a character not in C substring.
2765 : * @param __s C string containing characters to avoid.
2766 : * @param __pos Index of character to search back from.
2767 : * @param __n Number of characters from s to consider.
2768 : * @return Index of last occurrence.
2769 : *
2770 : * Starting from @a __pos, searches backward for a character not
2771 : * contained in the first @a __n characters of @a __s within this string.
2772 : * If found, returns the index where it was found. If not found,
2773 : * returns npos.
2774 : */
2775 : size_type
2776 : find_last_not_of(const _CharT* __s, size_type __pos,
2777 : size_type __n) const _GLIBCXX_NOEXCEPT;
2778 : /**
2779 : * @brief Find last position of a character not in C string.
2780 : * @param __s C string containing characters to avoid.
2781 : * @param __pos Index of character to search back from (default end).
2782 : * @return Index of last occurrence.
2783 : *
2784 : * Starting from @a __pos, searches backward for a character
2785 : * not contained in @a __s within this string. If found,
2786 : * returns the index where it was found. If not found, returns
2787 : * npos.
2788 : */
2789 : size_type
2790 : find_last_not_of(const _CharT* __s, size_type __pos = npos) const
2791 : _GLIBCXX_NOEXCEPT
2792 : {
2793 : __glibcxx_requires_string(__s);
2794 : return this->find_last_not_of(__s, __pos, traits_type::length(__s));
2795 : }
2796 :
2797 : /**
2798 : * @brief Find last position of a different character.
2799 : * @param __c Character to avoid.
2800 : * @param __pos Index of character to search back from (default end).
2801 : * @return Index of last occurrence.
2802 : *
2803 : * Starting from @a __pos, searches backward for a character other than
2804 : * @a __c within this string. If found, returns the index where it was
2805 : * found. If not found, returns npos.
2806 : */
2807 : size_type
2808 : find_last_not_of(_CharT __c, size_type __pos = npos) const
2809 : _GLIBCXX_NOEXCEPT;
2810 :
2811 : /**
2812 : * @brief Get a substring.
2813 : * @param __pos Index of first character (default 0).
2814 : * @param __n Number of characters in substring (default remainder).
2815 : * @return The new string.
2816 : * @throw std::out_of_range If __pos > size().
2817 : *
2818 : * Construct and return a new string using the @a __n
2819 : * characters starting at @a __pos. If the string is too
2820 : * short, use the remainder of the characters. If @a __pos is
2821 : * beyond the end of the string, out_of_range is thrown.
2822 : */
2823 : basic_string
2824 0 : substr(size_type __pos = 0, size_type __n = npos) const
2825 : { return basic_string(*this,
2826 0 : _M_check(__pos, "basic_string::substr"), __n); }
2827 :
2828 : /**
2829 : * @brief Compare to a string.
2830 : * @param __str String to compare against.
2831 : * @return Integer < 0, 0, or > 0.
2832 : *
2833 : * Returns an integer < 0 if this string is ordered before @a
2834 : * __str, 0 if their values are equivalent, or > 0 if this
2835 : * string is ordered after @a __str. Determines the effective
2836 : * length rlen of the strings to compare as the smallest of
2837 : * size() and str.size(). The function then compares the two
2838 : * strings by calling traits::compare(data(), str.data(),rlen).
2839 : * If the result of the comparison is nonzero returns it,
2840 : * otherwise the shorter one is ordered first.
2841 : */
2842 : int
2843 : compare(const basic_string& __str) const
2844 : {
2845 : const size_type __size = this->size();
2846 : const size_type __osize = __str.size();
2847 : const size_type __len = std::min(__size, __osize);
2848 :
2849 : int __r = traits_type::compare(_M_data(), __str.data(), __len);
2850 : if (!__r)
2851 : __r = _S_compare(__size, __osize);
2852 : return __r;
2853 : }
2854 :
2855 : #if __cplusplus > 201402L
2856 : /**
2857 : * @brief Compare to a string_view.
2858 : * @param __svt An object convertible to string_view to compare against.
2859 : * @return Integer < 0, 0, or > 0.
2860 : */
2861 : template<typename _Tp>
2862 : _If_sv<_Tp, int>
2863 : compare(const _Tp& __svt) const
2864 : noexcept(is_same<_Tp, __sv_type>::value)
2865 : {
2866 : __sv_type __sv = __svt;
2867 : const size_type __size = this->size();
2868 : const size_type __osize = __sv.size();
2869 : const size_type __len = std::min(__size, __osize);
2870 :
2871 : int __r = traits_type::compare(_M_data(), __sv.data(), __len);
2872 : if (!__r)
2873 : __r = _S_compare(__size, __osize);
2874 : return __r;
2875 : }
2876 :
2877 : /**
2878 : * @brief Compare to a string_view.
2879 : * @param __pos A position in the string to start comparing from.
2880 : * @param __n The number of characters to compare.
2881 : * @param __svt An object convertible to string_view to compare
2882 : * against.
2883 : * @return Integer < 0, 0, or > 0.
2884 : */
2885 : template<typename _Tp>
2886 : _If_sv<_Tp, int>
2887 : compare(size_type __pos, size_type __n, const _Tp& __svt) const
2888 : noexcept(is_same<_Tp, __sv_type>::value)
2889 : {
2890 : __sv_type __sv = __svt;
2891 : return __sv_type(*this).substr(__pos, __n).compare(__sv);
2892 : }
2893 :
2894 : /**
2895 : * @brief Compare to a string_view.
2896 : * @param __pos1 A position in the string to start comparing from.
2897 : * @param __n1 The number of characters to compare.
2898 : * @param __svt An object convertible to string_view to compare
2899 : * against.
2900 : * @param __pos2 A position in the string_view to start comparing from.
2901 : * @param __n2 The number of characters to compare.
2902 : * @return Integer < 0, 0, or > 0.
2903 : */
2904 : template<typename _Tp>
2905 : _If_sv<_Tp, int>
2906 : compare(size_type __pos1, size_type __n1, const _Tp& __svt,
2907 : size_type __pos2, size_type __n2 = npos) const
2908 : noexcept(is_same<_Tp, __sv_type>::value)
2909 : {
2910 : __sv_type __sv = __svt;
2911 : return __sv_type(*this)
2912 : .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
2913 : }
2914 : #endif // C++17
2915 :
2916 : /**
2917 : * @brief Compare substring to a string.
2918 : * @param __pos Index of first character of substring.
2919 : * @param __n Number of characters in substring.
2920 : * @param __str String to compare against.
2921 : * @return Integer < 0, 0, or > 0.
2922 : *
2923 : * Form the substring of this string from the @a __n characters
2924 : * starting at @a __pos. Returns an integer < 0 if the
2925 : * substring is ordered before @a __str, 0 if their values are
2926 : * equivalent, or > 0 if the substring is ordered after @a
2927 : * __str. Determines the effective length rlen of the strings
2928 : * to compare as the smallest of the length of the substring
2929 : * and @a __str.size(). The function then compares the two
2930 : * strings by calling
2931 : * traits::compare(substring.data(),str.data(),rlen). If the
2932 : * result of the comparison is nonzero returns it, otherwise
2933 : * the shorter one is ordered first.
2934 : */
2935 : int
2936 : compare(size_type __pos, size_type __n, const basic_string& __str) const;
2937 :
2938 : /**
2939 : * @brief Compare substring to a substring.
2940 : * @param __pos1 Index of first character of substring.
2941 : * @param __n1 Number of characters in substring.
2942 : * @param __str String to compare against.
2943 : * @param __pos2 Index of first character of substring of str.
2944 : * @param __n2 Number of characters in substring of str.
2945 : * @return Integer < 0, 0, or > 0.
2946 : *
2947 : * Form the substring of this string from the @a __n1
2948 : * characters starting at @a __pos1. Form the substring of @a
2949 : * __str from the @a __n2 characters starting at @a __pos2.
2950 : * Returns an integer < 0 if this substring is ordered before
2951 : * the substring of @a __str, 0 if their values are equivalent,
2952 : * or > 0 if this substring is ordered after the substring of
2953 : * @a __str. Determines the effective length rlen of the
2954 : * strings to compare as the smallest of the lengths of the
2955 : * substrings. The function then compares the two strings by
2956 : * calling
2957 : * traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
2958 : * If the result of the comparison is nonzero returns it,
2959 : * otherwise the shorter one is ordered first.
2960 : */
2961 : int
2962 : compare(size_type __pos1, size_type __n1, const basic_string& __str,
2963 : size_type __pos2, size_type __n2 = npos) const;
2964 :
2965 : /**
2966 : * @brief Compare to a C string.
2967 : * @param __s C string to compare against.
2968 : * @return Integer < 0, 0, or > 0.
2969 : *
2970 : * Returns an integer < 0 if this string is ordered before @a __s, 0 if
2971 : * their values are equivalent, or > 0 if this string is ordered after
2972 : * @a __s. Determines the effective length rlen of the strings to
2973 : * compare as the smallest of size() and the length of a string
2974 : * constructed from @a __s. The function then compares the two strings
2975 : * by calling traits::compare(data(),s,rlen). If the result of the
2976 : * comparison is nonzero returns it, otherwise the shorter one is
2977 : * ordered first.
2978 : */
2979 : int
2980 : compare(const _CharT* __s) const _GLIBCXX_NOEXCEPT;
2981 :
2982 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
2983 : // 5 String::compare specification questionable
2984 : /**
2985 : * @brief Compare substring to a C string.
2986 : * @param __pos Index of first character of substring.
2987 : * @param __n1 Number of characters in substring.
2988 : * @param __s C string to compare against.
2989 : * @return Integer < 0, 0, or > 0.
2990 : *
2991 : * Form the substring of this string from the @a __n1
2992 : * characters starting at @a pos. Returns an integer < 0 if
2993 : * the substring is ordered before @a __s, 0 if their values
2994 : * are equivalent, or > 0 if the substring is ordered after @a
2995 : * __s. Determines the effective length rlen of the strings to
2996 : * compare as the smallest of the length of the substring and
2997 : * the length of a string constructed from @a __s. The
2998 : * function then compares the two string by calling
2999 : * traits::compare(substring.data(),__s,rlen). If the result of
3000 : * the comparison is nonzero returns it, otherwise the shorter
3001 : * one is ordered first.
3002 : */
3003 : int
3004 : compare(size_type __pos, size_type __n1, const _CharT* __s) const;
3005 :
3006 : /**
3007 : * @brief Compare substring against a character %array.
3008 : * @param __pos Index of first character of substring.
3009 : * @param __n1 Number of characters in substring.
3010 : * @param __s character %array to compare against.
3011 : * @param __n2 Number of characters of s.
3012 : * @return Integer < 0, 0, or > 0.
3013 : *
3014 : * Form the substring of this string from the @a __n1
3015 : * characters starting at @a __pos. Form a string from the
3016 : * first @a __n2 characters of @a __s. Returns an integer < 0
3017 : * if this substring is ordered before the string from @a __s,
3018 : * 0 if their values are equivalent, or > 0 if this substring
3019 : * is ordered after the string from @a __s. Determines the
3020 : * effective length rlen of the strings to compare as the
3021 : * smallest of the length of the substring and @a __n2. The
3022 : * function then compares the two strings by calling
3023 : * traits::compare(substring.data(),s,rlen). If the result of
3024 : * the comparison is nonzero returns it, otherwise the shorter
3025 : * one is ordered first.
3026 : *
3027 : * NB: s must have at least n2 characters, '\\0' has
3028 : * no special meaning.
3029 : */
3030 : int
3031 : compare(size_type __pos, size_type __n1, const _CharT* __s,
3032 : size_type __n2) const;
3033 :
3034 : // Allow basic_stringbuf::__xfer_bufptrs to call _M_length:
3035 : template<typename, typename, typename> friend class basic_stringbuf;
3036 : };
3037 : _GLIBCXX_END_NAMESPACE_CXX11
3038 : #else // !_GLIBCXX_USE_CXX11_ABI
3039 : // Reference-counted COW string implentation
3040 :
3041 : /**
3042 : * @class basic_string basic_string.h <string>
3043 : * @brief Managing sequences of characters and character-like objects.
3044 : *
3045 : * @ingroup strings
3046 : * @ingroup sequences
3047 : *
3048 : * @tparam _CharT Type of character
3049 : * @tparam _Traits Traits for character type, defaults to
3050 : * char_traits<_CharT>.
3051 : * @tparam _Alloc Allocator type, defaults to allocator<_CharT>.
3052 : *
3053 : * Meets the requirements of a <a href="tables.html#65">container</a>, a
3054 : * <a href="tables.html#66">reversible container</a>, and a
3055 : * <a href="tables.html#67">sequence</a>. Of the
3056 : * <a href="tables.html#68">optional sequence requirements</a>, only
3057 : * @c push_back, @c at, and @c %array access are supported.
3058 : *
3059 : * @doctodo
3060 : *
3061 : *
3062 : * Documentation? What's that?
3063 : * Nathan Myers <ncm@cantrip.org>.
3064 : *
3065 : * A string looks like this:
3066 : *
3067 : * @code
3068 : * [_Rep]
3069 : * _M_length
3070 : * [basic_string<char_type>] _M_capacity
3071 : * _M_dataplus _M_refcount
3072 : * _M_p ----------------> unnamed array of char_type
3073 : * @endcode
3074 : *
3075 : * Where the _M_p points to the first character in the string, and
3076 : * you cast it to a pointer-to-_Rep and subtract 1 to get a
3077 : * pointer to the header.
3078 : *
3079 : * This approach has the enormous advantage that a string object
3080 : * requires only one allocation. All the ugliness is confined
3081 : * within a single %pair of inline functions, which each compile to
3082 : * a single @a add instruction: _Rep::_M_data(), and
3083 : * string::_M_rep(); and the allocation function which gets a
3084 : * block of raw bytes and with room enough and constructs a _Rep
3085 : * object at the front.
3086 : *
3087 : * The reason you want _M_data pointing to the character %array and
3088 : * not the _Rep is so that the debugger can see the string
3089 : * contents. (Probably we should add a non-inline member to get
3090 : * the _Rep for the debugger to use, so users can check the actual
3091 : * string length.)
3092 : *
3093 : * Note that the _Rep object is a POD so that you can have a
3094 : * static <em>empty string</em> _Rep object already @a constructed before
3095 : * static constructors have run. The reference-count encoding is
3096 : * chosen so that a 0 indicates one reference, so you never try to
3097 : * destroy the empty-string _Rep object.
3098 : *
3099 : * All but the last paragraph is considered pretty conventional
3100 : * for a C++ string implementation.
3101 : */
3102 : // 21.3 Template class basic_string
3103 : template<typename _CharT, typename _Traits, typename _Alloc>
3104 : class basic_string
3105 : {
3106 : typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
3107 :
3108 : // Types:
3109 : public:
3110 : typedef _Traits traits_type;
3111 : typedef typename _Traits::char_type value_type;
3112 : typedef _Alloc allocator_type;
3113 : typedef typename _CharT_alloc_type::size_type size_type;
3114 : typedef typename _CharT_alloc_type::difference_type difference_type;
3115 : typedef typename _CharT_alloc_type::reference reference;
3116 : typedef typename _CharT_alloc_type::const_reference const_reference;
3117 : typedef typename _CharT_alloc_type::pointer pointer;
3118 : typedef typename _CharT_alloc_type::const_pointer const_pointer;
3119 : typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
3120 : typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
3121 : const_iterator;
3122 : typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
3123 : typedef std::reverse_iterator<iterator> reverse_iterator;
3124 :
3125 : private:
3126 : // _Rep: string representation
3127 : // Invariants:
3128 : // 1. String really contains _M_length + 1 characters: due to 21.3.4
3129 : // must be kept null-terminated.
3130 : // 2. _M_capacity >= _M_length
3131 : // Allocated memory is always (_M_capacity + 1) * sizeof(_CharT).
3132 : // 3. _M_refcount has three states:
3133 : // -1: leaked, one reference, no ref-copies allowed, non-const.
3134 : // 0: one reference, non-const.
3135 : // n>0: n + 1 references, operations require a lock, const.
3136 : // 4. All fields==0 is an empty string, given the extra storage
3137 : // beyond-the-end for a null terminator; thus, the shared
3138 : // empty string representation needs no constructor.
3139 :
3140 : struct _Rep_base
3141 : {
3142 : size_type _M_length;
3143 : size_type _M_capacity;
3144 : _Atomic_word _M_refcount;
3145 : };
3146 :
3147 : struct _Rep : _Rep_base
3148 : {
3149 : // Types:
3150 : typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
3151 :
3152 : // (Public) Data members:
3153 :
3154 : // The maximum number of individual char_type elements of an
3155 : // individual string is determined by _S_max_size. This is the
3156 : // value that will be returned by max_size(). (Whereas npos
3157 : // is the maximum number of bytes the allocator can allocate.)
3158 : // If one was to divvy up the theoretical largest size string,
3159 : // with a terminating character and m _CharT elements, it'd
3160 : // look like this:
3161 : // npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT)
3162 : // Solving for m:
3163 : // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1
3164 : // In addition, this implementation quarters this amount.
3165 : static const size_type _S_max_size;
3166 : static const _CharT _S_terminal;
3167 :
3168 : // The following storage is init'd to 0 by the linker, resulting
3169 : // (carefully) in an empty string with one reference.
3170 : static size_type _S_empty_rep_storage[];
3171 :
3172 : static _Rep&
3173 : _S_empty_rep() _GLIBCXX_NOEXCEPT
3174 : {
3175 : // NB: Mild hack to avoid strict-aliasing warnings. Note that
3176 : // _S_empty_rep_storage is never modified and the punning should
3177 : // be reasonably safe in this case.
3178 : void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
3179 : return *reinterpret_cast<_Rep*>(__p);
3180 : }
3181 :
3182 : bool
3183 : _M_is_leaked() const _GLIBCXX_NOEXCEPT
3184 : {
3185 : #if defined(__GTHREADS)
3186 : // _M_refcount is mutated concurrently by _M_refcopy/_M_dispose,
3187 : // so we need to use an atomic load. However, _M_is_leaked
3188 : // predicate does not change concurrently (i.e. the string is either
3189 : // leaked or not), so a relaxed load is enough.
3190 : return __atomic_load_n(&this->_M_refcount, __ATOMIC_RELAXED) < 0;
3191 : #else
3192 : return this->_M_refcount < 0;
3193 : #endif
3194 : }
3195 :
3196 : bool
3197 : _M_is_shared() const _GLIBCXX_NOEXCEPT
3198 : {
3199 : #if defined(__GTHREADS)
3200 : // _M_refcount is mutated concurrently by _M_refcopy/_M_dispose,
3201 : // so we need to use an atomic load. Another thread can drop last
3202 : // but one reference concurrently with this check, so we need this
3203 : // load to be acquire to synchronize with release fetch_and_add in
3204 : // _M_dispose.
3205 : return __atomic_load_n(&this->_M_refcount, __ATOMIC_ACQUIRE) > 0;
3206 : #else
3207 : return this->_M_refcount > 0;
3208 : #endif
3209 : }
3210 :
3211 : void
3212 : _M_set_leaked() _GLIBCXX_NOEXCEPT
3213 : { this->_M_refcount = -1; }
3214 :
3215 : void
3216 : _M_set_sharable() _GLIBCXX_NOEXCEPT
3217 : { this->_M_refcount = 0; }
3218 :
3219 : void
3220 : _M_set_length_and_sharable(size_type __n) _GLIBCXX_NOEXCEPT
3221 : {
3222 : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3223 : if (__builtin_expect(this != &_S_empty_rep(), false))
3224 : #endif
3225 : {
3226 : this->_M_set_sharable(); // One reference.
3227 : this->_M_length = __n;
3228 : traits_type::assign(this->_M_refdata()[__n], _S_terminal);
3229 : // grrr. (per 21.3.4)
3230 : // You cannot leave those LWG people alone for a second.
3231 : }
3232 : }
3233 :
3234 : _CharT*
3235 : _M_refdata() throw()
3236 : { return reinterpret_cast<_CharT*>(this + 1); }
3237 :
3238 : _CharT*
3239 : _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
3240 : {
3241 : return (!_M_is_leaked() && __alloc1 == __alloc2)
3242 : ? _M_refcopy() : _M_clone(__alloc1);
3243 : }
3244 :
3245 : // Create & Destroy
3246 : static _Rep*
3247 : _S_create(size_type, size_type, const _Alloc&);
3248 :
3249 : void
3250 : _M_dispose(const _Alloc& __a) _GLIBCXX_NOEXCEPT
3251 : {
3252 : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3253 : if (__builtin_expect(this != &_S_empty_rep(), false))
3254 : #endif
3255 : {
3256 : // Be race-detector-friendly. For more info see bits/c++config.
3257 : _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount);
3258 : // Decrement of _M_refcount is acq_rel, because:
3259 : // - all but last decrements need to release to synchronize with
3260 : // the last decrement that will delete the object.
3261 : // - the last decrement needs to acquire to synchronize with
3262 : // all the previous decrements.
3263 : // - last but one decrement needs to release to synchronize with
3264 : // the acquire load in _M_is_shared that will conclude that
3265 : // the object is not shared anymore.
3266 : if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
3267 : -1) <= 0)
3268 : {
3269 : _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount);
3270 : _M_destroy(__a);
3271 : }
3272 : }
3273 : } // XXX MT
3274 :
3275 : void
3276 : _M_destroy(const _Alloc&) throw();
3277 :
3278 : _CharT*
3279 : _M_refcopy() throw()
3280 : {
3281 : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3282 : if (__builtin_expect(this != &_S_empty_rep(), false))
3283 : #endif
3284 : __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
3285 : return _M_refdata();
3286 : } // XXX MT
3287 :
3288 : _CharT*
3289 : _M_clone(const _Alloc&, size_type __res = 0);
3290 : };
3291 :
3292 : // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
3293 : struct _Alloc_hider : _Alloc
3294 : {
3295 : _Alloc_hider(_CharT* __dat, const _Alloc& __a) _GLIBCXX_NOEXCEPT
3296 : : _Alloc(__a), _M_p(__dat) { }
3297 :
3298 : _CharT* _M_p; // The actual data.
3299 : };
3300 :
3301 : public:
3302 : // Data Members (public):
3303 : // NB: This is an unsigned type, and thus represents the maximum
3304 : // size that the allocator can hold.
3305 : /// Value returned by various member functions when they fail.
3306 : static const size_type npos = static_cast<size_type>(-1);
3307 :
3308 : private:
3309 : // Data Members (private):
3310 : mutable _Alloc_hider _M_dataplus;
3311 :
3312 : _CharT*
3313 : _M_data() const _GLIBCXX_NOEXCEPT
3314 : { return _M_dataplus._M_p; }
3315 :
3316 : _CharT*
3317 : _M_data(_CharT* __p) _GLIBCXX_NOEXCEPT
3318 : { return (_M_dataplus._M_p = __p); }
3319 :
3320 : _Rep*
3321 : _M_rep() const _GLIBCXX_NOEXCEPT
3322 : { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
3323 :
3324 : // For the internal use we have functions similar to `begin'/`end'
3325 : // but they do not call _M_leak.
3326 : iterator
3327 : _M_ibegin() const _GLIBCXX_NOEXCEPT
3328 : { return iterator(_M_data()); }
3329 :
3330 : iterator
3331 : _M_iend() const _GLIBCXX_NOEXCEPT
3332 : { return iterator(_M_data() + this->size()); }
3333 :
3334 : void
3335 : _M_leak() // for use in begin() & non-const op[]
3336 : {
3337 : if (!_M_rep()->_M_is_leaked())
3338 : _M_leak_hard();
3339 : }
3340 :
3341 : size_type
3342 : _M_check(size_type __pos, const char* __s) const
3343 : {
3344 : if (__pos > this->size())
3345 : __throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > "
3346 : "this->size() (which is %zu)"),
3347 : __s, __pos, this->size());
3348 : return __pos;
3349 : }
3350 :
3351 : void
3352 : _M_check_length(size_type __n1, size_type __n2, const char* __s) const
3353 : {
3354 : if (this->max_size() - (this->size() - __n1) < __n2)
3355 : __throw_length_error(__N(__s));
3356 : }
3357 :
3358 : // NB: _M_limit doesn't check for a bad __pos value.
3359 : size_type
3360 : _M_limit(size_type __pos, size_type __off) const _GLIBCXX_NOEXCEPT
3361 : {
3362 : const bool __testoff = __off < this->size() - __pos;
3363 : return __testoff ? __off : this->size() - __pos;
3364 : }
3365 :
3366 : // True if _Rep and source do not overlap.
3367 : bool
3368 : _M_disjunct(const _CharT* __s) const _GLIBCXX_NOEXCEPT
3369 : {
3370 : return (less<const _CharT*>()(__s, _M_data())
3371 : || less<const _CharT*>()(_M_data() + this->size(), __s));
3372 : }
3373 :
3374 : // When __n = 1 way faster than the general multichar
3375 : // traits_type::copy/move/assign.
3376 : static void
3377 : _M_copy(_CharT* __d, const _CharT* __s, size_type __n) _GLIBCXX_NOEXCEPT
3378 : {
3379 : if (__n == 1)
3380 : traits_type::assign(*__d, *__s);
3381 : else
3382 : traits_type::copy(__d, __s, __n);
3383 : }
3384 :
3385 : static void
3386 : _M_move(_CharT* __d, const _CharT* __s, size_type __n) _GLIBCXX_NOEXCEPT
3387 : {
3388 : if (__n == 1)
3389 : traits_type::assign(*__d, *__s);
3390 : else
3391 : traits_type::move(__d, __s, __n);
3392 : }
3393 :
3394 : static void
3395 : _M_assign(_CharT* __d, size_type __n, _CharT __c) _GLIBCXX_NOEXCEPT
3396 : {
3397 : if (__n == 1)
3398 : traits_type::assign(*__d, __c);
3399 : else
3400 : traits_type::assign(__d, __n, __c);
3401 : }
3402 :
3403 : // _S_copy_chars is a separate template to permit specialization
3404 : // to optimize for the common case of pointers as iterators.
3405 : template<class _Iterator>
3406 : static void
3407 : _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
3408 : {
3409 : for (; __k1 != __k2; ++__k1, (void)++__p)
3410 : traits_type::assign(*__p, *__k1); // These types are off.
3411 : }
3412 :
3413 : static void
3414 : _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) _GLIBCXX_NOEXCEPT
3415 : { _S_copy_chars(__p, __k1.base(), __k2.base()); }
3416 :
3417 : static void
3418 : _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
3419 : _GLIBCXX_NOEXCEPT
3420 : { _S_copy_chars(__p, __k1.base(), __k2.base()); }
3421 :
3422 : static void
3423 : _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) _GLIBCXX_NOEXCEPT
3424 : { _M_copy(__p, __k1, __k2 - __k1); }
3425 :
3426 : static void
3427 : _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
3428 : _GLIBCXX_NOEXCEPT
3429 : { _M_copy(__p, __k1, __k2 - __k1); }
3430 :
3431 : static int
3432 : _S_compare(size_type __n1, size_type __n2) _GLIBCXX_NOEXCEPT
3433 : {
3434 : const difference_type __d = difference_type(__n1 - __n2);
3435 :
3436 : if (__d > __gnu_cxx::__numeric_traits<int>::__max)
3437 : return __gnu_cxx::__numeric_traits<int>::__max;
3438 : else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
3439 : return __gnu_cxx::__numeric_traits<int>::__min;
3440 : else
3441 : return int(__d);
3442 : }
3443 :
3444 : void
3445 : _M_mutate(size_type __pos, size_type __len1, size_type __len2);
3446 :
3447 : void
3448 : _M_leak_hard();
3449 :
3450 : static _Rep&
3451 : _S_empty_rep() _GLIBCXX_NOEXCEPT
3452 : { return _Rep::_S_empty_rep(); }
3453 :
3454 : #if __cplusplus > 201402L
3455 : // A helper type for avoiding boiler-plate.
3456 : typedef basic_string_view<_CharT, _Traits> __sv_type;
3457 :
3458 : template<typename _Tp, typename _Res>
3459 : using _If_sv = enable_if_t<
3460 : __and_<is_convertible<const _Tp&, __sv_type>,
3461 : __not_<is_convertible<const _Tp*, const basic_string*>>,
3462 : __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
3463 : _Res>;
3464 :
3465 : // Allows an implicit conversion to __sv_type.
3466 : static __sv_type
3467 : _S_to_string_view(__sv_type __svt) noexcept
3468 : { return __svt; }
3469 :
3470 : // Wraps a string_view by explicit conversion and thus
3471 : // allows to add an internal constructor that does not
3472 : // participate in overload resolution when a string_view
3473 : // is provided.
3474 : struct __sv_wrapper
3475 : {
3476 : explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }
3477 : __sv_type _M_sv;
3478 : };
3479 : #endif
3480 :
3481 : public:
3482 : // Construct/copy/destroy:
3483 : // NB: We overload ctors in some cases instead of using default
3484 : // arguments, per 17.4.4.4 para. 2 item 2.
3485 :
3486 : /**
3487 : * @brief Default constructor creates an empty string.
3488 : */
3489 : basic_string()
3490 : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3491 : : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
3492 : #else
3493 : : _M_dataplus(_S_construct(size_type(), _CharT(), _Alloc()), _Alloc()){ }
3494 : #endif
3495 :
3496 : /**
3497 : * @brief Construct an empty string using allocator @a a.
3498 : */
3499 : explicit
3500 : basic_string(const _Alloc& __a);
3501 :
3502 : // NB: per LWG issue 42, semantics different from IS:
3503 : /**
3504 : * @brief Construct string with copy of value of @a str.
3505 : * @param __str Source string.
3506 : */
3507 : basic_string(const basic_string& __str);
3508 :
3509 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
3510 : // 2583. no way to supply an allocator for basic_string(str, pos)
3511 : /**
3512 : * @brief Construct string as copy of a substring.
3513 : * @param __str Source string.
3514 : * @param __pos Index of first character to copy from.
3515 : * @param __a Allocator to use.
3516 : */
3517 : basic_string(const basic_string& __str, size_type __pos,
3518 : const _Alloc& __a = _Alloc());
3519 :
3520 : /**
3521 : * @brief Construct string as copy of a substring.
3522 : * @param __str Source string.
3523 : * @param __pos Index of first character to copy from.
3524 : * @param __n Number of characters to copy.
3525 : */
3526 : basic_string(const basic_string& __str, size_type __pos,
3527 : size_type __n);
3528 : /**
3529 : * @brief Construct string as copy of a substring.
3530 : * @param __str Source string.
3531 : * @param __pos Index of first character to copy from.
3532 : * @param __n Number of characters to copy.
3533 : * @param __a Allocator to use.
3534 : */
3535 : basic_string(const basic_string& __str, size_type __pos,
3536 : size_type __n, const _Alloc& __a);
3537 :
3538 : /**
3539 : * @brief Construct string initialized by a character %array.
3540 : * @param __s Source character %array.
3541 : * @param __n Number of characters to copy.
3542 : * @param __a Allocator to use (default is default allocator).
3543 : *
3544 : * NB: @a __s must have at least @a __n characters, '\\0'
3545 : * has no special meaning.
3546 : */
3547 : basic_string(const _CharT* __s, size_type __n,
3548 : const _Alloc& __a = _Alloc());
3549 : /**
3550 : * @brief Construct string as copy of a C string.
3551 : * @param __s Source C string.
3552 : * @param __a Allocator to use (default is default allocator).
3553 : */
3554 : basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
3555 : /**
3556 : * @brief Construct string as multiple characters.
3557 : * @param __n Number of characters.
3558 : * @param __c Character to use.
3559 : * @param __a Allocator to use (default is default allocator).
3560 : */
3561 : basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
3562 :
3563 : #if __cplusplus >= 201103L
3564 : /**
3565 : * @brief Move construct string.
3566 : * @param __str Source string.
3567 : *
3568 : * The newly-created string contains the exact contents of @a __str.
3569 : * @a __str is a valid, but unspecified string.
3570 : **/
3571 : basic_string(basic_string&& __str)
3572 : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3573 : noexcept // FIXME C++11: should always be noexcept.
3574 : #endif
3575 : : _M_dataplus(__str._M_dataplus)
3576 : {
3577 : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3578 : __str._M_data(_S_empty_rep()._M_refdata());
3579 : #else
3580 : __str._M_data(_S_construct(size_type(), _CharT(), get_allocator()));
3581 : #endif
3582 : }
3583 :
3584 : /**
3585 : * @brief Construct string from an initializer %list.
3586 : * @param __l std::initializer_list of characters.
3587 : * @param __a Allocator to use (default is default allocator).
3588 : */
3589 : basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc());
3590 : #endif // C++11
3591 :
3592 : /**
3593 : * @brief Construct string as copy of a range.
3594 : * @param __beg Start of range.
3595 : * @param __end End of range.
3596 : * @param __a Allocator to use (default is default allocator).
3597 : */
3598 : template<class _InputIterator>
3599 : basic_string(_InputIterator __beg, _InputIterator __end,
3600 : const _Alloc& __a = _Alloc());
3601 :
3602 : #if __cplusplus > 201402L
3603 : /**
3604 : * @brief Construct string from a substring of a string_view.
3605 : * @param __t Source object convertible to string view.
3606 : * @param __pos The index of the first character to copy from __t.
3607 : * @param __n The number of characters to copy from __t.
3608 : * @param __a Allocator to use.
3609 : */
3610 : template<typename _Tp, typename = _If_sv<_Tp, void>>
3611 : basic_string(const _Tp& __t, size_type __pos, size_type __n,
3612 : const _Alloc& __a = _Alloc())
3613 : : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }
3614 :
3615 : /**
3616 : * @brief Construct string from a string_view.
3617 : * @param __t Source object convertible to string view.
3618 : * @param __a Allocator to use (default is default allocator).
3619 : */
3620 : template<typename _Tp, typename = _If_sv<_Tp, void>>
3621 : explicit
3622 : basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
3623 : : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }
3624 :
3625 : /**
3626 : * @brief Only internally used: Construct string from a string view
3627 : * wrapper.
3628 : * @param __svw string view wrapper.
3629 : * @param __a Allocator to use.
3630 : */
3631 : explicit
3632 : basic_string(__sv_wrapper __svw, const _Alloc& __a)
3633 : : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }
3634 : #endif // C++17
3635 :
3636 : /**
3637 : * @brief Destroy the string instance.
3638 : */
3639 : ~basic_string() _GLIBCXX_NOEXCEPT
3640 : { _M_rep()->_M_dispose(this->get_allocator()); }
3641 :
3642 : /**
3643 : * @brief Assign the value of @a str to this string.
3644 : * @param __str Source string.
3645 : */
3646 : basic_string&
3647 : operator=(const basic_string& __str)
3648 : { return this->assign(__str); }
3649 :
3650 : /**
3651 : * @brief Copy contents of @a s into this string.
3652 : * @param __s Source null-terminated string.
3653 : */
3654 : basic_string&
3655 : operator=(const _CharT* __s)
3656 : { return this->assign(__s); }
3657 :
3658 : /**
3659 : * @brief Set value to string of length 1.
3660 : * @param __c Source character.
3661 : *
3662 : * Assigning to a character makes this string length 1 and
3663 : * (*this)[0] == @a c.
3664 : */
3665 : basic_string&
3666 : operator=(_CharT __c)
3667 : {
3668 : this->assign(1, __c);
3669 : return *this;
3670 : }
3671 :
3672 : #if __cplusplus >= 201103L
3673 : /**
3674 : * @brief Move assign the value of @a str to this string.
3675 : * @param __str Source string.
3676 : *
3677 : * The contents of @a str are moved into this string (without copying).
3678 : * @a str is a valid, but unspecified string.
3679 : **/
3680 : // PR 58265, this should be noexcept.
3681 : basic_string&
3682 : operator=(basic_string&& __str)
3683 : {
3684 : // NB: DR 1204.
3685 : this->swap(__str);
3686 : return *this;
3687 : }
3688 :
3689 : /**
3690 : * @brief Set value to string constructed from initializer %list.
3691 : * @param __l std::initializer_list.
3692 : */
3693 : basic_string&
3694 : operator=(initializer_list<_CharT> __l)
3695 : {
3696 : this->assign(__l.begin(), __l.size());
3697 : return *this;
3698 : }
3699 : #endif // C++11
3700 :
3701 : #if __cplusplus > 201402L
3702 : /**
3703 : * @brief Set value to string constructed from a string_view.
3704 : * @param __svt An object convertible to string_view.
3705 : */
3706 : template<typename _Tp>
3707 : _If_sv<_Tp, basic_string&>
3708 : operator=(const _Tp& __svt)
3709 : { return this->assign(__svt); }
3710 :
3711 : /**
3712 : * @brief Convert to a string_view.
3713 : * @return A string_view.
3714 : */
3715 : operator __sv_type() const noexcept
3716 : { return __sv_type(data(), size()); }
3717 : #endif // C++17
3718 :
3719 : // Iterators:
3720 : /**
3721 : * Returns a read/write iterator that points to the first character in
3722 : * the %string. Unshares the string.
3723 : */
3724 : iterator
3725 : begin() // FIXME C++11: should be noexcept.
3726 : {
3727 : _M_leak();
3728 : return iterator(_M_data());
3729 : }
3730 :
3731 : /**
3732 : * Returns a read-only (constant) iterator that points to the first
3733 : * character in the %string.
3734 : */
3735 : const_iterator
3736 : begin() const _GLIBCXX_NOEXCEPT
3737 : { return const_iterator(_M_data()); }
3738 :
3739 : /**
3740 : * Returns a read/write iterator that points one past the last
3741 : * character in the %string. Unshares the string.
3742 : */
3743 : iterator
3744 : end() // FIXME C++11: should be noexcept.
3745 : {
3746 : _M_leak();
3747 : return iterator(_M_data() + this->size());
3748 : }
3749 :
3750 : /**
3751 : * Returns a read-only (constant) iterator that points one past the
3752 : * last character in the %string.
3753 : */
3754 : const_iterator
3755 : end() const _GLIBCXX_NOEXCEPT
3756 : { return const_iterator(_M_data() + this->size()); }
3757 :
3758 : /**
3759 : * Returns a read/write reverse iterator that points to the last
3760 : * character in the %string. Iteration is done in reverse element
3761 : * order. Unshares the string.
3762 : */
3763 : reverse_iterator
3764 : rbegin() // FIXME C++11: should be noexcept.
3765 : { return reverse_iterator(this->end()); }
3766 :
3767 : /**
3768 : * Returns a read-only (constant) reverse iterator that points
3769 : * to the last character in the %string. Iteration is done in
3770 : * reverse element order.
3771 : */
3772 : const_reverse_iterator
3773 : rbegin() const _GLIBCXX_NOEXCEPT
3774 : { return const_reverse_iterator(this->end()); }
3775 :
3776 : /**
3777 : * Returns a read/write reverse iterator that points to one before the
3778 : * first character in the %string. Iteration is done in reverse
3779 : * element order. Unshares the string.
3780 : */
3781 : reverse_iterator
3782 : rend() // FIXME C++11: should be noexcept.
3783 : { return reverse_iterator(this->begin()); }
3784 :
3785 : /**
3786 : * Returns a read-only (constant) reverse iterator that points
3787 : * to one before the first character in the %string. Iteration
3788 : * is done in reverse element order.
3789 : */
3790 : const_reverse_iterator
3791 : rend() const _GLIBCXX_NOEXCEPT
3792 : { return const_reverse_iterator(this->begin()); }
3793 :
3794 : #if __cplusplus >= 201103L
3795 : /**
3796 : * Returns a read-only (constant) iterator that points to the first
3797 : * character in the %string.
3798 : */
3799 : const_iterator
3800 : cbegin() const noexcept
3801 : { return const_iterator(this->_M_data()); }
3802 :
3803 : /**
3804 : * Returns a read-only (constant) iterator that points one past the
3805 : * last character in the %string.
3806 : */
3807 : const_iterator
3808 : cend() const noexcept
3809 : { return const_iterator(this->_M_data() + this->size()); }
3810 :
3811 : /**
3812 : * Returns a read-only (constant) reverse iterator that points
3813 : * to the last character in the %string. Iteration is done in
3814 : * reverse element order.
3815 : */
3816 : const_reverse_iterator
3817 : crbegin() const noexcept
3818 : { return const_reverse_iterator(this->end()); }
3819 :
3820 : /**
3821 : * Returns a read-only (constant) reverse iterator that points
3822 : * to one before the first character in the %string. Iteration
3823 : * is done in reverse element order.
3824 : */
3825 : const_reverse_iterator
3826 : crend() const noexcept
3827 : { return const_reverse_iterator(this->begin()); }
3828 : #endif
3829 :
3830 : public:
3831 : // Capacity:
3832 : /// Returns the number of characters in the string, not including any
3833 : /// null-termination.
3834 : size_type
3835 : size() const _GLIBCXX_NOEXCEPT
3836 : { return _M_rep()->_M_length; }
3837 :
3838 : /// Returns the number of characters in the string, not including any
3839 : /// null-termination.
3840 : size_type
3841 : length() const _GLIBCXX_NOEXCEPT
3842 : { return _M_rep()->_M_length; }
3843 :
3844 : /// Returns the size() of the largest possible %string.
3845 : size_type
3846 : max_size() const _GLIBCXX_NOEXCEPT
3847 : { return _Rep::_S_max_size; }
3848 :
3849 : /**
3850 : * @brief Resizes the %string to the specified number of characters.
3851 : * @param __n Number of characters the %string should contain.
3852 : * @param __c Character to fill any new elements.
3853 : *
3854 : * This function will %resize the %string to the specified
3855 : * number of characters. If the number is smaller than the
3856 : * %string's current size the %string is truncated, otherwise
3857 : * the %string is extended and new elements are %set to @a __c.
3858 : */
3859 : void
3860 : resize(size_type __n, _CharT __c);
3861 :
3862 : /**
3863 : * @brief Resizes the %string to the specified number of characters.
3864 : * @param __n Number of characters the %string should contain.
3865 : *
3866 : * This function will resize the %string to the specified length. If
3867 : * the new size is smaller than the %string's current size the %string
3868 : * is truncated, otherwise the %string is extended and new characters
3869 : * are default-constructed. For basic types such as char, this means
3870 : * setting them to 0.
3871 : */
3872 : void
3873 : resize(size_type __n)
3874 : { this->resize(__n, _CharT()); }
3875 :
3876 : #if __cplusplus >= 201103L
3877 : /// A non-binding request to reduce capacity() to size().
3878 : void
3879 : shrink_to_fit() _GLIBCXX_NOEXCEPT
3880 : {
3881 : #if __cpp_exceptions
3882 : if (capacity() > size())
3883 : {
3884 : try
3885 : { reserve(0); }
3886 : catch(...)
3887 : { }
3888 : }
3889 : #endif
3890 : }
3891 : #endif
3892 :
3893 : /**
3894 : * Returns the total number of characters that the %string can hold
3895 : * before needing to allocate more memory.
3896 : */
3897 : size_type
3898 : capacity() const _GLIBCXX_NOEXCEPT
3899 : { return _M_rep()->_M_capacity; }
3900 :
3901 : /**
3902 : * @brief Attempt to preallocate enough memory for specified number of
3903 : * characters.
3904 : * @param __res_arg Number of characters required.
3905 : * @throw std::length_error If @a __res_arg exceeds @c max_size().
3906 : *
3907 : * This function attempts to reserve enough memory for the
3908 : * %string to hold the specified number of characters. If the
3909 : * number requested is more than max_size(), length_error is
3910 : * thrown.
3911 : *
3912 : * The advantage of this function is that if optimal code is a
3913 : * necessity and the user can determine the string length that will be
3914 : * required, the user can reserve the memory in %advance, and thus
3915 : * prevent a possible reallocation of memory and copying of %string
3916 : * data.
3917 : */
3918 : void
3919 : reserve(size_type __res_arg = 0);
3920 :
3921 : /**
3922 : * Erases the string, making it empty.
3923 : */
3924 : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
3925 : void
3926 : clear() _GLIBCXX_NOEXCEPT
3927 : {
3928 : if (_M_rep()->_M_is_shared())
3929 : {
3930 : _M_rep()->_M_dispose(this->get_allocator());
3931 : _M_data(_S_empty_rep()._M_refdata());
3932 : }
3933 : else
3934 : _M_rep()->_M_set_length_and_sharable(0);
3935 : }
3936 : #else
3937 : // PR 56166: this should not throw.
3938 : void
3939 : clear()
3940 : { _M_mutate(0, this->size(), 0); }
3941 : #endif
3942 :
3943 : /**
3944 : * Returns true if the %string is empty. Equivalent to
3945 : * <code>*this == ""</code>.
3946 : */
3947 : bool
3948 : empty() const _GLIBCXX_NOEXCEPT
3949 : { return this->size() == 0; }
3950 :
3951 : // Element access:
3952 : /**
3953 : * @brief Subscript access to the data contained in the %string.
3954 : * @param __pos The index of the character to access.
3955 : * @return Read-only (constant) reference to the character.
3956 : *
3957 : * This operator allows for easy, array-style, data access.
3958 : * Note that data access with this operator is unchecked and
3959 : * out_of_range lookups are not defined. (For checked lookups
3960 : * see at().)
3961 : */
3962 : const_reference
3963 : operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
3964 : {
3965 : __glibcxx_assert(__pos <= size());
3966 : return _M_data()[__pos];
3967 : }
3968 :
3969 : /**
3970 : * @brief Subscript access to the data contained in the %string.
3971 : * @param __pos The index of the character to access.
3972 : * @return Read/write reference to the character.
3973 : *
3974 : * This operator allows for easy, array-style, data access.
3975 : * Note that data access with this operator is unchecked and
3976 : * out_of_range lookups are not defined. (For checked lookups
3977 : * see at().) Unshares the string.
3978 : */
3979 : reference
3980 : operator[](size_type __pos)
3981 : {
3982 : // Allow pos == size() both in C++98 mode, as v3 extension,
3983 : // and in C++11 mode.
3984 : __glibcxx_assert(__pos <= size());
3985 : // In pedantic mode be strict in C++98 mode.
3986 : _GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L || __pos < size());
3987 : _M_leak();
3988 : return _M_data()[__pos];
3989 : }
3990 :
3991 : /**
3992 : * @brief Provides access to the data contained in the %string.
3993 : * @param __n The index of the character to access.
3994 : * @return Read-only (const) reference to the character.
3995 : * @throw std::out_of_range If @a n is an invalid index.
3996 : *
3997 : * This function provides for safer data access. The parameter is
3998 : * first checked that it is in the range of the string. The function
3999 : * throws out_of_range if the check fails.
4000 : */
4001 : const_reference
4002 : at(size_type __n) const
4003 : {
4004 : if (__n >= this->size())
4005 : __throw_out_of_range_fmt(__N("basic_string::at: __n "
4006 : "(which is %zu) >= this->size() "
4007 : "(which is %zu)"),
4008 : __n, this->size());
4009 : return _M_data()[__n];
4010 : }
4011 :
4012 : /**
4013 : * @brief Provides access to the data contained in the %string.
4014 : * @param __n The index of the character to access.
4015 : * @return Read/write reference to the character.
4016 : * @throw std::out_of_range If @a n is an invalid index.
4017 : *
4018 : * This function provides for safer data access. The parameter is
4019 : * first checked that it is in the range of the string. The function
4020 : * throws out_of_range if the check fails. Success results in
4021 : * unsharing the string.
4022 : */
4023 : reference
4024 : at(size_type __n)
4025 : {
4026 : if (__n >= size())
4027 : __throw_out_of_range_fmt(__N("basic_string::at: __n "
4028 : "(which is %zu) >= this->size() "
4029 : "(which is %zu)"),
4030 : __n, this->size());
4031 : _M_leak();
4032 : return _M_data()[__n];
4033 : }
4034 :
4035 : #if __cplusplus >= 201103L
4036 : /**
4037 : * Returns a read/write reference to the data at the first
4038 : * element of the %string.
4039 : */
4040 : reference
4041 : front()
4042 : {
4043 : __glibcxx_assert(!empty());
4044 : return operator[](0);
4045 : }
4046 :
4047 : /**
4048 : * Returns a read-only (constant) reference to the data at the first
4049 : * element of the %string.
4050 : */
4051 : const_reference
4052 : front() const noexcept
4053 : {
4054 : __glibcxx_assert(!empty());
4055 : return operator[](0);
4056 : }
4057 :
4058 : /**
4059 : * Returns a read/write reference to the data at the last
4060 : * element of the %string.
4061 : */
4062 : reference
4063 : back()
4064 : {
4065 : __glibcxx_assert(!empty());
4066 : return operator[](this->size() - 1);
4067 : }
4068 :
4069 : /**
4070 : * Returns a read-only (constant) reference to the data at the
4071 : * last element of the %string.
4072 : */
4073 : const_reference
4074 : back() const noexcept
4075 : {
4076 : __glibcxx_assert(!empty());
4077 : return operator[](this->size() - 1);
4078 : }
4079 : #endif
4080 :
4081 : // Modifiers:
4082 : /**
4083 : * @brief Append a string to this string.
4084 : * @param __str The string to append.
4085 : * @return Reference to this string.
4086 : */
4087 : basic_string&
4088 : operator+=(const basic_string& __str)
4089 : { return this->append(__str); }
4090 :
4091 : /**
4092 : * @brief Append a C string.
4093 : * @param __s The C string to append.
4094 : * @return Reference to this string.
4095 : */
4096 : basic_string&
4097 : operator+=(const _CharT* __s)
4098 : { return this->append(__s); }
4099 :
4100 : /**
4101 : * @brief Append a character.
4102 : * @param __c The character to append.
4103 : * @return Reference to this string.
4104 : */
4105 : basic_string&
4106 : operator+=(_CharT __c)
4107 : {
4108 : this->push_back(__c);
4109 : return *this;
4110 : }
4111 :
4112 : #if __cplusplus >= 201103L
4113 : /**
4114 : * @brief Append an initializer_list of characters.
4115 : * @param __l The initializer_list of characters to be appended.
4116 : * @return Reference to this string.
4117 : */
4118 : basic_string&
4119 : operator+=(initializer_list<_CharT> __l)
4120 : { return this->append(__l.begin(), __l.size()); }
4121 : #endif // C++11
4122 :
4123 : #if __cplusplus > 201402L
4124 : /**
4125 : * @brief Append a string_view.
4126 : * @param __svt The object convertible to string_view to be appended.
4127 : * @return Reference to this string.
4128 : */
4129 : template<typename _Tp>
4130 : _If_sv<_Tp, basic_string&>
4131 : operator+=(const _Tp& __svt)
4132 : { return this->append(__svt); }
4133 : #endif // C++17
4134 :
4135 : /**
4136 : * @brief Append a string to this string.
4137 : * @param __str The string to append.
4138 : * @return Reference to this string.
4139 : */
4140 : basic_string&
4141 : append(const basic_string& __str);
4142 :
4143 : /**
4144 : * @brief Append a substring.
4145 : * @param __str The string to append.
4146 : * @param __pos Index of the first character of str to append.
4147 : * @param __n The number of characters to append.
4148 : * @return Reference to this string.
4149 : * @throw std::out_of_range if @a __pos is not a valid index.
4150 : *
4151 : * This function appends @a __n characters from @a __str
4152 : * starting at @a __pos to this string. If @a __n is is larger
4153 : * than the number of available characters in @a __str, the
4154 : * remainder of @a __str is appended.
4155 : */
4156 : basic_string&
4157 : append(const basic_string& __str, size_type __pos, size_type __n = npos);
4158 :
4159 : /**
4160 : * @brief Append a C substring.
4161 : * @param __s The C string to append.
4162 : * @param __n The number of characters to append.
4163 : * @return Reference to this string.
4164 : */
4165 : basic_string&
4166 : append(const _CharT* __s, size_type __n);
4167 :
4168 : /**
4169 : * @brief Append a C string.
4170 : * @param __s The C string to append.
4171 : * @return Reference to this string.
4172 : */
4173 : basic_string&
4174 : append(const _CharT* __s)
4175 : {
4176 : __glibcxx_requires_string(__s);
4177 : return this->append(__s, traits_type::length(__s));
4178 : }
4179 :
4180 : /**
4181 : * @brief Append multiple characters.
4182 : * @param __n The number of characters to append.
4183 : * @param __c The character to use.
4184 : * @return Reference to this string.
4185 : *
4186 : * Appends __n copies of __c to this string.
4187 : */
4188 : basic_string&
4189 : append(size_type __n, _CharT __c);
4190 :
4191 : #if __cplusplus >= 201103L
4192 : /**
4193 : * @brief Append an initializer_list of characters.
4194 : * @param __l The initializer_list of characters to append.
4195 : * @return Reference to this string.
4196 : */
4197 : basic_string&
4198 : append(initializer_list<_CharT> __l)
4199 : { return this->append(__l.begin(), __l.size()); }
4200 : #endif // C++11
4201 :
4202 : /**
4203 : * @brief Append a range of characters.
4204 : * @param __first Iterator referencing the first character to append.
4205 : * @param __last Iterator marking the end of the range.
4206 : * @return Reference to this string.
4207 : *
4208 : * Appends characters in the range [__first,__last) to this string.
4209 : */
4210 : template<class _InputIterator>
4211 : basic_string&
4212 : append(_InputIterator __first, _InputIterator __last)
4213 : { return this->replace(_M_iend(), _M_iend(), __first, __last); }
4214 :
4215 : #if __cplusplus > 201402L
4216 : /**
4217 : * @brief Append a string_view.
4218 : * @param __svt The object convertible to string_view to be appended.
4219 : * @return Reference to this string.
4220 : */
4221 : template<typename _Tp>
4222 : _If_sv<_Tp, basic_string&>
4223 : append(const _Tp& __svt)
4224 : {
4225 : __sv_type __sv = __svt;
4226 : return this->append(__sv.data(), __sv.size());
4227 : }
4228 :
4229 : /**
4230 : * @brief Append a range of characters from a string_view.
4231 : * @param __svt The object convertible to string_view to be appended
4232 : * from.
4233 : * @param __pos The position in the string_view to append from.
4234 : * @param __n The number of characters to append from the string_view.
4235 : * @return Reference to this string.
4236 : */
4237 : template<typename _Tp>
4238 : _If_sv<_Tp, basic_string&>
4239 : append(const _Tp& __svt, size_type __pos, size_type __n = npos)
4240 : {
4241 : __sv_type __sv = __svt;
4242 : return append(__sv.data()
4243 : + __sv._M_check(__pos, "basic_string::append"),
4244 : __sv._M_limit(__pos, __n));
4245 : }
4246 : #endif // C++17
4247 :
4248 : /**
4249 : * @brief Append a single character.
4250 : * @param __c Character to append.
4251 : */
4252 : void
4253 : push_back(_CharT __c)
4254 : {
4255 : const size_type __len = 1 + this->size();
4256 : if (__len > this->capacity() || _M_rep()->_M_is_shared())
4257 : this->reserve(__len);
4258 : traits_type::assign(_M_data()[this->size()], __c);
4259 : _M_rep()->_M_set_length_and_sharable(__len);
4260 : }
4261 :
4262 : /**
4263 : * @brief Set value to contents of another string.
4264 : * @param __str Source string to use.
4265 : * @return Reference to this string.
4266 : */
4267 : basic_string&
4268 : assign(const basic_string& __str);
4269 :
4270 : #if __cplusplus >= 201103L
4271 : /**
4272 : * @brief Set value to contents of another string.
4273 : * @param __str Source string to use.
4274 : * @return Reference to this string.
4275 : *
4276 : * This function sets this string to the exact contents of @a __str.
4277 : * @a __str is a valid, but unspecified string.
4278 : */
4279 : // PR 58265, this should be noexcept.
4280 : basic_string&
4281 : assign(basic_string&& __str)
4282 : {
4283 : this->swap(__str);
4284 : return *this;
4285 : }
4286 : #endif // C++11
4287 :
4288 : /**
4289 : * @brief Set value to a substring of a string.
4290 : * @param __str The string to use.
4291 : * @param __pos Index of the first character of str.
4292 : * @param __n Number of characters to use.
4293 : * @return Reference to this string.
4294 : * @throw std::out_of_range if @a pos is not a valid index.
4295 : *
4296 : * This function sets this string to the substring of @a __str
4297 : * consisting of @a __n characters at @a __pos. If @a __n is
4298 : * is larger than the number of available characters in @a
4299 : * __str, the remainder of @a __str is used.
4300 : */
4301 : basic_string&
4302 : assign(const basic_string& __str, size_type __pos, size_type __n = npos)
4303 : { return this->assign(__str._M_data()
4304 : + __str._M_check(__pos, "basic_string::assign"),
4305 : __str._M_limit(__pos, __n)); }
4306 :
4307 : /**
4308 : * @brief Set value to a C substring.
4309 : * @param __s The C string to use.
4310 : * @param __n Number of characters to use.
4311 : * @return Reference to this string.
4312 : *
4313 : * This function sets the value of this string to the first @a __n
4314 : * characters of @a __s. If @a __n is is larger than the number of
4315 : * available characters in @a __s, the remainder of @a __s is used.
4316 : */
4317 : basic_string&
4318 : assign(const _CharT* __s, size_type __n);
4319 :
4320 : /**
4321 : * @brief Set value to contents of a C string.
4322 : * @param __s The C string to use.
4323 : * @return Reference to this string.
4324 : *
4325 : * This function sets the value of this string to the value of @a __s.
4326 : * The data is copied, so there is no dependence on @a __s once the
4327 : * function returns.
4328 : */
4329 : basic_string&
4330 : assign(const _CharT* __s)
4331 : {
4332 : __glibcxx_requires_string(__s);
4333 : return this->assign(__s, traits_type::length(__s));
4334 : }
4335 :
4336 : /**
4337 : * @brief Set value to multiple characters.
4338 : * @param __n Length of the resulting string.
4339 : * @param __c The character to use.
4340 : * @return Reference to this string.
4341 : *
4342 : * This function sets the value of this string to @a __n copies of
4343 : * character @a __c.
4344 : */
4345 : basic_string&
4346 : assign(size_type __n, _CharT __c)
4347 : { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
4348 :
4349 : /**
4350 : * @brief Set value to a range of characters.
4351 : * @param __first Iterator referencing the first character to append.
4352 : * @param __last Iterator marking the end of the range.
4353 : * @return Reference to this string.
4354 : *
4355 : * Sets value of string to characters in the range [__first,__last).
4356 : */
4357 : template<class _InputIterator>
4358 : basic_string&
4359 : assign(_InputIterator __first, _InputIterator __last)
4360 : { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
4361 :
4362 : #if __cplusplus >= 201103L
4363 : /**
4364 : * @brief Set value to an initializer_list of characters.
4365 : * @param __l The initializer_list of characters to assign.
4366 : * @return Reference to this string.
4367 : */
4368 : basic_string&
4369 : assign(initializer_list<_CharT> __l)
4370 : { return this->assign(__l.begin(), __l.size()); }
4371 : #endif // C++11
4372 :
4373 : #if __cplusplus > 201402L
4374 : /**
4375 : * @brief Set value from a string_view.
4376 : * @param __svt The source object convertible to string_view.
4377 : * @return Reference to this string.
4378 : */
4379 : template<typename _Tp>
4380 : _If_sv<_Tp, basic_string&>
4381 : assign(const _Tp& __svt)
4382 : {
4383 : __sv_type __sv = __svt;
4384 : return this->assign(__sv.data(), __sv.size());
4385 : }
4386 :
4387 : /**
4388 : * @brief Set value from a range of characters in a string_view.
4389 : * @param __svt The source object convertible to string_view.
4390 : * @param __pos The position in the string_view to assign from.
4391 : * @param __n The number of characters to assign.
4392 : * @return Reference to this string.
4393 : */
4394 : template<typename _Tp>
4395 : _If_sv<_Tp, basic_string&>
4396 : assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
4397 : {
4398 : __sv_type __sv = __svt;
4399 : return assign(__sv.data()
4400 : + __sv._M_check(__pos, "basic_string::assign"),
4401 : __sv._M_limit(__pos, __n));
4402 : }
4403 : #endif // C++17
4404 :
4405 : /**
4406 : * @brief Insert multiple characters.
4407 : * @param __p Iterator referencing location in string to insert at.
4408 : * @param __n Number of characters to insert
4409 : * @param __c The character to insert.
4410 : * @throw std::length_error If new length exceeds @c max_size().
4411 : *
4412 : * Inserts @a __n copies of character @a __c starting at the
4413 : * position referenced by iterator @a __p. If adding
4414 : * characters causes the length to exceed max_size(),
4415 : * length_error is thrown. The value of the string doesn't
4416 : * change if an error is thrown.
4417 : */
4418 : void
4419 : insert(iterator __p, size_type __n, _CharT __c)
4420 : { this->replace(__p, __p, __n, __c); }
4421 :
4422 : /**
4423 : * @brief Insert a range of characters.
4424 : * @param __p Iterator referencing location in string to insert at.
4425 : * @param __beg Start of range.
4426 : * @param __end End of range.
4427 : * @throw std::length_error If new length exceeds @c max_size().
4428 : *
4429 : * Inserts characters in range [__beg,__end). If adding
4430 : * characters causes the length to exceed max_size(),
4431 : * length_error is thrown. The value of the string doesn't
4432 : * change if an error is thrown.
4433 : */
4434 : template<class _InputIterator>
4435 : void
4436 : insert(iterator __p, _InputIterator __beg, _InputIterator __end)
4437 : { this->replace(__p, __p, __beg, __end); }
4438 :
4439 : #if __cplusplus >= 201103L
4440 : /**
4441 : * @brief Insert an initializer_list of characters.
4442 : * @param __p Iterator referencing location in string to insert at.
4443 : * @param __l The initializer_list of characters to insert.
4444 : * @throw std::length_error If new length exceeds @c max_size().
4445 : */
4446 : void
4447 : insert(iterator __p, initializer_list<_CharT> __l)
4448 : {
4449 : _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
4450 : this->insert(__p - _M_ibegin(), __l.begin(), __l.size());
4451 : }
4452 : #endif // C++11
4453 :
4454 : /**
4455 : * @brief Insert value of a string.
4456 : * @param __pos1 Iterator referencing location in string to insert at.
4457 : * @param __str The string to insert.
4458 : * @return Reference to this string.
4459 : * @throw std::length_error If new length exceeds @c max_size().
4460 : *
4461 : * Inserts value of @a __str starting at @a __pos1. If adding
4462 : * characters causes the length to exceed max_size(),
4463 : * length_error is thrown. The value of the string doesn't
4464 : * change if an error is thrown.
4465 : */
4466 : basic_string&
4467 : insert(size_type __pos1, const basic_string& __str)
4468 : { return this->insert(__pos1, __str, size_type(0), __str.size()); }
4469 :
4470 : /**
4471 : * @brief Insert a substring.
4472 : * @param __pos1 Iterator referencing location in string to insert at.
4473 : * @param __str The string to insert.
4474 : * @param __pos2 Start of characters in str to insert.
4475 : * @param __n Number of characters to insert.
4476 : * @return Reference to this string.
4477 : * @throw std::length_error If new length exceeds @c max_size().
4478 : * @throw std::out_of_range If @a pos1 > size() or
4479 : * @a __pos2 > @a str.size().
4480 : *
4481 : * Starting at @a pos1, insert @a __n character of @a __str
4482 : * beginning with @a __pos2. If adding characters causes the
4483 : * length to exceed max_size(), length_error is thrown. If @a
4484 : * __pos1 is beyond the end of this string or @a __pos2 is
4485 : * beyond the end of @a __str, out_of_range is thrown. The
4486 : * value of the string doesn't change if an error is thrown.
4487 : */
4488 : basic_string&
4489 : insert(size_type __pos1, const basic_string& __str,
4490 : size_type __pos2, size_type __n = npos)
4491 : { return this->insert(__pos1, __str._M_data()
4492 : + __str._M_check(__pos2, "basic_string::insert"),
4493 : __str._M_limit(__pos2, __n)); }
4494 :
4495 : /**
4496 : * @brief Insert a C substring.
4497 : * @param __pos Iterator referencing location in string to insert at.
4498 : * @param __s The C string to insert.
4499 : * @param __n The number of characters to insert.
4500 : * @return Reference to this string.
4501 : * @throw std::length_error If new length exceeds @c max_size().
4502 : * @throw std::out_of_range If @a __pos is beyond the end of this
4503 : * string.
4504 : *
4505 : * Inserts the first @a __n characters of @a __s starting at @a
4506 : * __pos. If adding characters causes the length to exceed
4507 : * max_size(), length_error is thrown. If @a __pos is beyond
4508 : * end(), out_of_range is thrown. The value of the string
4509 : * doesn't change if an error is thrown.
4510 : */
4511 : basic_string&
4512 : insert(size_type __pos, const _CharT* __s, size_type __n);
4513 :
4514 : /**
4515 : * @brief Insert a C string.
4516 : * @param __pos Iterator referencing location in string to insert at.
4517 : * @param __s The C string to insert.
4518 : * @return Reference to this string.
4519 : * @throw std::length_error If new length exceeds @c max_size().
4520 : * @throw std::out_of_range If @a pos is beyond the end of this
4521 : * string.
4522 : *
4523 : * Inserts the first @a n characters of @a __s starting at @a __pos. If
4524 : * adding characters causes the length to exceed max_size(),
4525 : * length_error is thrown. If @a __pos is beyond end(), out_of_range is
4526 : * thrown. The value of the string doesn't change if an error is
4527 : * thrown.
4528 : */
4529 : basic_string&
4530 : insert(size_type __pos, const _CharT* __s)
4531 : {
4532 : __glibcxx_requires_string(__s);
4533 : return this->insert(__pos, __s, traits_type::length(__s));
4534 : }
4535 :
4536 : /**
4537 : * @brief Insert multiple characters.
4538 : * @param __pos Index in string to insert at.
4539 : * @param __n Number of characters to insert
4540 : * @param __c The character to insert.
4541 : * @return Reference to this string.
4542 : * @throw std::length_error If new length exceeds @c max_size().
4543 : * @throw std::out_of_range If @a __pos is beyond the end of this
4544 : * string.
4545 : *
4546 : * Inserts @a __n copies of character @a __c starting at index
4547 : * @a __pos. If adding characters causes the length to exceed
4548 : * max_size(), length_error is thrown. If @a __pos > length(),
4549 : * out_of_range is thrown. The value of the string doesn't
4550 : * change if an error is thrown.
4551 : */
4552 : basic_string&
4553 : insert(size_type __pos, size_type __n, _CharT __c)
4554 : { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
4555 : size_type(0), __n, __c); }
4556 :
4557 : /**
4558 : * @brief Insert one character.
4559 : * @param __p Iterator referencing position in string to insert at.
4560 : * @param __c The character to insert.
4561 : * @return Iterator referencing newly inserted char.
4562 : * @throw std::length_error If new length exceeds @c max_size().
4563 : *
4564 : * Inserts character @a __c at position referenced by @a __p.
4565 : * If adding character causes the length to exceed max_size(),
4566 : * length_error is thrown. If @a __p is beyond end of string,
4567 : * out_of_range is thrown. The value of the string doesn't
4568 : * change if an error is thrown.
4569 : */
4570 : iterator
4571 : insert(iterator __p, _CharT __c)
4572 : {
4573 : _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
4574 : const size_type __pos = __p - _M_ibegin();
4575 : _M_replace_aux(__pos, size_type(0), size_type(1), __c);
4576 : _M_rep()->_M_set_leaked();
4577 : return iterator(_M_data() + __pos);
4578 : }
4579 :
4580 : #if __cplusplus > 201402L
4581 : /**
4582 : * @brief Insert a string_view.
4583 : * @param __pos Iterator referencing position in string to insert at.
4584 : * @param __svt The object convertible to string_view to insert.
4585 : * @return Reference to this string.
4586 : */
4587 : template<typename _Tp>
4588 : _If_sv<_Tp, basic_string&>
4589 : insert(size_type __pos, const _Tp& __svt)
4590 : {
4591 : __sv_type __sv = __svt;
4592 : return this->insert(__pos, __sv.data(), __sv.size());
4593 : }
4594 :
4595 : /**
4596 : * @brief Insert a string_view.
4597 : * @param __pos Iterator referencing position in string to insert at.
4598 : * @param __svt The object convertible to string_view to insert from.
4599 : * @param __pos Iterator referencing position in string_view to insert
4600 : * from.
4601 : * @param __n The number of characters to insert.
4602 : * @return Reference to this string.
4603 : */
4604 : template<typename _Tp>
4605 : _If_sv<_Tp, basic_string&>
4606 : insert(size_type __pos1, const _Tp& __svt,
4607 : size_type __pos2, size_type __n = npos)
4608 : {
4609 : __sv_type __sv = __svt;
4610 : return this->replace(__pos1, size_type(0), __sv.data()
4611 : + __sv._M_check(__pos2, "basic_string::insert"),
4612 : __sv._M_limit(__pos2, __n));
4613 : }
4614 : #endif // C++17
4615 :
4616 : /**
4617 : * @brief Remove characters.
4618 : * @param __pos Index of first character to remove (default 0).
4619 : * @param __n Number of characters to remove (default remainder).
4620 : * @return Reference to this string.
4621 : * @throw std::out_of_range If @a pos is beyond the end of this
4622 : * string.
4623 : *
4624 : * Removes @a __n characters from this string starting at @a
4625 : * __pos. The length of the string is reduced by @a __n. If
4626 : * there are < @a __n characters to remove, the remainder of
4627 : * the string is truncated. If @a __p is beyond end of string,
4628 : * out_of_range is thrown. The value of the string doesn't
4629 : * change if an error is thrown.
4630 : */
4631 : basic_string&
4632 : erase(size_type __pos = 0, size_type __n = npos)
4633 : {
4634 : _M_mutate(_M_check(__pos, "basic_string::erase"),
4635 : _M_limit(__pos, __n), size_type(0));
4636 : return *this;
4637 : }
4638 :
4639 : /**
4640 : * @brief Remove one character.
4641 : * @param __position Iterator referencing the character to remove.
4642 : * @return iterator referencing same location after removal.
4643 : *
4644 : * Removes the character at @a __position from this string. The value
4645 : * of the string doesn't change if an error is thrown.
4646 : */
4647 : iterator
4648 : erase(iterator __position)
4649 : {
4650 : _GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin()
4651 : && __position < _M_iend());
4652 : const size_type __pos = __position - _M_ibegin();
4653 : _M_mutate(__pos, size_type(1), size_type(0));
4654 : _M_rep()->_M_set_leaked();
4655 : return iterator(_M_data() + __pos);
4656 : }
4657 :
4658 : /**
4659 : * @brief Remove a range of characters.
4660 : * @param __first Iterator referencing the first character to remove.
4661 : * @param __last Iterator referencing the end of the range.
4662 : * @return Iterator referencing location of first after removal.
4663 : *
4664 : * Removes the characters in the range [first,last) from this string.
4665 : * The value of the string doesn't change if an error is thrown.
4666 : */
4667 : iterator
4668 : erase(iterator __first, iterator __last);
4669 :
4670 : #if __cplusplus >= 201103L
4671 : /**
4672 : * @brief Remove the last character.
4673 : *
4674 : * The string must be non-empty.
4675 : */
4676 : void
4677 : pop_back() // FIXME C++11: should be noexcept.
4678 : {
4679 : __glibcxx_assert(!empty());
4680 : erase(size() - 1, 1);
4681 : }
4682 : #endif // C++11
4683 :
4684 : /**
4685 : * @brief Replace characters with value from another string.
4686 : * @param __pos Index of first character to replace.
4687 : * @param __n Number of characters to be replaced.
4688 : * @param __str String to insert.
4689 : * @return Reference to this string.
4690 : * @throw std::out_of_range If @a pos is beyond the end of this
4691 : * string.
4692 : * @throw std::length_error If new length exceeds @c max_size().
4693 : *
4694 : * Removes the characters in the range [__pos,__pos+__n) from
4695 : * this string. In place, the value of @a __str is inserted.
4696 : * If @a __pos is beyond end of string, out_of_range is thrown.
4697 : * If the length of the result exceeds max_size(), length_error
4698 : * is thrown. The value of the string doesn't change if an
4699 : * error is thrown.
4700 : */
4701 : basic_string&
4702 : replace(size_type __pos, size_type __n, const basic_string& __str)
4703 : { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
4704 :
4705 : /**
4706 : * @brief Replace characters with value from another string.
4707 : * @param __pos1 Index of first character to replace.
4708 : * @param __n1 Number of characters to be replaced.
4709 : * @param __str String to insert.
4710 : * @param __pos2 Index of first character of str to use.
4711 : * @param __n2 Number of characters from str to use.
4712 : * @return Reference to this string.
4713 : * @throw std::out_of_range If @a __pos1 > size() or @a __pos2 >
4714 : * __str.size().
4715 : * @throw std::length_error If new length exceeds @c max_size().
4716 : *
4717 : * Removes the characters in the range [__pos1,__pos1 + n) from this
4718 : * string. In place, the value of @a __str is inserted. If @a __pos is
4719 : * beyond end of string, out_of_range is thrown. If the length of the
4720 : * result exceeds max_size(), length_error is thrown. The value of the
4721 : * string doesn't change if an error is thrown.
4722 : */
4723 : basic_string&
4724 : replace(size_type __pos1, size_type __n1, const basic_string& __str,
4725 : size_type __pos2, size_type __n2 = npos)
4726 : { return this->replace(__pos1, __n1, __str._M_data()
4727 : + __str._M_check(__pos2, "basic_string::replace"),
4728 : __str._M_limit(__pos2, __n2)); }
4729 :
4730 : /**
4731 : * @brief Replace characters with value of a C substring.
4732 : * @param __pos Index of first character to replace.
4733 : * @param __n1 Number of characters to be replaced.
4734 : * @param __s C string to insert.
4735 : * @param __n2 Number of characters from @a s to use.
4736 : * @return Reference to this string.
4737 : * @throw std::out_of_range If @a pos1 > size().
4738 : * @throw std::length_error If new length exceeds @c max_size().
4739 : *
4740 : * Removes the characters in the range [__pos,__pos + __n1)
4741 : * from this string. In place, the first @a __n2 characters of
4742 : * @a __s are inserted, or all of @a __s if @a __n2 is too large. If
4743 : * @a __pos is beyond end of string, out_of_range is thrown. If
4744 : * the length of result exceeds max_size(), length_error is
4745 : * thrown. The value of the string doesn't change if an error
4746 : * is thrown.
4747 : */
4748 : basic_string&
4749 : replace(size_type __pos, size_type __n1, const _CharT* __s,
4750 : size_type __n2);
4751 :
4752 : /**
4753 : * @brief Replace characters with value of a C string.
4754 : * @param __pos Index of first character to replace.
4755 : * @param __n1 Number of characters to be replaced.
4756 : * @param __s C string to insert.
4757 : * @return Reference to this string.
4758 : * @throw std::out_of_range If @a pos > size().
4759 : * @throw std::length_error If new length exceeds @c max_size().
4760 : *
4761 : * Removes the characters in the range [__pos,__pos + __n1)
4762 : * from this string. In place, the characters of @a __s are
4763 : * inserted. If @a __pos is beyond end of string, out_of_range
4764 : * is thrown. If the length of result exceeds max_size(),
4765 : * length_error is thrown. The value of the string doesn't
4766 : * change if an error is thrown.
4767 : */
4768 : basic_string&
4769 : replace(size_type __pos, size_type __n1, const _CharT* __s)
4770 : {
4771 : __glibcxx_requires_string(__s);
4772 : return this->replace(__pos, __n1, __s, traits_type::length(__s));
4773 : }
4774 :
4775 : /**
4776 : * @brief Replace characters with multiple characters.
4777 : * @param __pos Index of first character to replace.
4778 : * @param __n1 Number of characters to be replaced.
4779 : * @param __n2 Number of characters to insert.
4780 : * @param __c Character to insert.
4781 : * @return Reference to this string.
4782 : * @throw std::out_of_range If @a __pos > size().
4783 : * @throw std::length_error If new length exceeds @c max_size().
4784 : *
4785 : * Removes the characters in the range [pos,pos + n1) from this
4786 : * string. In place, @a __n2 copies of @a __c are inserted.
4787 : * If @a __pos is beyond end of string, out_of_range is thrown.
4788 : * If the length of result exceeds max_size(), length_error is
4789 : * thrown. The value of the string doesn't change if an error
4790 : * is thrown.
4791 : */
4792 : basic_string&
4793 : replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
4794 : { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
4795 : _M_limit(__pos, __n1), __n2, __c); }
4796 :
4797 : /**
4798 : * @brief Replace range of characters with string.
4799 : * @param __i1 Iterator referencing start of range to replace.
4800 : * @param __i2 Iterator referencing end of range to replace.
4801 : * @param __str String value to insert.
4802 : * @return Reference to this string.
4803 : * @throw std::length_error If new length exceeds @c max_size().
4804 : *
4805 : * Removes the characters in the range [__i1,__i2). In place,
4806 : * the value of @a __str is inserted. If the length of result
4807 : * exceeds max_size(), length_error is thrown. The value of
4808 : * the string doesn't change if an error is thrown.
4809 : */
4810 : basic_string&
4811 : replace(iterator __i1, iterator __i2, const basic_string& __str)
4812 : { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
4813 :
4814 : /**
4815 : * @brief Replace range of characters with C substring.
4816 : * @param __i1 Iterator referencing start of range to replace.
4817 : * @param __i2 Iterator referencing end of range to replace.
4818 : * @param __s C string value to insert.
4819 : * @param __n Number of characters from s to insert.
4820 : * @return Reference to this string.
4821 : * @throw std::length_error If new length exceeds @c max_size().
4822 : *
4823 : * Removes the characters in the range [__i1,__i2). In place,
4824 : * the first @a __n characters of @a __s are inserted. If the
4825 : * length of result exceeds max_size(), length_error is thrown.
4826 : * The value of the string doesn't change if an error is
4827 : * thrown.
4828 : */
4829 : basic_string&
4830 : replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
4831 : {
4832 : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
4833 : && __i2 <= _M_iend());
4834 : return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
4835 : }
4836 :
4837 : /**
4838 : * @brief Replace range of characters with C string.
4839 : * @param __i1 Iterator referencing start of range to replace.
4840 : * @param __i2 Iterator referencing end of range to replace.
4841 : * @param __s C string value to insert.
4842 : * @return Reference to this string.
4843 : * @throw std::length_error If new length exceeds @c max_size().
4844 : *
4845 : * Removes the characters in the range [__i1,__i2). In place,
4846 : * the characters of @a __s are inserted. If the length of
4847 : * result exceeds max_size(), length_error is thrown. The
4848 : * value of the string doesn't change if an error is thrown.
4849 : */
4850 : basic_string&
4851 : replace(iterator __i1, iterator __i2, const _CharT* __s)
4852 : {
4853 : __glibcxx_requires_string(__s);
4854 : return this->replace(__i1, __i2, __s, traits_type::length(__s));
4855 : }
4856 :
4857 : /**
4858 : * @brief Replace range of characters with multiple characters
4859 : * @param __i1 Iterator referencing start of range to replace.
4860 : * @param __i2 Iterator referencing end of range to replace.
4861 : * @param __n Number of characters to insert.
4862 : * @param __c Character to insert.
4863 : * @return Reference to this string.
4864 : * @throw std::length_error If new length exceeds @c max_size().
4865 : *
4866 : * Removes the characters in the range [__i1,__i2). In place,
4867 : * @a __n copies of @a __c are inserted. If the length of
4868 : * result exceeds max_size(), length_error is thrown. The
4869 : * value of the string doesn't change if an error is thrown.
4870 : */
4871 : basic_string&
4872 : replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
4873 : {
4874 : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
4875 : && __i2 <= _M_iend());
4876 : return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
4877 : }
4878 :
4879 : /**
4880 : * @brief Replace range of characters with range.
4881 : * @param __i1 Iterator referencing start of range to replace.
4882 : * @param __i2 Iterator referencing end of range to replace.
4883 : * @param __k1 Iterator referencing start of range to insert.
4884 : * @param __k2 Iterator referencing end of range to insert.
4885 : * @return Reference to this string.
4886 : * @throw std::length_error If new length exceeds @c max_size().
4887 : *
4888 : * Removes the characters in the range [__i1,__i2). In place,
4889 : * characters in the range [__k1,__k2) are inserted. If the
4890 : * length of result exceeds max_size(), length_error is thrown.
4891 : * The value of the string doesn't change if an error is
4892 : * thrown.
4893 : */
4894 : template<class _InputIterator>
4895 : basic_string&
4896 : replace(iterator __i1, iterator __i2,
4897 : _InputIterator __k1, _InputIterator __k2)
4898 : {
4899 : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
4900 : && __i2 <= _M_iend());
4901 : __glibcxx_requires_valid_range(__k1, __k2);
4902 : typedef typename std::__is_integer<_InputIterator>::__type _Integral;
4903 : return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
4904 : }
4905 :
4906 : // Specializations for the common case of pointer and iterator:
4907 : // useful to avoid the overhead of temporary buffering in _M_replace.
4908 : basic_string&
4909 : replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
4910 : {
4911 : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
4912 : && __i2 <= _M_iend());
4913 : __glibcxx_requires_valid_range(__k1, __k2);
4914 : return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
4915 : __k1, __k2 - __k1);
4916 : }
4917 :
4918 : basic_string&
4919 : replace(iterator __i1, iterator __i2,
4920 : const _CharT* __k1, const _CharT* __k2)
4921 : {
4922 : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
4923 : && __i2 <= _M_iend());
4924 : __glibcxx_requires_valid_range(__k1, __k2);
4925 : return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
4926 : __k1, __k2 - __k1);
4927 : }
4928 :
4929 : basic_string&
4930 : replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
4931 : {
4932 : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
4933 : && __i2 <= _M_iend());
4934 : __glibcxx_requires_valid_range(__k1, __k2);
4935 : return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
4936 : __k1.base(), __k2 - __k1);
4937 : }
4938 :
4939 : basic_string&
4940 : replace(iterator __i1, iterator __i2,
4941 : const_iterator __k1, const_iterator __k2)
4942 : {
4943 : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
4944 : && __i2 <= _M_iend());
4945 : __glibcxx_requires_valid_range(__k1, __k2);
4946 : return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
4947 : __k1.base(), __k2 - __k1);
4948 : }
4949 :
4950 : #if __cplusplus >= 201103L
4951 : /**
4952 : * @brief Replace range of characters with initializer_list.
4953 : * @param __i1 Iterator referencing start of range to replace.
4954 : * @param __i2 Iterator referencing end of range to replace.
4955 : * @param __l The initializer_list of characters to insert.
4956 : * @return Reference to this string.
4957 : * @throw std::length_error If new length exceeds @c max_size().
4958 : *
4959 : * Removes the characters in the range [__i1,__i2). In place,
4960 : * characters in the range [__k1,__k2) are inserted. If the
4961 : * length of result exceeds max_size(), length_error is thrown.
4962 : * The value of the string doesn't change if an error is
4963 : * thrown.
4964 : */
4965 : basic_string& replace(iterator __i1, iterator __i2,
4966 : initializer_list<_CharT> __l)
4967 : { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
4968 : #endif // C++11
4969 :
4970 : #if __cplusplus > 201402L
4971 : /**
4972 : * @brief Replace range of characters with string_view.
4973 : * @param __pos The position to replace at.
4974 : * @param __n The number of characters to replace.
4975 : * @param __svt The object convertible to string_view to insert.
4976 : * @return Reference to this string.
4977 : */
4978 : template<typename _Tp>
4979 : _If_sv<_Tp, basic_string&>
4980 : replace(size_type __pos, size_type __n, const _Tp& __svt)
4981 : {
4982 : __sv_type __sv = __svt;
4983 : return this->replace(__pos, __n, __sv.data(), __sv.size());
4984 : }
4985 :
4986 : /**
4987 : * @brief Replace range of characters with string_view.
4988 : * @param __pos1 The position to replace at.
4989 : * @param __n1 The number of characters to replace.
4990 : * @param __svt The object convertible to string_view to insert from.
4991 : * @param __pos2 The position in the string_view to insert from.
4992 : * @param __n2 The number of characters to insert.
4993 : * @return Reference to this string.
4994 : */
4995 : template<typename _Tp>
4996 : _If_sv<_Tp, basic_string&>
4997 : replace(size_type __pos1, size_type __n1, const _Tp& __svt,
4998 : size_type __pos2, size_type __n2 = npos)
4999 : {
5000 : __sv_type __sv = __svt;
5001 : return this->replace(__pos1, __n1,
5002 : __sv.data() + __sv._M_check(__pos2, "basic_string::replace"),
5003 : __sv._M_limit(__pos2, __n2));
5004 : }
5005 :
5006 : /**
5007 : * @brief Replace range of characters with string_view.
5008 : * @param __i1 An iterator referencing the start position
5009 : to replace at.
5010 : * @param __i2 An iterator referencing the end position
5011 : for the replace.
5012 : * @param __svt The object convertible to string_view to insert from.
5013 : * @return Reference to this string.
5014 : */
5015 : template<typename _Tp>
5016 : _If_sv<_Tp, basic_string&>
5017 : replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
5018 : {
5019 : __sv_type __sv = __svt;
5020 : return this->replace(__i1 - begin(), __i2 - __i1, __sv);
5021 : }
5022 : #endif // C++17
5023 :
5024 : private:
5025 : template<class _Integer>
5026 : basic_string&
5027 : _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
5028 : _Integer __val, __true_type)
5029 : { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
5030 :
5031 : template<class _InputIterator>
5032 : basic_string&
5033 : _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
5034 : _InputIterator __k2, __false_type);
5035 :
5036 : basic_string&
5037 : _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
5038 : _CharT __c);
5039 :
5040 : basic_string&
5041 : _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
5042 : size_type __n2);
5043 :
5044 : // _S_construct_aux is used to implement the 21.3.1 para 15 which
5045 : // requires special behaviour if _InIter is an integral type
5046 : template<class _InIterator>
5047 : static _CharT*
5048 : _S_construct_aux(_InIterator __beg, _InIterator __end,
5049 : const _Alloc& __a, __false_type)
5050 : {
5051 : typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
5052 : return _S_construct(__beg, __end, __a, _Tag());
5053 : }
5054 :
5055 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
5056 : // 438. Ambiguity in the "do the right thing" clause
5057 : template<class _Integer>
5058 : static _CharT*
5059 : _S_construct_aux(_Integer __beg, _Integer __end,
5060 : const _Alloc& __a, __true_type)
5061 : { return _S_construct_aux_2(static_cast<size_type>(__beg),
5062 : __end, __a); }
5063 :
5064 : static _CharT*
5065 : _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
5066 : { return _S_construct(__req, __c, __a); }
5067 :
5068 : template<class _InIterator>
5069 : static _CharT*
5070 : _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
5071 : {
5072 : typedef typename std::__is_integer<_InIterator>::__type _Integral;
5073 : return _S_construct_aux(__beg, __end, __a, _Integral());
5074 : }
5075 :
5076 : // For Input Iterators, used in istreambuf_iterators, etc.
5077 : template<class _InIterator>
5078 : static _CharT*
5079 : _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
5080 : input_iterator_tag);
5081 :
5082 : // For forward_iterators up to random_access_iterators, used for
5083 : // string::iterator, _CharT*, etc.
5084 : template<class _FwdIterator>
5085 : static _CharT*
5086 : _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
5087 : forward_iterator_tag);
5088 :
5089 : static _CharT*
5090 : _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
5091 :
5092 : public:
5093 :
5094 : /**
5095 : * @brief Copy substring into C string.
5096 : * @param __s C string to copy value into.
5097 : * @param __n Number of characters to copy.
5098 : * @param __pos Index of first character to copy.
5099 : * @return Number of characters actually copied
5100 : * @throw std::out_of_range If __pos > size().
5101 : *
5102 : * Copies up to @a __n characters starting at @a __pos into the
5103 : * C string @a __s. If @a __pos is %greater than size(),
5104 : * out_of_range is thrown.
5105 : */
5106 : size_type
5107 : copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
5108 :
5109 : /**
5110 : * @brief Swap contents with another string.
5111 : * @param __s String to swap with.
5112 : *
5113 : * Exchanges the contents of this string with that of @a __s in constant
5114 : * time.
5115 : */
5116 : // PR 58265, this should be noexcept.
5117 : void
5118 : swap(basic_string& __s);
5119 :
5120 : // String operations:
5121 : /**
5122 : * @brief Return const pointer to null-terminated contents.
5123 : *
5124 : * This is a handle to internal data. Do not modify or dire things may
5125 : * happen.
5126 : */
5127 : const _CharT*
5128 : c_str() const _GLIBCXX_NOEXCEPT
5129 : { return _M_data(); }
5130 :
5131 : /**
5132 : * @brief Return const pointer to contents.
5133 : *
5134 : * This is a pointer to internal data. It is undefined to modify
5135 : * the contents through the returned pointer. To get a pointer that
5136 : * allows modifying the contents use @c &str[0] instead,
5137 : * (or in C++17 the non-const @c str.data() overload).
5138 : */
5139 : const _CharT*
5140 : data() const _GLIBCXX_NOEXCEPT
5141 : { return _M_data(); }
5142 :
5143 : #if __cplusplus > 201402L
5144 : /**
5145 : * @brief Return non-const pointer to contents.
5146 : *
5147 : * This is a pointer to the character sequence held by the string.
5148 : * Modifying the characters in the sequence is allowed.
5149 : */
5150 : _CharT*
5151 : data() noexcept
5152 : {
5153 : _M_leak();
5154 : return _M_data();
5155 : }
5156 : #endif
5157 :
5158 : /**
5159 : * @brief Return copy of allocator used to construct this string.
5160 : */
5161 : allocator_type
5162 : get_allocator() const _GLIBCXX_NOEXCEPT
5163 : { return _M_dataplus; }
5164 :
5165 : /**
5166 : * @brief Find position of a C substring.
5167 : * @param __s C string to locate.
5168 : * @param __pos Index of character to search from.
5169 : * @param __n Number of characters from @a s to search for.
5170 : * @return Index of start of first occurrence.
5171 : *
5172 : * Starting from @a __pos, searches forward for the first @a
5173 : * __n characters in @a __s within this string. If found,
5174 : * returns the index where it begins. If not found, returns
5175 : * npos.
5176 : */
5177 : size_type
5178 : find(const _CharT* __s, size_type __pos, size_type __n) const
5179 : _GLIBCXX_NOEXCEPT;
5180 :
5181 : /**
5182 : * @brief Find position of a string.
5183 : * @param __str String to locate.
5184 : * @param __pos Index of character to search from (default 0).
5185 : * @return Index of start of first occurrence.
5186 : *
5187 : * Starting from @a __pos, searches forward for value of @a __str within
5188 : * this string. If found, returns the index where it begins. If not
5189 : * found, returns npos.
5190 : */
5191 : size_type
5192 : find(const basic_string& __str, size_type __pos = 0) const
5193 : _GLIBCXX_NOEXCEPT
5194 : { return this->find(__str.data(), __pos, __str.size()); }
5195 :
5196 : /**
5197 : * @brief Find position of a C string.
5198 : * @param __s C string to locate.
5199 : * @param __pos Index of character to search from (default 0).
5200 : * @return Index of start of first occurrence.
5201 : *
5202 : * Starting from @a __pos, searches forward for the value of @a
5203 : * __s within this string. If found, returns the index where
5204 : * it begins. If not found, returns npos.
5205 : */
5206 : size_type
5207 : find(const _CharT* __s, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
5208 : {
5209 : __glibcxx_requires_string(__s);
5210 : return this->find(__s, __pos, traits_type::length(__s));
5211 : }
5212 :
5213 : /**
5214 : * @brief Find position of a character.
5215 : * @param __c Character to locate.
5216 : * @param __pos Index of character to search from (default 0).
5217 : * @return Index of first occurrence.
5218 : *
5219 : * Starting from @a __pos, searches forward for @a __c within
5220 : * this string. If found, returns the index where it was
5221 : * found. If not found, returns npos.
5222 : */
5223 : size_type
5224 : find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT;
5225 :
5226 : #if __cplusplus > 201402L
5227 : /**
5228 : * @brief Find position of a string_view.
5229 : * @param __svt The object convertible to string_view to locate.
5230 : * @param __pos Index of character to search from (default 0).
5231 : * @return Index of start of first occurrence.
5232 : */
5233 : template<typename _Tp>
5234 : _If_sv<_Tp, size_type>
5235 : find(const _Tp& __svt, size_type __pos = 0) const
5236 : noexcept(is_same<_Tp, __sv_type>::value)
5237 : {
5238 : __sv_type __sv = __svt;
5239 : return this->find(__sv.data(), __pos, __sv.size());
5240 : }
5241 : #endif // C++17
5242 :
5243 : /**
5244 : * @brief Find last position of a string.
5245 : * @param __str String to locate.
5246 : * @param __pos Index of character to search back from (default end).
5247 : * @return Index of start of last occurrence.
5248 : *
5249 : * Starting from @a __pos, searches backward for value of @a
5250 : * __str within this string. If found, returns the index where
5251 : * it begins. If not found, returns npos.
5252 : */
5253 : size_type
5254 : rfind(const basic_string& __str, size_type __pos = npos) const
5255 : _GLIBCXX_NOEXCEPT
5256 : { return this->rfind(__str.data(), __pos, __str.size()); }
5257 :
5258 : /**
5259 : * @brief Find last position of a C substring.
5260 : * @param __s C string to locate.
5261 : * @param __pos Index of character to search back from.
5262 : * @param __n Number of characters from s to search for.
5263 : * @return Index of start of last occurrence.
5264 : *
5265 : * Starting from @a __pos, searches backward for the first @a
5266 : * __n characters in @a __s within this string. If found,
5267 : * returns the index where it begins. If not found, returns
5268 : * npos.
5269 : */
5270 : size_type
5271 : rfind(const _CharT* __s, size_type __pos, size_type __n) const
5272 : _GLIBCXX_NOEXCEPT;
5273 :
5274 : /**
5275 : * @brief Find last position of a C string.
5276 : * @param __s C string to locate.
5277 : * @param __pos Index of character to start search at (default end).
5278 : * @return Index of start of last occurrence.
5279 : *
5280 : * Starting from @a __pos, searches backward for the value of
5281 : * @a __s within this string. If found, returns the index
5282 : * where it begins. If not found, returns npos.
5283 : */
5284 : size_type
5285 : rfind(const _CharT* __s, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
5286 : {
5287 : __glibcxx_requires_string(__s);
5288 : return this->rfind(__s, __pos, traits_type::length(__s));
5289 : }
5290 :
5291 : /**
5292 : * @brief Find last position of a character.
5293 : * @param __c Character to locate.
5294 : * @param __pos Index of character to search back from (default end).
5295 : * @return Index of last occurrence.
5296 : *
5297 : * Starting from @a __pos, searches backward for @a __c within
5298 : * this string. If found, returns the index where it was
5299 : * found. If not found, returns npos.
5300 : */
5301 : size_type
5302 : rfind(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT;
5303 :
5304 : #if __cplusplus > 201402L
5305 : /**
5306 : * @brief Find last position of a string_view.
5307 : * @param __svt The object convertible to string_view to locate.
5308 : * @param __pos Index of character to search back from (default end).
5309 : * @return Index of start of last occurrence.
5310 : */
5311 : template<typename _Tp>
5312 : _If_sv<_Tp, size_type>
5313 : rfind(const _Tp& __svt, size_type __pos = npos) const
5314 : noexcept(is_same<_Tp, __sv_type>::value)
5315 : {
5316 : __sv_type __sv = __svt;
5317 : return this->rfind(__sv.data(), __pos, __sv.size());
5318 : }
5319 : #endif // C++17
5320 :
5321 : /**
5322 : * @brief Find position of a character of string.
5323 : * @param __str String containing characters to locate.
5324 : * @param __pos Index of character to search from (default 0).
5325 : * @return Index of first occurrence.
5326 : *
5327 : * Starting from @a __pos, searches forward for one of the
5328 : * characters of @a __str within this string. If found,
5329 : * returns the index where it was found. If not found, returns
5330 : * npos.
5331 : */
5332 : size_type
5333 : find_first_of(const basic_string& __str, size_type __pos = 0) const
5334 : _GLIBCXX_NOEXCEPT
5335 : { return this->find_first_of(__str.data(), __pos, __str.size()); }
5336 :
5337 : /**
5338 : * @brief Find position of a character of C substring.
5339 : * @param __s String containing characters to locate.
5340 : * @param __pos Index of character to search from.
5341 : * @param __n Number of characters from s to search for.
5342 : * @return Index of first occurrence.
5343 : *
5344 : * Starting from @a __pos, searches forward for one of the
5345 : * first @a __n characters of @a __s within this string. If
5346 : * found, returns the index where it was found. If not found,
5347 : * returns npos.
5348 : */
5349 : size_type
5350 : find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
5351 : _GLIBCXX_NOEXCEPT;
5352 :
5353 : /**
5354 : * @brief Find position of a character of C string.
5355 : * @param __s String containing characters to locate.
5356 : * @param __pos Index of character to search from (default 0).
5357 : * @return Index of first occurrence.
5358 : *
5359 : * Starting from @a __pos, searches forward for one of the
5360 : * characters of @a __s within this string. If found, returns
5361 : * the index where it was found. If not found, returns npos.
5362 : */
5363 : size_type
5364 : find_first_of(const _CharT* __s, size_type __pos = 0) const
5365 : _GLIBCXX_NOEXCEPT
5366 : {
5367 : __glibcxx_requires_string(__s);
5368 : return this->find_first_of(__s, __pos, traits_type::length(__s));
5369 : }
5370 :
5371 : /**
5372 : * @brief Find position of a character.
5373 : * @param __c Character to locate.
5374 : * @param __pos Index of character to search from (default 0).
5375 : * @return Index of first occurrence.
5376 : *
5377 : * Starting from @a __pos, searches forward for the character
5378 : * @a __c within this string. If found, returns the index
5379 : * where it was found. If not found, returns npos.
5380 : *
5381 : * Note: equivalent to find(__c, __pos).
5382 : */
5383 : size_type
5384 : find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
5385 : { return this->find(__c, __pos); }
5386 :
5387 : #if __cplusplus > 201402L
5388 : /**
5389 : * @brief Find position of a character of a string_view.
5390 : * @param __svt An object convertible to string_view containing
5391 : * characters to locate.
5392 : * @param __pos Index of character to search from (default 0).
5393 : * @return Index of first occurrence.
5394 : */
5395 : template<typename _Tp>
5396 : _If_sv<_Tp, size_type>
5397 : find_first_of(const _Tp& __svt, size_type __pos = 0) const
5398 : noexcept(is_same<_Tp, __sv_type>::value)
5399 : {
5400 : __sv_type __sv = __svt;
5401 : return this->find_first_of(__sv.data(), __pos, __sv.size());
5402 : }
5403 : #endif // C++17
5404 :
5405 : /**
5406 : * @brief Find last position of a character of string.
5407 : * @param __str String containing characters to locate.
5408 : * @param __pos Index of character to search back from (default end).
5409 : * @return Index of last occurrence.
5410 : *
5411 : * Starting from @a __pos, searches backward for one of the
5412 : * characters of @a __str within this string. If found,
5413 : * returns the index where it was found. If not found, returns
5414 : * npos.
5415 : */
5416 : size_type
5417 : find_last_of(const basic_string& __str, size_type __pos = npos) const
5418 : _GLIBCXX_NOEXCEPT
5419 : { return this->find_last_of(__str.data(), __pos, __str.size()); }
5420 :
5421 : /**
5422 : * @brief Find last position of a character of C substring.
5423 : * @param __s C string containing characters to locate.
5424 : * @param __pos Index of character to search back from.
5425 : * @param __n Number of characters from s to search for.
5426 : * @return Index of last occurrence.
5427 : *
5428 : * Starting from @a __pos, searches backward for one of the
5429 : * first @a __n characters of @a __s within this string. If
5430 : * found, returns the index where it was found. If not found,
5431 : * returns npos.
5432 : */
5433 : size_type
5434 : find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
5435 : _GLIBCXX_NOEXCEPT;
5436 :
5437 : /**
5438 : * @brief Find last position of a character of C string.
5439 : * @param __s C string containing characters to locate.
5440 : * @param __pos Index of character to search back from (default end).
5441 : * @return Index of last occurrence.
5442 : *
5443 : * Starting from @a __pos, searches backward for one of the
5444 : * characters of @a __s within this string. If found, returns
5445 : * the index where it was found. If not found, returns npos.
5446 : */
5447 : size_type
5448 : find_last_of(const _CharT* __s, size_type __pos = npos) const
5449 : _GLIBCXX_NOEXCEPT
5450 : {
5451 : __glibcxx_requires_string(__s);
5452 : return this->find_last_of(__s, __pos, traits_type::length(__s));
5453 : }
5454 :
5455 : /**
5456 : * @brief Find last position of a character.
5457 : * @param __c Character to locate.
5458 : * @param __pos Index of character to search back from (default end).
5459 : * @return Index of last occurrence.
5460 : *
5461 : * Starting from @a __pos, searches backward for @a __c within
5462 : * this string. If found, returns the index where it was
5463 : * found. If not found, returns npos.
5464 : *
5465 : * Note: equivalent to rfind(__c, __pos).
5466 : */
5467 : size_type
5468 : find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
5469 : { return this->rfind(__c, __pos); }
5470 :
5471 : #if __cplusplus > 201402L
5472 : /**
5473 : * @brief Find last position of a character of string.
5474 : * @param __svt An object convertible to string_view containing
5475 : * characters to locate.
5476 : * @param __pos Index of character to search back from (default end).
5477 : * @return Index of last occurrence.
5478 : */
5479 : template<typename _Tp>
5480 : _If_sv<_Tp, size_type>
5481 : find_last_of(const _Tp& __svt, size_type __pos = npos) const
5482 : noexcept(is_same<_Tp, __sv_type>::value)
5483 : {
5484 : __sv_type __sv = __svt;
5485 : return this->find_last_of(__sv.data(), __pos, __sv.size());
5486 : }
5487 : #endif // C++17
5488 :
5489 : /**
5490 : * @brief Find position of a character not in string.
5491 : * @param __str String containing characters to avoid.
5492 : * @param __pos Index of character to search from (default 0).
5493 : * @return Index of first occurrence.
5494 : *
5495 : * Starting from @a __pos, searches forward for a character not contained
5496 : * in @a __str within this string. If found, returns the index where it
5497 : * was found. If not found, returns npos.
5498 : */
5499 : size_type
5500 : find_first_not_of(const basic_string& __str, size_type __pos = 0) const
5501 : _GLIBCXX_NOEXCEPT
5502 : { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
5503 :
5504 : /**
5505 : * @brief Find position of a character not in C substring.
5506 : * @param __s C string containing characters to avoid.
5507 : * @param __pos Index of character to search from.
5508 : * @param __n Number of characters from __s to consider.
5509 : * @return Index of first occurrence.
5510 : *
5511 : * Starting from @a __pos, searches forward for a character not
5512 : * contained in the first @a __n characters of @a __s within
5513 : * this string. If found, returns the index where it was
5514 : * found. If not found, returns npos.
5515 : */
5516 : size_type
5517 : find_first_not_of(const _CharT* __s, size_type __pos,
5518 : size_type __n) const _GLIBCXX_NOEXCEPT;
5519 :
5520 : /**
5521 : * @brief Find position of a character not in C string.
5522 : * @param __s C string containing characters to avoid.
5523 : * @param __pos Index of character to search from (default 0).
5524 : * @return Index of first occurrence.
5525 : *
5526 : * Starting from @a __pos, searches forward for a character not
5527 : * contained in @a __s within this string. If found, returns
5528 : * the index where it was found. If not found, returns npos.
5529 : */
5530 : size_type
5531 : find_first_not_of(const _CharT* __s, size_type __pos = 0) const
5532 : _GLIBCXX_NOEXCEPT
5533 : {
5534 : __glibcxx_requires_string(__s);
5535 : return this->find_first_not_of(__s, __pos, traits_type::length(__s));
5536 : }
5537 :
5538 : /**
5539 : * @brief Find position of a different character.
5540 : * @param __c Character to avoid.
5541 : * @param __pos Index of character to search from (default 0).
5542 : * @return Index of first occurrence.
5543 : *
5544 : * Starting from @a __pos, searches forward for a character
5545 : * other than @a __c within this string. If found, returns the
5546 : * index where it was found. If not found, returns npos.
5547 : */
5548 : size_type
5549 : find_first_not_of(_CharT __c, size_type __pos = 0) const
5550 : _GLIBCXX_NOEXCEPT;
5551 :
5552 : #if __cplusplus > 201402L
5553 : /**
5554 : * @brief Find position of a character not in a string_view.
5555 : * @param __svt An object convertible to string_view containing
5556 : * characters to avoid.
5557 : * @param __pos Index of character to search from (default 0).
5558 : * @return Index of first occurrence.
5559 : */
5560 : template<typename _Tp>
5561 : _If_sv<_Tp, size_type>
5562 : find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
5563 : noexcept(is_same<_Tp, __sv_type>::value)
5564 : {
5565 : __sv_type __sv = __svt;
5566 : return this->find_first_not_of(__sv.data(), __pos, __sv.size());
5567 : }
5568 : #endif // C++17
5569 :
5570 : /**
5571 : * @brief Find last position of a character not in string.
5572 : * @param __str String containing characters to avoid.
5573 : * @param __pos Index of character to search back from (default end).
5574 : * @return Index of last occurrence.
5575 : *
5576 : * Starting from @a __pos, searches backward for a character
5577 : * not contained in @a __str within this string. If found,
5578 : * returns the index where it was found. If not found, returns
5579 : * npos.
5580 : */
5581 : size_type
5582 : find_last_not_of(const basic_string& __str, size_type __pos = npos) const
5583 : _GLIBCXX_NOEXCEPT
5584 : { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
5585 :
5586 : /**
5587 : * @brief Find last position of a character not in C substring.
5588 : * @param __s C string containing characters to avoid.
5589 : * @param __pos Index of character to search back from.
5590 : * @param __n Number of characters from s to consider.
5591 : * @return Index of last occurrence.
5592 : *
5593 : * Starting from @a __pos, searches backward for a character not
5594 : * contained in the first @a __n characters of @a __s within this string.
5595 : * If found, returns the index where it was found. If not found,
5596 : * returns npos.
5597 : */
5598 : size_type
5599 : find_last_not_of(const _CharT* __s, size_type __pos,
5600 : size_type __n) const _GLIBCXX_NOEXCEPT;
5601 : /**
5602 : * @brief Find last position of a character not in C string.
5603 : * @param __s C string containing characters to avoid.
5604 : * @param __pos Index of character to search back from (default end).
5605 : * @return Index of last occurrence.
5606 : *
5607 : * Starting from @a __pos, searches backward for a character
5608 : * not contained in @a __s within this string. If found,
5609 : * returns the index where it was found. If not found, returns
5610 : * npos.
5611 : */
5612 : size_type
5613 : find_last_not_of(const _CharT* __s, size_type __pos = npos) const
5614 : _GLIBCXX_NOEXCEPT
5615 : {
5616 : __glibcxx_requires_string(__s);
5617 : return this->find_last_not_of(__s, __pos, traits_type::length(__s));
5618 : }
5619 :
5620 : /**
5621 : * @brief Find last position of a different character.
5622 : * @param __c Character to avoid.
5623 : * @param __pos Index of character to search back from (default end).
5624 : * @return Index of last occurrence.
5625 : *
5626 : * Starting from @a __pos, searches backward for a character other than
5627 : * @a __c within this string. If found, returns the index where it was
5628 : * found. If not found, returns npos.
5629 : */
5630 : size_type
5631 : find_last_not_of(_CharT __c, size_type __pos = npos) const
5632 : _GLIBCXX_NOEXCEPT;
5633 :
5634 : #if __cplusplus > 201402L
5635 : /**
5636 : * @brief Find last position of a character not in a string_view.
5637 : * @param __svt An object convertible to string_view containing
5638 : * characters to avoid.
5639 : * @param __pos Index of character to search back from (default end).
5640 : * @return Index of last occurrence.
5641 : */
5642 : template<typename _Tp>
5643 : _If_sv<_Tp, size_type>
5644 : find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
5645 : noexcept(is_same<_Tp, __sv_type>::value)
5646 : {
5647 : __sv_type __sv = __svt;
5648 : return this->find_last_not_of(__sv.data(), __pos, __sv.size());
5649 : }
5650 : #endif // C++17
5651 :
5652 : /**
5653 : * @brief Get a substring.
5654 : * @param __pos Index of first character (default 0).
5655 : * @param __n Number of characters in substring (default remainder).
5656 : * @return The new string.
5657 : * @throw std::out_of_range If __pos > size().
5658 : *
5659 : * Construct and return a new string using the @a __n
5660 : * characters starting at @a __pos. If the string is too
5661 : * short, use the remainder of the characters. If @a __pos is
5662 : * beyond the end of the string, out_of_range is thrown.
5663 : */
5664 : basic_string
5665 : substr(size_type __pos = 0, size_type __n = npos) const
5666 : { return basic_string(*this,
5667 : _M_check(__pos, "basic_string::substr"), __n); }
5668 :
5669 : /**
5670 : * @brief Compare to a string.
5671 : * @param __str String to compare against.
5672 : * @return Integer < 0, 0, or > 0.
5673 : *
5674 : * Returns an integer < 0 if this string is ordered before @a
5675 : * __str, 0 if their values are equivalent, or > 0 if this
5676 : * string is ordered after @a __str. Determines the effective
5677 : * length rlen of the strings to compare as the smallest of
5678 : * size() and str.size(). The function then compares the two
5679 : * strings by calling traits::compare(data(), str.data(),rlen).
5680 : * If the result of the comparison is nonzero returns it,
5681 : * otherwise the shorter one is ordered first.
5682 : */
5683 : int
5684 : compare(const basic_string& __str) const
5685 : {
5686 : const size_type __size = this->size();
5687 : const size_type __osize = __str.size();
5688 : const size_type __len = std::min(__size, __osize);
5689 :
5690 : int __r = traits_type::compare(_M_data(), __str.data(), __len);
5691 : if (!__r)
5692 : __r = _S_compare(__size, __osize);
5693 : return __r;
5694 : }
5695 :
5696 : #if __cplusplus > 201402L
5697 : /**
5698 : * @brief Compare to a string_view.
5699 : * @param __svt An object convertible to string_view to compare against.
5700 : * @return Integer < 0, 0, or > 0.
5701 : */
5702 : template<typename _Tp>
5703 : _If_sv<_Tp, int>
5704 : compare(const _Tp& __svt) const
5705 : noexcept(is_same<_Tp, __sv_type>::value)
5706 : {
5707 : __sv_type __sv = __svt;
5708 : const size_type __size = this->size();
5709 : const size_type __osize = __sv.size();
5710 : const size_type __len = std::min(__size, __osize);
5711 :
5712 : int __r = traits_type::compare(_M_data(), __sv.data(), __len);
5713 : if (!__r)
5714 : __r = _S_compare(__size, __osize);
5715 : return __r;
5716 : }
5717 :
5718 : /**
5719 : * @brief Compare to a string_view.
5720 : * @param __pos A position in the string to start comparing from.
5721 : * @param __n The number of characters to compare.
5722 : * @param __svt An object convertible to string_view to compare
5723 : * against.
5724 : * @return Integer < 0, 0, or > 0.
5725 : */
5726 : template<typename _Tp>
5727 : _If_sv<_Tp, int>
5728 : compare(size_type __pos, size_type __n, const _Tp& __svt) const
5729 : noexcept(is_same<_Tp, __sv_type>::value)
5730 : {
5731 : __sv_type __sv = __svt;
5732 : return __sv_type(*this).substr(__pos, __n).compare(__sv);
5733 : }
5734 :
5735 : /**
5736 : * @brief Compare to a string_view.
5737 : * @param __pos1 A position in the string to start comparing from.
5738 : * @param __n1 The number of characters to compare.
5739 : * @param __svt An object convertible to string_view to compare
5740 : * against.
5741 : * @param __pos2 A position in the string_view to start comparing from.
5742 : * @param __n2 The number of characters to compare.
5743 : * @return Integer < 0, 0, or > 0.
5744 : */
5745 : template<typename _Tp>
5746 : _If_sv<_Tp, int>
5747 : compare(size_type __pos1, size_type __n1, const _Tp& __svt,
5748 : size_type __pos2, size_type __n2 = npos) const
5749 : noexcept(is_same<_Tp, __sv_type>::value)
5750 : {
5751 : __sv_type __sv = __svt;
5752 : return __sv_type(*this)
5753 : .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
5754 : }
5755 : #endif // C++17
5756 :
5757 : /**
5758 : * @brief Compare substring to a string.
5759 : * @param __pos Index of first character of substring.
5760 : * @param __n Number of characters in substring.
5761 : * @param __str String to compare against.
5762 : * @return Integer < 0, 0, or > 0.
5763 : *
5764 : * Form the substring of this string from the @a __n characters
5765 : * starting at @a __pos. Returns an integer < 0 if the
5766 : * substring is ordered before @a __str, 0 if their values are
5767 : * equivalent, or > 0 if the substring is ordered after @a
5768 : * __str. Determines the effective length rlen of the strings
5769 : * to compare as the smallest of the length of the substring
5770 : * and @a __str.size(). The function then compares the two
5771 : * strings by calling
5772 : * traits::compare(substring.data(),str.data(),rlen). If the
5773 : * result of the comparison is nonzero returns it, otherwise
5774 : * the shorter one is ordered first.
5775 : */
5776 : int
5777 : compare(size_type __pos, size_type __n, const basic_string& __str) const;
5778 :
5779 : /**
5780 : * @brief Compare substring to a substring.
5781 : * @param __pos1 Index of first character of substring.
5782 : * @param __n1 Number of characters in substring.
5783 : * @param __str String to compare against.
5784 : * @param __pos2 Index of first character of substring of str.
5785 : * @param __n2 Number of characters in substring of str.
5786 : * @return Integer < 0, 0, or > 0.
5787 : *
5788 : * Form the substring of this string from the @a __n1
5789 : * characters starting at @a __pos1. Form the substring of @a
5790 : * __str from the @a __n2 characters starting at @a __pos2.
5791 : * Returns an integer < 0 if this substring is ordered before
5792 : * the substring of @a __str, 0 if their values are equivalent,
5793 : * or > 0 if this substring is ordered after the substring of
5794 : * @a __str. Determines the effective length rlen of the
5795 : * strings to compare as the smallest of the lengths of the
5796 : * substrings. The function then compares the two strings by
5797 : * calling
5798 : * traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
5799 : * If the result of the comparison is nonzero returns it,
5800 : * otherwise the shorter one is ordered first.
5801 : */
5802 : int
5803 : compare(size_type __pos1, size_type __n1, const basic_string& __str,
5804 : size_type __pos2, size_type __n2 = npos) const;
5805 :
5806 : /**
5807 : * @brief Compare to a C string.
5808 : * @param __s C string to compare against.
5809 : * @return Integer < 0, 0, or > 0.
5810 : *
5811 : * Returns an integer < 0 if this string is ordered before @a __s, 0 if
5812 : * their values are equivalent, or > 0 if this string is ordered after
5813 : * @a __s. Determines the effective length rlen of the strings to
5814 : * compare as the smallest of size() and the length of a string
5815 : * constructed from @a __s. The function then compares the two strings
5816 : * by calling traits::compare(data(),s,rlen). If the result of the
5817 : * comparison is nonzero returns it, otherwise the shorter one is
5818 : * ordered first.
5819 : */
5820 : int
5821 : compare(const _CharT* __s) const _GLIBCXX_NOEXCEPT;
5822 :
5823 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
5824 : // 5 String::compare specification questionable
5825 : /**
5826 : * @brief Compare substring to a C string.
5827 : * @param __pos Index of first character of substring.
5828 : * @param __n1 Number of characters in substring.
5829 : * @param __s C string to compare against.
5830 : * @return Integer < 0, 0, or > 0.
5831 : *
5832 : * Form the substring of this string from the @a __n1
5833 : * characters starting at @a pos. Returns an integer < 0 if
5834 : * the substring is ordered before @a __s, 0 if their values
5835 : * are equivalent, or > 0 if the substring is ordered after @a
5836 : * __s. Determines the effective length rlen of the strings to
5837 : * compare as the smallest of the length of the substring and
5838 : * the length of a string constructed from @a __s. The
5839 : * function then compares the two string by calling
5840 : * traits::compare(substring.data(),__s,rlen). If the result of
5841 : * the comparison is nonzero returns it, otherwise the shorter
5842 : * one is ordered first.
5843 : */
5844 : int
5845 : compare(size_type __pos, size_type __n1, const _CharT* __s) const;
5846 :
5847 : /**
5848 : * @brief Compare substring against a character %array.
5849 : * @param __pos Index of first character of substring.
5850 : * @param __n1 Number of characters in substring.
5851 : * @param __s character %array to compare against.
5852 : * @param __n2 Number of characters of s.
5853 : * @return Integer < 0, 0, or > 0.
5854 : *
5855 : * Form the substring of this string from the @a __n1
5856 : * characters starting at @a __pos. Form a string from the
5857 : * first @a __n2 characters of @a __s. Returns an integer < 0
5858 : * if this substring is ordered before the string from @a __s,
5859 : * 0 if their values are equivalent, or > 0 if this substring
5860 : * is ordered after the string from @a __s. Determines the
5861 : * effective length rlen of the strings to compare as the
5862 : * smallest of the length of the substring and @a __n2. The
5863 : * function then compares the two strings by calling
5864 : * traits::compare(substring.data(),s,rlen). If the result of
5865 : * the comparison is nonzero returns it, otherwise the shorter
5866 : * one is ordered first.
5867 : *
5868 : * NB: s must have at least n2 characters, '\\0' has
5869 : * no special meaning.
5870 : */
5871 : int
5872 : compare(size_type __pos, size_type __n1, const _CharT* __s,
5873 : size_type __n2) const;
5874 :
5875 : # ifdef _GLIBCXX_TM_TS_INTERNAL
5876 : friend void
5877 : ::_txnal_cow_string_C1_for_exceptions(void* that, const char* s,
5878 : void* exc);
5879 : friend const char*
5880 : ::_txnal_cow_string_c_str(const void *that);
5881 : friend void
5882 : ::_txnal_cow_string_D1(void *that);
5883 : friend void
5884 : ::_txnal_cow_string_D1_commit(void *that);
5885 : # endif
5886 : };
5887 : #endif // !_GLIBCXX_USE_CXX11_ABI
5888 :
5889 : #if __cpp_deduction_guides >= 201606
5890 : _GLIBCXX_BEGIN_NAMESPACE_CXX11
5891 : template<typename _InputIterator, typename _CharT
5892 : = typename iterator_traits<_InputIterator>::value_type,
5893 : typename _Allocator = allocator<_CharT>,
5894 : typename = _RequireInputIter<_InputIterator>,
5895 : typename = _RequireAllocator<_Allocator>>
5896 : basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
5897 : -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
5898 :
5899 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
5900 : // 3075. basic_string needs deduction guides from basic_string_view
5901 : template<typename _CharT, typename _Traits,
5902 : typename _Allocator = allocator<_CharT>,
5903 : typename = _RequireAllocator<_Allocator>>
5904 : basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
5905 : -> basic_string<_CharT, _Traits, _Allocator>;
5906 :
5907 : template<typename _CharT, typename _Traits,
5908 : typename _Allocator = allocator<_CharT>,
5909 : typename = _RequireAllocator<_Allocator>>
5910 : basic_string(basic_string_view<_CharT, _Traits>,
5911 : typename basic_string<_CharT, _Traits, _Allocator>::size_type,
5912 : typename basic_string<_CharT, _Traits, _Allocator>::size_type,
5913 : const _Allocator& = _Allocator())
5914 : -> basic_string<_CharT, _Traits, _Allocator>;
5915 : _GLIBCXX_END_NAMESPACE_CXX11
5916 : #endif
5917 :
5918 : // operator+
5919 : /**
5920 : * @brief Concatenate two strings.
5921 : * @param __lhs First string.
5922 : * @param __rhs Last string.
5923 : * @return New string with value of @a __lhs followed by @a __rhs.
5924 : */
5925 : template<typename _CharT, typename _Traits, typename _Alloc>
5926 : basic_string<_CharT, _Traits, _Alloc>
5927 : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
5928 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
5929 : {
5930 : basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
5931 : __str.append(__rhs);
5932 : return __str;
5933 : }
5934 :
5935 : /**
5936 : * @brief Concatenate C string and string.
5937 : * @param __lhs First string.
5938 : * @param __rhs Last string.
5939 : * @return New string with value of @a __lhs followed by @a __rhs.
5940 : */
5941 : template<typename _CharT, typename _Traits, typename _Alloc>
5942 : basic_string<_CharT,_Traits,_Alloc>
5943 : operator+(const _CharT* __lhs,
5944 : const basic_string<_CharT,_Traits,_Alloc>& __rhs);
5945 :
5946 : /**
5947 : * @brief Concatenate character and string.
5948 : * @param __lhs First string.
5949 : * @param __rhs Last string.
5950 : * @return New string with @a __lhs followed by @a __rhs.
5951 : */
5952 : template<typename _CharT, typename _Traits, typename _Alloc>
5953 : basic_string<_CharT,_Traits,_Alloc>
5954 : operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
5955 :
5956 : /**
5957 : * @brief Concatenate string and C string.
5958 : * @param __lhs First string.
5959 : * @param __rhs Last string.
5960 : * @return New string with @a __lhs followed by @a __rhs.
5961 : */
5962 : template<typename _CharT, typename _Traits, typename _Alloc>
5963 : inline basic_string<_CharT, _Traits, _Alloc>
5964 503 : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
5965 : const _CharT* __rhs)
5966 : {
5967 503 : basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
5968 503 : __str.append(__rhs);
5969 503 : return __str;
5970 : }
5971 :
5972 : /**
5973 : * @brief Concatenate string and character.
5974 : * @param __lhs First string.
5975 : * @param __rhs Last string.
5976 : * @return New string with @a __lhs followed by @a __rhs.
5977 : */
5978 : template<typename _CharT, typename _Traits, typename _Alloc>
5979 : inline basic_string<_CharT, _Traits, _Alloc>
5980 : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
5981 : {
5982 : typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
5983 : typedef typename __string_type::size_type __size_type;
5984 : __string_type __str(__lhs);
5985 : __str.append(__size_type(1), __rhs);
5986 : return __str;
5987 : }
5988 :
5989 : #if __cplusplus >= 201103L
5990 : template<typename _CharT, typename _Traits, typename _Alloc>
5991 : inline basic_string<_CharT, _Traits, _Alloc>
5992 : operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
5993 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
5994 : { return std::move(__lhs.append(__rhs)); }
5995 :
5996 : template<typename _CharT, typename _Traits, typename _Alloc>
5997 : inline basic_string<_CharT, _Traits, _Alloc>
5998 : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
5999 : basic_string<_CharT, _Traits, _Alloc>&& __rhs)
6000 : { return std::move(__rhs.insert(0, __lhs)); }
6001 :
6002 : template<typename _CharT, typename _Traits, typename _Alloc>
6003 : inline basic_string<_CharT, _Traits, _Alloc>
6004 540 : operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
6005 : basic_string<_CharT, _Traits, _Alloc>&& __rhs)
6006 : {
6007 540 : const auto __size = __lhs.size() + __rhs.size();
6008 540 : const bool __cond = (__size > __lhs.capacity()
6009 540 : && __size <= __rhs.capacity());
6010 0 : return __cond ? std::move(__rhs.insert(0, __lhs))
6011 540 : : std::move(__lhs.append(__rhs));
6012 : }
6013 :
6014 : template<typename _CharT, typename _Traits, typename _Alloc>
6015 : inline basic_string<_CharT, _Traits, _Alloc>
6016 99 : operator+(const _CharT* __lhs,
6017 : basic_string<_CharT, _Traits, _Alloc>&& __rhs)
6018 99 : { return std::move(__rhs.insert(0, __lhs)); }
6019 :
6020 : template<typename _CharT, typename _Traits, typename _Alloc>
6021 : inline basic_string<_CharT, _Traits, _Alloc>
6022 : operator+(_CharT __lhs,
6023 : basic_string<_CharT, _Traits, _Alloc>&& __rhs)
6024 : { return std::move(__rhs.insert(0, 1, __lhs)); }
6025 :
6026 : template<typename _CharT, typename _Traits, typename _Alloc>
6027 : inline basic_string<_CharT, _Traits, _Alloc>
6028 575 : operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
6029 : const _CharT* __rhs)
6030 575 : { return std::move(__lhs.append(__rhs)); }
6031 :
6032 : template<typename _CharT, typename _Traits, typename _Alloc>
6033 : inline basic_string<_CharT, _Traits, _Alloc>
6034 : operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
6035 : _CharT __rhs)
6036 : { return std::move(__lhs.append(1, __rhs)); }
6037 : #endif
6038 :
6039 : // operator ==
6040 : /**
6041 : * @brief Test equivalence of two strings.
6042 : * @param __lhs First string.
6043 : * @param __rhs Second string.
6044 : * @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise.
6045 : */
6046 : template<typename _CharT, typename _Traits, typename _Alloc>
6047 : inline bool
6048 : operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6049 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6050 : _GLIBCXX_NOEXCEPT
6051 : { return __lhs.compare(__rhs) == 0; }
6052 :
6053 : template<typename _CharT>
6054 : inline
6055 : typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
6056 1018 : operator==(const basic_string<_CharT>& __lhs,
6057 : const basic_string<_CharT>& __rhs) _GLIBCXX_NOEXCEPT
6058 1018 : { return (__lhs.size() == __rhs.size()
6059 1018 : && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
6060 1018 : __lhs.size())); }
6061 :
6062 : /**
6063 : * @brief Test equivalence of C string and string.
6064 : * @param __lhs C string.
6065 : * @param __rhs String.
6066 : * @return True if @a __rhs.compare(@a __lhs) == 0. False otherwise.
6067 : */
6068 : template<typename _CharT, typename _Traits, typename _Alloc>
6069 : inline bool
6070 : operator==(const _CharT* __lhs,
6071 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6072 : { return __rhs.compare(__lhs) == 0; }
6073 :
6074 : /**
6075 : * @brief Test equivalence of string and C string.
6076 : * @param __lhs String.
6077 : * @param __rhs C string.
6078 : * @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise.
6079 : */
6080 : template<typename _CharT, typename _Traits, typename _Alloc>
6081 : inline bool
6082 : operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6083 : const _CharT* __rhs)
6084 : { return __lhs.compare(__rhs) == 0; }
6085 :
6086 : // operator !=
6087 : /**
6088 : * @brief Test difference of two strings.
6089 : * @param __lhs First string.
6090 : * @param __rhs Second string.
6091 : * @return True if @a __lhs.compare(@a __rhs) != 0. False otherwise.
6092 : */
6093 : template<typename _CharT, typename _Traits, typename _Alloc>
6094 : inline bool
6095 : operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6096 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6097 : _GLIBCXX_NOEXCEPT
6098 : { return !(__lhs == __rhs); }
6099 :
6100 : /**
6101 : * @brief Test difference of C string and string.
6102 : * @param __lhs C string.
6103 : * @param __rhs String.
6104 : * @return True if @a __rhs.compare(@a __lhs) != 0. False otherwise.
6105 : */
6106 : template<typename _CharT, typename _Traits, typename _Alloc>
6107 : inline bool
6108 : operator!=(const _CharT* __lhs,
6109 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6110 : { return !(__lhs == __rhs); }
6111 :
6112 : /**
6113 : * @brief Test difference of string and C string.
6114 : * @param __lhs String.
6115 : * @param __rhs C string.
6116 : * @return True if @a __lhs.compare(@a __rhs) != 0. False otherwise.
6117 : */
6118 : template<typename _CharT, typename _Traits, typename _Alloc>
6119 : inline bool
6120 : operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6121 : const _CharT* __rhs)
6122 : { return !(__lhs == __rhs); }
6123 :
6124 : // operator <
6125 : /**
6126 : * @brief Test if string precedes string.
6127 : * @param __lhs First string.
6128 : * @param __rhs Second string.
6129 : * @return True if @a __lhs precedes @a __rhs. False otherwise.
6130 : */
6131 : template<typename _CharT, typename _Traits, typename _Alloc>
6132 : inline bool
6133 : operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6134 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6135 : _GLIBCXX_NOEXCEPT
6136 : { return __lhs.compare(__rhs) < 0; }
6137 :
6138 : /**
6139 : * @brief Test if string precedes C string.
6140 : * @param __lhs String.
6141 : * @param __rhs C string.
6142 : * @return True if @a __lhs precedes @a __rhs. False otherwise.
6143 : */
6144 : template<typename _CharT, typename _Traits, typename _Alloc>
6145 : inline bool
6146 : operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6147 : const _CharT* __rhs)
6148 : { return __lhs.compare(__rhs) < 0; }
6149 :
6150 : /**
6151 : * @brief Test if C string precedes string.
6152 : * @param __lhs C string.
6153 : * @param __rhs String.
6154 : * @return True if @a __lhs precedes @a __rhs. False otherwise.
6155 : */
6156 : template<typename _CharT, typename _Traits, typename _Alloc>
6157 : inline bool
6158 : operator<(const _CharT* __lhs,
6159 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6160 : { return __rhs.compare(__lhs) > 0; }
6161 :
6162 : // operator >
6163 : /**
6164 : * @brief Test if string follows string.
6165 : * @param __lhs First string.
6166 : * @param __rhs Second string.
6167 : * @return True if @a __lhs follows @a __rhs. False otherwise.
6168 : */
6169 : template<typename _CharT, typename _Traits, typename _Alloc>
6170 : inline bool
6171 : operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6172 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6173 : _GLIBCXX_NOEXCEPT
6174 : { return __lhs.compare(__rhs) > 0; }
6175 :
6176 : /**
6177 : * @brief Test if string follows C string.
6178 : * @param __lhs String.
6179 : * @param __rhs C string.
6180 : * @return True if @a __lhs follows @a __rhs. False otherwise.
6181 : */
6182 : template<typename _CharT, typename _Traits, typename _Alloc>
6183 : inline bool
6184 : operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6185 : const _CharT* __rhs)
6186 : { return __lhs.compare(__rhs) > 0; }
6187 :
6188 : /**
6189 : * @brief Test if C string follows string.
6190 : * @param __lhs C string.
6191 : * @param __rhs String.
6192 : * @return True if @a __lhs follows @a __rhs. False otherwise.
6193 : */
6194 : template<typename _CharT, typename _Traits, typename _Alloc>
6195 : inline bool
6196 : operator>(const _CharT* __lhs,
6197 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6198 : { return __rhs.compare(__lhs) < 0; }
6199 :
6200 : // operator <=
6201 : /**
6202 : * @brief Test if string doesn't follow string.
6203 : * @param __lhs First string.
6204 : * @param __rhs Second string.
6205 : * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
6206 : */
6207 : template<typename _CharT, typename _Traits, typename _Alloc>
6208 : inline bool
6209 : operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6210 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6211 : _GLIBCXX_NOEXCEPT
6212 : { return __lhs.compare(__rhs) <= 0; }
6213 :
6214 : /**
6215 : * @brief Test if string doesn't follow C string.
6216 : * @param __lhs String.
6217 : * @param __rhs C string.
6218 : * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
6219 : */
6220 : template<typename _CharT, typename _Traits, typename _Alloc>
6221 : inline bool
6222 : operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6223 : const _CharT* __rhs)
6224 : { return __lhs.compare(__rhs) <= 0; }
6225 :
6226 : /**
6227 : * @brief Test if C string doesn't follow string.
6228 : * @param __lhs C string.
6229 : * @param __rhs String.
6230 : * @return True if @a __lhs doesn't follow @a __rhs. False otherwise.
6231 : */
6232 : template<typename _CharT, typename _Traits, typename _Alloc>
6233 : inline bool
6234 : operator<=(const _CharT* __lhs,
6235 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6236 : { return __rhs.compare(__lhs) >= 0; }
6237 :
6238 : // operator >=
6239 : /**
6240 : * @brief Test if string doesn't precede string.
6241 : * @param __lhs First string.
6242 : * @param __rhs Second string.
6243 : * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
6244 : */
6245 : template<typename _CharT, typename _Traits, typename _Alloc>
6246 : inline bool
6247 : operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6248 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6249 : _GLIBCXX_NOEXCEPT
6250 : { return __lhs.compare(__rhs) >= 0; }
6251 :
6252 : /**
6253 : * @brief Test if string doesn't precede C string.
6254 : * @param __lhs String.
6255 : * @param __rhs C string.
6256 : * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
6257 : */
6258 : template<typename _CharT, typename _Traits, typename _Alloc>
6259 : inline bool
6260 : operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
6261 : const _CharT* __rhs)
6262 : { return __lhs.compare(__rhs) >= 0; }
6263 :
6264 : /**
6265 : * @brief Test if C string doesn't precede string.
6266 : * @param __lhs C string.
6267 : * @param __rhs String.
6268 : * @return True if @a __lhs doesn't precede @a __rhs. False otherwise.
6269 : */
6270 : template<typename _CharT, typename _Traits, typename _Alloc>
6271 : inline bool
6272 : operator>=(const _CharT* __lhs,
6273 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)
6274 : { return __rhs.compare(__lhs) <= 0; }
6275 :
6276 : /**
6277 : * @brief Swap contents of two strings.
6278 : * @param __lhs First string.
6279 : * @param __rhs Second string.
6280 : *
6281 : * Exchanges the contents of @a __lhs and @a __rhs in constant time.
6282 : */
6283 : template<typename _CharT, typename _Traits, typename _Alloc>
6284 : inline void
6285 : swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
6286 : basic_string<_CharT, _Traits, _Alloc>& __rhs)
6287 : _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
6288 : { __lhs.swap(__rhs); }
6289 :
6290 :
6291 : /**
6292 : * @brief Read stream into a string.
6293 : * @param __is Input stream.
6294 : * @param __str Buffer to store into.
6295 : * @return Reference to the input stream.
6296 : *
6297 : * Stores characters from @a __is into @a __str until whitespace is
6298 : * found, the end of the stream is encountered, or str.max_size()
6299 : * is reached. If is.width() is non-zero, that is the limit on the
6300 : * number of characters stored into @a __str. Any previous
6301 : * contents of @a __str are erased.
6302 : */
6303 : template<typename _CharT, typename _Traits, typename _Alloc>
6304 : basic_istream<_CharT, _Traits>&
6305 : operator>>(basic_istream<_CharT, _Traits>& __is,
6306 : basic_string<_CharT, _Traits, _Alloc>& __str);
6307 :
6308 : template<>
6309 : basic_istream<char>&
6310 : operator>>(basic_istream<char>& __is, basic_string<char>& __str);
6311 :
6312 : /**
6313 : * @brief Write string to a stream.
6314 : * @param __os Output stream.
6315 : * @param __str String to write out.
6316 : * @return Reference to the output stream.
6317 : *
6318 : * Output characters of @a __str into os following the same rules as for
6319 : * writing a C string.
6320 : */
6321 : template<typename _CharT, typename _Traits, typename _Alloc>
6322 : inline basic_ostream<_CharT, _Traits>&
6323 : operator<<(basic_ostream<_CharT, _Traits>& __os,
6324 : const basic_string<_CharT, _Traits, _Alloc>& __str)
6325 : {
6326 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
6327 : // 586. string inserter not a formatted function
6328 : return __ostream_insert(__os, __str.data(), __str.size());
6329 : }
6330 :
6331 : /**
6332 : * @brief Read a line from stream into a string.
6333 : * @param __is Input stream.
6334 : * @param __str Buffer to store into.
6335 : * @param __delim Character marking end of line.
6336 : * @return Reference to the input stream.
6337 : *
6338 : * Stores characters from @a __is into @a __str until @a __delim is
6339 : * found, the end of the stream is encountered, or str.max_size()
6340 : * is reached. Any previous contents of @a __str are erased. If
6341 : * @a __delim is encountered, it is extracted but not stored into
6342 : * @a __str.
6343 : */
6344 : template<typename _CharT, typename _Traits, typename _Alloc>
6345 : basic_istream<_CharT, _Traits>&
6346 : getline(basic_istream<_CharT, _Traits>& __is,
6347 : basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
6348 :
6349 : /**
6350 : * @brief Read a line from stream into a string.
6351 : * @param __is Input stream.
6352 : * @param __str Buffer to store into.
6353 : * @return Reference to the input stream.
6354 : *
6355 : * Stores characters from is into @a __str until '\n' is
6356 : * found, the end of the stream is encountered, or str.max_size()
6357 : * is reached. Any previous contents of @a __str are erased. If
6358 : * end of line is encountered, it is extracted but not stored into
6359 : * @a __str.
6360 : */
6361 : template<typename _CharT, typename _Traits, typename _Alloc>
6362 : inline basic_istream<_CharT, _Traits>&
6363 : getline(basic_istream<_CharT, _Traits>& __is,
6364 : basic_string<_CharT, _Traits, _Alloc>& __str)
6365 : { return std::getline(__is, __str, __is.widen('\n')); }
6366 :
6367 : #if __cplusplus >= 201103L
6368 : /// Read a line from an rvalue stream into a string.
6369 : template<typename _CharT, typename _Traits, typename _Alloc>
6370 : inline basic_istream<_CharT, _Traits>&
6371 : getline(basic_istream<_CharT, _Traits>&& __is,
6372 : basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
6373 : { return std::getline(__is, __str, __delim); }
6374 :
6375 : /// Read a line from an rvalue stream into a string.
6376 : template<typename _CharT, typename _Traits, typename _Alloc>
6377 : inline basic_istream<_CharT, _Traits>&
6378 : getline(basic_istream<_CharT, _Traits>&& __is,
6379 : basic_string<_CharT, _Traits, _Alloc>& __str)
6380 : { return std::getline(__is, __str); }
6381 : #endif
6382 :
6383 : template<>
6384 : basic_istream<char>&
6385 : getline(basic_istream<char>& __in, basic_string<char>& __str,
6386 : char __delim);
6387 :
6388 : #ifdef _GLIBCXX_USE_WCHAR_T
6389 : template<>
6390 : basic_istream<wchar_t>&
6391 : getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
6392 : wchar_t __delim);
6393 : #endif
6394 :
6395 : _GLIBCXX_END_NAMESPACE_VERSION
6396 : } // namespace
6397 :
6398 : #if __cplusplus >= 201103L
6399 :
6400 : #include <ext/string_conversions.h>
6401 :
6402 : namespace std _GLIBCXX_VISIBILITY(default)
6403 : {
6404 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
6405 : _GLIBCXX_BEGIN_NAMESPACE_CXX11
6406 :
6407 : #if _GLIBCXX_USE_C99_STDLIB
6408 : // 21.4 Numeric Conversions [string.conversions].
6409 : inline int
6410 : stoi(const string& __str, size_t* __idx = 0, int __base = 10)
6411 : { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
6412 : __idx, __base); }
6413 :
6414 : inline long
6415 : stol(const string& __str, size_t* __idx = 0, int __base = 10)
6416 : { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
6417 : __idx, __base); }
6418 :
6419 : inline unsigned long
6420 : stoul(const string& __str, size_t* __idx = 0, int __base = 10)
6421 : { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
6422 : __idx, __base); }
6423 :
6424 : inline long long
6425 : stoll(const string& __str, size_t* __idx = 0, int __base = 10)
6426 : { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
6427 : __idx, __base); }
6428 :
6429 : inline unsigned long long
6430 : stoull(const string& __str, size_t* __idx = 0, int __base = 10)
6431 : { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
6432 : __idx, __base); }
6433 :
6434 : // NB: strtof vs strtod.
6435 : inline float
6436 : stof(const string& __str, size_t* __idx = 0)
6437 : { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
6438 :
6439 : inline double
6440 : stod(const string& __str, size_t* __idx = 0)
6441 : { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
6442 :
6443 : inline long double
6444 : stold(const string& __str, size_t* __idx = 0)
6445 : { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
6446 : #endif // _GLIBCXX_USE_C99_STDLIB
6447 :
6448 : #if _GLIBCXX_USE_C99_STDIO
6449 : // NB: (v)snprintf vs sprintf.
6450 :
6451 : // DR 1261.
6452 : inline string
6453 585 : to_string(int __val)
6454 : { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
6455 585 : "%d", __val); }
6456 :
6457 : inline string
6458 12 : to_string(unsigned __val)
6459 : { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
6460 : 4 * sizeof(unsigned),
6461 12 : "%u", __val); }
6462 :
6463 : inline string
6464 28 : to_string(long __val)
6465 : { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
6466 28 : "%ld", __val); }
6467 :
6468 : inline string
6469 : to_string(unsigned long __val)
6470 : { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
6471 : 4 * sizeof(unsigned long),
6472 : "%lu", __val); }
6473 :
6474 : inline string
6475 : to_string(long long __val)
6476 : { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
6477 : 4 * sizeof(long long),
6478 : "%lld", __val); }
6479 :
6480 : inline string
6481 : to_string(unsigned long long __val)
6482 : { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
6483 : 4 * sizeof(unsigned long long),
6484 : "%llu", __val); }
6485 :
6486 : inline string
6487 : to_string(float __val)
6488 : {
6489 : const int __n =
6490 : __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
6491 : return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
6492 : "%f", __val);
6493 : }
6494 :
6495 : inline string
6496 14 : to_string(double __val)
6497 : {
6498 14 : const int __n =
6499 : __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
6500 : return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
6501 14 : "%f", __val);
6502 : }
6503 :
6504 : inline string
6505 : to_string(long double __val)
6506 : {
6507 : const int __n =
6508 : __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
6509 : return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
6510 : "%Lf", __val);
6511 : }
6512 : #endif // _GLIBCXX_USE_C99_STDIO
6513 :
6514 : #if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_WCHAR
6515 : inline int
6516 : stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
6517 : { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
6518 : __idx, __base); }
6519 :
6520 : inline long
6521 : stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
6522 : { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
6523 : __idx, __base); }
6524 :
6525 : inline unsigned long
6526 : stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
6527 : { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
6528 : __idx, __base); }
6529 :
6530 : inline long long
6531 : stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
6532 : { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
6533 : __idx, __base); }
6534 :
6535 : inline unsigned long long
6536 : stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
6537 : { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
6538 : __idx, __base); }
6539 :
6540 : // NB: wcstof vs wcstod.
6541 : inline float
6542 : stof(const wstring& __str, size_t* __idx = 0)
6543 : { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
6544 :
6545 : inline double
6546 : stod(const wstring& __str, size_t* __idx = 0)
6547 : { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
6548 :
6549 : inline long double
6550 : stold(const wstring& __str, size_t* __idx = 0)
6551 : { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
6552 :
6553 : #ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF
6554 : // DR 1261.
6555 : inline wstring
6556 : to_wstring(int __val)
6557 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
6558 : L"%d", __val); }
6559 :
6560 : inline wstring
6561 : to_wstring(unsigned __val)
6562 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
6563 : 4 * sizeof(unsigned),
6564 : L"%u", __val); }
6565 :
6566 : inline wstring
6567 : to_wstring(long __val)
6568 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
6569 : L"%ld", __val); }
6570 :
6571 : inline wstring
6572 : to_wstring(unsigned long __val)
6573 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
6574 : 4 * sizeof(unsigned long),
6575 : L"%lu", __val); }
6576 :
6577 : inline wstring
6578 : to_wstring(long long __val)
6579 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
6580 : 4 * sizeof(long long),
6581 : L"%lld", __val); }
6582 :
6583 : inline wstring
6584 : to_wstring(unsigned long long __val)
6585 : { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
6586 : 4 * sizeof(unsigned long long),
6587 : L"%llu", __val); }
6588 :
6589 : inline wstring
6590 : to_wstring(float __val)
6591 : {
6592 : const int __n =
6593 : __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
6594 : return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
6595 : L"%f", __val);
6596 : }
6597 :
6598 : inline wstring
6599 : to_wstring(double __val)
6600 : {
6601 : const int __n =
6602 : __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
6603 : return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
6604 : L"%f", __val);
6605 : }
6606 :
6607 : inline wstring
6608 : to_wstring(long double __val)
6609 : {
6610 : const int __n =
6611 : __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
6612 : return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
6613 : L"%Lf", __val);
6614 : }
6615 : #endif // _GLIBCXX_HAVE_BROKEN_VSWPRINTF
6616 : #endif // _GLIBCXX_USE_WCHAR_T && _GLIBCXX_USE_C99_WCHAR
6617 :
6618 : _GLIBCXX_END_NAMESPACE_CXX11
6619 : _GLIBCXX_END_NAMESPACE_VERSION
6620 : } // namespace
6621 :
6622 : #endif /* C++11 */
6623 :
6624 : #if __cplusplus >= 201103L
6625 :
6626 : #include <bits/functional_hash.h>
6627 :
6628 : namespace std _GLIBCXX_VISIBILITY(default)
6629 : {
6630 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
6631 :
6632 : // DR 1182.
6633 :
6634 : #ifndef _GLIBCXX_COMPATIBILITY_CXX0X
6635 : /// std::hash specialization for string.
6636 : template<>
6637 : struct hash<string>
6638 : : public __hash_base<size_t, string>
6639 : {
6640 : size_t
6641 1558 : operator()(const string& __s) const noexcept
6642 1558 : { return std::_Hash_impl::hash(__s.data(), __s.length()); }
6643 : };
6644 :
6645 : template<>
6646 : struct __is_fast_hash<hash<string>> : std::false_type
6647 : { };
6648 :
6649 : #ifdef _GLIBCXX_USE_WCHAR_T
6650 : /// std::hash specialization for wstring.
6651 : template<>
6652 : struct hash<wstring>
6653 : : public __hash_base<size_t, wstring>
6654 : {
6655 : size_t
6656 : operator()(const wstring& __s) const noexcept
6657 : { return std::_Hash_impl::hash(__s.data(),
6658 : __s.length() * sizeof(wchar_t)); }
6659 : };
6660 :
6661 : template<>
6662 : struct __is_fast_hash<hash<wstring>> : std::false_type
6663 : { };
6664 : #endif
6665 : #endif /* _GLIBCXX_COMPATIBILITY_CXX0X */
6666 :
6667 : #ifdef _GLIBCXX_USE_C99_STDINT_TR1
6668 : /// std::hash specialization for u16string.
6669 : template<>
6670 : struct hash<u16string>
6671 : : public __hash_base<size_t, u16string>
6672 : {
6673 : size_t
6674 : operator()(const u16string& __s) const noexcept
6675 : { return std::_Hash_impl::hash(__s.data(),
6676 : __s.length() * sizeof(char16_t)); }
6677 : };
6678 :
6679 : template<>
6680 : struct __is_fast_hash<hash<u16string>> : std::false_type
6681 : { };
6682 :
6683 : /// std::hash specialization for u32string.
6684 : template<>
6685 : struct hash<u32string>
6686 : : public __hash_base<size_t, u32string>
6687 : {
6688 : size_t
6689 : operator()(const u32string& __s) const noexcept
6690 : { return std::_Hash_impl::hash(__s.data(),
6691 : __s.length() * sizeof(char32_t)); }
6692 : };
6693 :
6694 : template<>
6695 : struct __is_fast_hash<hash<u32string>> : std::false_type
6696 : { };
6697 : #endif
6698 :
6699 : #if __cplusplus > 201103L
6700 :
6701 : #define __cpp_lib_string_udls 201304
6702 :
6703 : inline namespace literals
6704 : {
6705 : inline namespace string_literals
6706 : {
6707 : #pragma GCC diagnostic push
6708 : #pragma GCC diagnostic ignored "-Wliteral-suffix"
6709 : _GLIBCXX_DEFAULT_ABI_TAG
6710 : inline basic_string<char>
6711 : operator""s(const char* __str, size_t __len)
6712 : { return basic_string<char>{__str, __len}; }
6713 :
6714 : #ifdef _GLIBCXX_USE_WCHAR_T
6715 : _GLIBCXX_DEFAULT_ABI_TAG
6716 : inline basic_string<wchar_t>
6717 : operator""s(const wchar_t* __str, size_t __len)
6718 : { return basic_string<wchar_t>{__str, __len}; }
6719 : #endif
6720 :
6721 : #ifdef _GLIBCXX_USE_C99_STDINT_TR1
6722 : _GLIBCXX_DEFAULT_ABI_TAG
6723 : inline basic_string<char16_t>
6724 : operator""s(const char16_t* __str, size_t __len)
6725 : { return basic_string<char16_t>{__str, __len}; }
6726 :
6727 : _GLIBCXX_DEFAULT_ABI_TAG
6728 : inline basic_string<char32_t>
6729 : operator""s(const char32_t* __str, size_t __len)
6730 : { return basic_string<char32_t>{__str, __len}; }
6731 : #endif
6732 :
6733 : #pragma GCC diagnostic pop
6734 : } // inline namespace string_literals
6735 : } // inline namespace literals
6736 :
6737 : #endif // __cplusplus > 201103L
6738 :
6739 : _GLIBCXX_END_NAMESPACE_VERSION
6740 : } // namespace std
6741 :
6742 : #endif // C++11
6743 :
6744 : #endif /* _BASIC_STRING_H */
|
