LCOV - code coverage report
Current view: top level - usr/include/c++/9/bits - basic_string.h (source / functions) Hit Total Coverage
Test: ROSE Lines: 184 250 73.6 %
Date: 2022-12-08 13:48:47 Functions: 9 16 56.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14