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