LCOV - code coverage report
Current view: directory - tools/gcc-4.5/include/c++/4.5.2/bits - basic_string.h (source / functions) Found Hit Coverage
Test: app.info Lines: 330 30 9.1 %
Date: 2012-06-02 Functions: 345 13 3.8 %

       1                 : // Components for manipulating sequences of characters -*- C++ -*-
       2                 : 
       3                 : // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
       4                 : // 2006, 2007, 2008, 2009, 2010
       5                 : // Free Software Foundation, Inc.
       6                 : //
       7                 : // This file is part of the GNU ISO C++ Library.  This library is free
       8                 : // software; you can redistribute it and/or modify it under the
       9                 : // terms of the GNU General Public License as published by the
      10                 : // Free Software Foundation; either version 3, or (at your option)
      11                 : // any later version.
      12                 : 
      13                 : // This library is distributed in the hope that it will be useful,
      14                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 : // GNU General Public License for more details.
      17                 : 
      18                 : // Under Section 7 of GPL version 3, you are granted additional
      19                 : // permissions described in the GCC Runtime Library Exception, version
      20                 : // 3.1, as published by the Free Software Foundation.
      21                 : 
      22                 : // You should have received a copy of the GNU General Public License and
      23                 : // a copy of the GCC Runtime Library Exception along with this program;
      24                 : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      25                 : // <http://www.gnu.org/licenses/>.
      26                 : 
      27                 : /** @file basic_string.h
      28                 :  *  This is an internal header file, included by other library headers.
      29                 :  *  You should not attempt to use it directly.
      30                 :  */
      31                 : 
      32                 : //
      33                 : // ISO C++ 14882: 21 Strings library
      34                 : //
      35                 : 
      36                 : #ifndef _BASIC_STRING_H
      37                 : #define _BASIC_STRING_H 1
      38                 : 
      39                 : #pragma GCC system_header
      40                 : 
      41                 : #include <ext/atomicity.h>
      42                 : #include <debug/debug.h>
      43                 : #include <initializer_list>
      44                 : 
      45                 : _GLIBCXX_BEGIN_NAMESPACE(std)
      46                 : 
      47                 :   /**
      48                 :    *  @class basic_string basic_string.h <string>
      49                 :    *  @brief  Managing sequences of characters and character-like objects.
      50                 :    *
      51                 :    *  @ingroup strings
      52                 :    *  @ingroup sequences
      53                 :    *
      54                 :    *  Meets the requirements of a <a href="tables.html#65">container</a>, a
      55                 :    *  <a href="tables.html#66">reversible container</a>, and a
      56                 :    *  <a href="tables.html#67">sequence</a>.  Of the
      57                 :    *  <a href="tables.html#68">optional sequence requirements</a>, only
      58                 :    *  @c push_back, @c at, and @c %array access are supported.
      59                 :    *
      60                 :    *  @doctodo
      61                 :    *
      62                 :    *
      63                 :    *  Documentation?  What's that?
      64                 :    *  Nathan Myers <ncm@cantrip.org>.
      65                 :    *
      66                 :    *  A string looks like this:
      67                 :    *
      68                 :    *  @code
      69                 :    *                                        [_Rep]
      70                 :    *                                        _M_length
      71                 :    *   [basic_string<char_type>]            _M_capacity
      72                 :    *   _M_dataplus                          _M_refcount
      73                 :    *   _M_p ---------------->               unnamed array of char_type
      74                 :    *  @endcode
      75                 :    *
      76                 :    *  Where the _M_p points to the first character in the string, and
      77                 :    *  you cast it to a pointer-to-_Rep and subtract 1 to get a
      78                 :    *  pointer to the header.
      79                 :    *
      80                 :    *  This approach has the enormous advantage that a string object
      81                 :    *  requires only one allocation.  All the ugliness is confined
      82                 :    *  within a single %pair of inline functions, which each compile to
      83                 :    *  a single @a add instruction: _Rep::_M_data(), and
      84                 :    *  string::_M_rep(); and the allocation function which gets a
      85                 :    *  block of raw bytes and with room enough and constructs a _Rep
      86                 :    *  object at the front.
      87                 :    *
      88                 :    *  The reason you want _M_data pointing to the character %array and
      89                 :    *  not the _Rep is so that the debugger can see the string
      90                 :    *  contents. (Probably we should add a non-inline member to get
      91                 :    *  the _Rep for the debugger to use, so users can check the actual
      92                 :    *  string length.)
      93                 :    *
      94                 :    *  Note that the _Rep object is a POD so that you can have a
      95                 :    *  static <em>empty string</em> _Rep object already @a constructed before
      96                 :    *  static constructors have run.  The reference-count encoding is
      97                 :    *  chosen so that a 0 indicates one reference, so you never try to
      98                 :    *  destroy the empty-string _Rep object.
      99                 :    *
     100                 :    *  All but the last paragraph is considered pretty conventional
     101                 :    *  for a C++ string implementation.
     102                 :   */
     103                 :   // 21.3  Template class basic_string
     104                 :   template<typename _CharT, typename _Traits, typename _Alloc>
     105                 :     class basic_string
     106                 :     {
     107                 :       typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
     108                 : 
     109                 :       // Types:
     110                 :     public:
     111                 :       typedef _Traits                                       traits_type;
     112                 :       typedef typename _Traits::char_type                   value_type;
     113                 :       typedef _Alloc                                        allocator_type;
     114                 :       typedef typename _CharT_alloc_type::size_type         size_type;
     115                 :       typedef typename _CharT_alloc_type::difference_type   difference_type;
     116                 :       typedef typename _CharT_alloc_type::reference         reference;
     117                 :       typedef typename _CharT_alloc_type::const_reference   const_reference;
     118                 :       typedef typename _CharT_alloc_type::pointer           pointer;
     119                 :       typedef typename _CharT_alloc_type::const_pointer     const_pointer;
     120                 :       typedef __gnu_cxx::__normal_iterator<pointer, basic_string>  iterator;
     121                 :       typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
     122                 :                                                             const_iterator;
     123                 :       typedef std::reverse_iterator<const_iterator>       const_reverse_iterator;
     124                 :       typedef std::reverse_iterator<iterator>                 reverse_iterator;
     125                 : 
     126                 :     private:
     127                 :       // _Rep: string representation
     128                 :       //   Invariants:
     129                 :       //   1. String really contains _M_length + 1 characters: due to 21.3.4
     130                 :       //      must be kept null-terminated.
     131                 :       //   2. _M_capacity >= _M_length
     132                 :       //      Allocated memory is always (_M_capacity + 1) * sizeof(_CharT).
     133                 :       //   3. _M_refcount has three states:
     134                 :       //      -1: leaked, one reference, no ref-copies allowed, non-const.
     135                 :       //       0: one reference, non-const.
     136                 :       //     n>0: n + 1 references, operations require a lock, const.
     137                 :       //   4. All fields==0 is an empty string, given the extra storage
     138                 :       //      beyond-the-end for a null terminator; thus, the shared
     139                 :       //      empty string representation needs no constructor.
     140                 : 
     141                 :       struct _Rep_base
     142                 :       {
     143                 :         size_type               _M_length;
     144                 :         size_type               _M_capacity;
     145                 :         _Atomic_word            _M_refcount;
     146                 :       };
     147                 : 
     148                 :       struct _Rep : _Rep_base
     149                 :       {
     150                 :         // Types:
     151                 :         typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
     152                 : 
     153                 :         // (Public) Data members:
     154                 : 
     155                 :         // The maximum number of individual char_type elements of an
     156                 :         // individual string is determined by _S_max_size. This is the
     157                 :         // value that will be returned by max_size().  (Whereas npos
     158                 :         // is the maximum number of bytes the allocator can allocate.)
     159                 :         // If one was to divvy up the theoretical largest size string,
     160                 :         // with a terminating character and m _CharT elements, it'd
     161                 :         // look like this:
     162                 :         // npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT)
     163                 :         // Solving for m:
     164                 :         // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1
     165                 :         // In addition, this implementation quarters this amount.
     166                 :         static const size_type  _S_max_size;
     167                 :         static const _CharT     _S_terminal;
     168                 : 
     169                 :         // The following storage is init'd to 0 by the linker, resulting
     170                 :         // (carefully) in an empty string with one reference.
     171                 :         static size_type _S_empty_rep_storage[];
     172                 : 
     173                 :         static _Rep&
     174               0 :         _S_empty_rep()
     175                 :         { 
     176                 :           // NB: Mild hack to avoid strict-aliasing warnings.  Note that
     177                 :           // _S_empty_rep_storage is never modified and the punning should
     178                 :           // be reasonably safe in this case.
     179               0 :           void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
     180               0 :           return *reinterpret_cast<_Rep*>(__p);
     181                 :         }
     182                 : 
     183                 :         bool
     184               0 :         _M_is_leaked() const
     185               0 :         { return this->_M_refcount < 0; }
     186                 : 
     187                 :         bool
     188               0 :         _M_is_shared() const
     189               0 :         { return this->_M_refcount > 0; }
     190                 : 
     191                 :         void
     192               0 :         _M_set_leaked()
     193               0 :         { this->_M_refcount = -1; }
     194                 : 
     195                 :         void
     196               0 :         _M_set_sharable()
     197               0 :         { this->_M_refcount = 0; }
     198                 : 
     199                 :         void
     200               0 :         _M_set_length_and_sharable(size_type __n)
     201                 :         {
     202                 : #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING
     203               0 :           if (__builtin_expect(this != &_S_empty_rep(), false))
     204                 : #endif
     205                 :             {
     206               0 :               this->_M_set_sharable();  // One reference.
     207               0 :               this->_M_length = __n;
     208               0 :               traits_type::assign(this->_M_refdata()[__n], _S_terminal);
     209                 :               // grrr. (per 21.3.4)
     210                 :               // You cannot leave those LWG people alone for a second.
     211                 :             }
     212               0 :         }
     213                 : 
     214                 :         _CharT*
     215               0 :         _M_refdata() throw()
     216               0 :         { return reinterpret_cast<_CharT*>(this + 1); }
     217                 : 
     218                 :         _CharT*
     219               0 :         _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
     220                 :         {
     221                 :           return (!_M_is_leaked() && __alloc1 == __alloc2)
     222               0 :                   ? _M_refcopy() : _M_clone(__alloc1);
     223                 :         }
     224                 : 
     225                 :         // Create & Destroy
     226                 :         static _Rep*
     227                 :         _S_create(size_type, size_type, const _Alloc&);
     228                 : 
     229                 :         void
     230               0 :         _M_dispose(const _Alloc& __a)
     231                 :         {
     232                 : #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING
     233               0 :           if (__builtin_expect(this != &_S_empty_rep(), false))
     234                 : #endif
     235               0 :             if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
     236                 :                                                        -1) <= 0)
     237               0 :               _M_destroy(__a);
     238               0 :         }  // XXX MT
     239                 : 
     240                 :         void
     241                 :         _M_destroy(const _Alloc&) throw();
     242                 : 
     243                 :         _CharT*
     244               0 :         _M_refcopy() throw()
     245                 :         {
     246                 : #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING
     247               0 :           if (__builtin_expect(this != &_S_empty_rep(), false))
     248                 : #endif
     249               0 :             __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
     250               0 :           return _M_refdata();
     251                 :         }  // XXX MT
     252                 : 
     253                 :         _CharT*
     254                 :         _M_clone(const _Alloc&, size_type __res = 0);
     255                 :       };
     256                 : 
     257                 :       // Use empty-base optimization: http://www.cantrip.org/emptyopt.html
     258                 :       struct _Alloc_hider : _Alloc
     259            1634 :       {
     260               0 :         _Alloc_hider(_CharT* __dat, const _Alloc& __a)
     261               0 :         : _Alloc(__a), _M_p(__dat) { }
     262                 : 
     263                 :         _CharT* _M_p; // The actual data.
     264                 :       };
     265                 : 
     266                 :     public:
     267                 :       // Data Members (public):
     268                 :       // NB: This is an unsigned type, and thus represents the maximum
     269                 :       // size that the allocator can hold.
     270                 :       ///  Value returned by various member functions when they fail.
     271                 :       static const size_type    npos = static_cast<size_type>(-1);
     272                 : 
     273                 :     private:
     274                 :       // Data Members (private):
     275                 :       mutable _Alloc_hider      _M_dataplus;
     276                 : 
     277                 :       _CharT*
     278               0 :       _M_data() const
     279               0 :       { return  _M_dataplus._M_p; }
     280                 : 
     281                 :       _CharT*
     282               0 :       _M_data(_CharT* __p)
     283               0 :       { return (_M_dataplus._M_p = __p); }
     284                 : 
     285                 :       _Rep*
     286               0 :       _M_rep() const
     287               0 :       { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
     288                 : 
     289                 :       // For the internal use we have functions similar to `begin'/`end'
     290                 :       // but they do not call _M_leak.
     291                 :       iterator
     292               0 :       _M_ibegin() const
     293               0 :       { return iterator(_M_data()); }
     294                 : 
     295                 :       iterator
     296               0 :       _M_iend() const
     297               0 :       { return iterator(_M_data() + this->size()); }
     298                 : 
     299                 :       void
     300               0 :       _M_leak()    // for use in begin() & non-const op[]
     301                 :       {
     302               0 :         if (!_M_rep()->_M_is_leaked())
     303               0 :           _M_leak_hard();
     304               0 :       }
     305                 : 
     306                 :       size_type
     307               0 :       _M_check(size_type __pos, const char* __s) const
     308                 :       {
     309               0 :         if (__pos > this->size())
     310               0 :           __throw_out_of_range(__N(__s));
     311               0 :         return __pos;
     312                 :       }
     313                 : 
     314                 :       void
     315               0 :       _M_check_length(size_type __n1, size_type __n2, const char* __s) const
     316                 :       {
     317               0 :         if (this->max_size() - (this->size() - __n1) < __n2)
     318               0 :           __throw_length_error(__N(__s));
     319               0 :       }
     320                 : 
     321                 :       // NB: _M_limit doesn't check for a bad __pos value.
     322                 :       size_type
     323               0 :       _M_limit(size_type __pos, size_type __off) const
     324                 :       {
     325               0 :         const bool __testoff =  __off < this->size() - __pos;
     326               0 :         return __testoff ? __off : this->size() - __pos;
     327                 :       }
     328                 : 
     329                 :       // True if _Rep and source do not overlap.
     330                 :       bool
     331               0 :       _M_disjunct(const _CharT* __s) const
     332                 :       {
     333                 :         return (less<const _CharT*>()(__s, _M_data())
     334               0 :                 || less<const _CharT*>()(_M_data() + this->size(), __s));
     335                 :       }
     336                 : 
     337                 :       // When __n = 1 way faster than the general multichar
     338                 :       // traits_type::copy/move/assign.
     339                 :       static void
     340               0 :       _M_copy(_CharT* __d, const _CharT* __s, size_type __n)
     341                 :       {
     342               0 :         if (__n == 1)
     343               0 :           traits_type::assign(*__d, *__s);
     344                 :         else
     345               0 :           traits_type::copy(__d, __s, __n);
     346               0 :       }
     347                 : 
     348                 :       static void
     349               0 :       _M_move(_CharT* __d, const _CharT* __s, size_type __n)
     350                 :       {
     351               0 :         if (__n == 1)
     352               0 :           traits_type::assign(*__d, *__s);
     353                 :         else
     354               0 :           traits_type::move(__d, __s, __n);       
     355               0 :       }
     356                 : 
     357                 :       static void
     358               0 :       _M_assign(_CharT* __d, size_type __n, _CharT __c)
     359                 :       {
     360               0 :         if (__n == 1)
     361               0 :           traits_type::assign(*__d, __c);
     362                 :         else
     363               0 :           traits_type::assign(__d, __n, __c);     
     364               0 :       }
     365                 : 
     366                 :       // _S_copy_chars is a separate template to permit specialization
     367                 :       // to optimize for the common case of pointers as iterators.
     368                 :       template<class _Iterator>
     369                 :         static void
     370               2 :         _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
     371                 :         {
     372              21 :           for (; __k1 != __k2; ++__k1, ++__p)
     373              19 :             traits_type::assign(*__p, *__k1); // These types are off.
     374               2 :         }
     375                 : 
     376                 :       static void
     377               0 :       _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
     378               0 :       { _S_copy_chars(__p, __k1.base(), __k2.base()); }
     379                 : 
     380                 :       static void
     381               0 :       _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
     382               0 :       { _S_copy_chars(__p, __k1.base(), __k2.base()); }
     383                 : 
     384                 :       static void
     385               0 :       _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
     386               0 :       { _M_copy(__p, __k1, __k2 - __k1); }
     387                 : 
     388                 :       static void
     389               0 :       _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
     390               0 :       { _M_copy(__p, __k1, __k2 - __k1); }
     391                 : 
     392                 :       static int
     393               0 :       _S_compare(size_type __n1, size_type __n2)
     394                 :       {
     395               0 :         const difference_type __d = difference_type(__n1 - __n2);
     396                 : 
     397                 :         if (__d > __gnu_cxx::__numeric_traits<int>::__max)
     398                 :           return __gnu_cxx::__numeric_traits<int>::__max;
     399                 :         else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
     400                 :           return __gnu_cxx::__numeric_traits<int>::__min;
     401                 :         else
     402               0 :           return int(__d);
     403                 :       }
     404                 : 
     405                 :       void
     406                 :       _M_mutate(size_type __pos, size_type __len1, size_type __len2);
     407                 : 
     408                 :       void
     409                 :       _M_leak_hard();
     410                 : 
     411                 :       static _Rep&
     412               0 :       _S_empty_rep()
     413               0 :       { return _Rep::_S_empty_rep(); }
     414                 : 
     415                 :     public:
     416                 :       // Construct/copy/destroy:
     417                 :       // NB: We overload ctors in some cases instead of using default
     418                 :       // arguments, per 17.4.4.4 para. 2 item 2.
     419                 : 
     420                 :       /**
     421                 :        *  @brief  Default constructor creates an empty string.
     422                 :        */
     423               0 :       basic_string()
     424                 : #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING
     425               0 :       : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
     426                 : #else
     427                 :       : _M_dataplus(_S_construct(size_type(), _CharT(), _Alloc()), _Alloc()){ }
     428                 : #endif
     429                 : 
     430                 :       /**
     431                 :        *  @brief  Construct an empty string using allocator @a a.
     432                 :        */
     433                 :       explicit
     434                 :       basic_string(const _Alloc& __a);
     435                 : 
     436                 :       // NB: per LWG issue 42, semantics different from IS:
     437                 :       /**
     438                 :        *  @brief  Construct string with copy of value of @a str.
     439                 :        *  @param  str  Source string.
     440                 :        */
     441                 :       basic_string(const basic_string& __str);
     442                 :       /**
     443                 :        *  @brief  Construct string as copy of a substring.
     444                 :        *  @param  str  Source string.
     445                 :        *  @param  pos  Index of first character to copy from.
     446                 :        *  @param  n  Number of characters to copy (default remainder).
     447                 :        */
     448                 :       basic_string(const basic_string& __str, size_type __pos,
     449                 :                    size_type __n = npos);
     450                 :       /**
     451                 :        *  @brief  Construct string as copy of a substring.
     452                 :        *  @param  str  Source string.
     453                 :        *  @param  pos  Index of first character to copy from.
     454                 :        *  @param  n  Number of characters to copy.
     455                 :        *  @param  a  Allocator to use.
     456                 :        */
     457                 :       basic_string(const basic_string& __str, size_type __pos,
     458                 :                    size_type __n, const _Alloc& __a);
     459                 : 
     460                 :       /**
     461                 :        *  @brief  Construct string initialized by a character %array.
     462                 :        *  @param  s  Source character %array.
     463                 :        *  @param  n  Number of characters to copy.
     464                 :        *  @param  a  Allocator to use (default is default allocator).
     465                 :        *
     466                 :        *  NB: @a s must have at least @a n characters, &apos;\\0&apos;
     467                 :        *  has no special meaning.
     468                 :        */
     469                 :       basic_string(const _CharT* __s, size_type __n,
     470                 :                    const _Alloc& __a = _Alloc());
     471                 :       /**
     472                 :        *  @brief  Construct string as copy of a C string.
     473                 :        *  @param  s  Source C string.
     474                 :        *  @param  a  Allocator to use (default is default allocator).
     475                 :        */
     476                 :       basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
     477                 :       /**
     478                 :        *  @brief  Construct string as multiple characters.
     479                 :        *  @param  n  Number of characters.
     480                 :        *  @param  c  Character to use.
     481                 :        *  @param  a  Allocator to use (default is default allocator).
     482                 :        */
     483                 :       basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
     484                 : 
     485                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     486                 :       /**
     487                 :        *  @brief  Move construct string.
     488                 :        *  @param  str  Source string.
     489                 :        *
     490                 :        *  The newly-created string contains the exact contents of @a str.
     491                 :        *  @a str is a valid, but unspecified string.
     492                 :        **/
     493            1634 :       basic_string(basic_string&& __str)
     494            1634 :       : _M_dataplus(__str._M_dataplus)
     495                 :       {
     496                 : #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING   
     497            1634 :         __str._M_data(_S_empty_rep()._M_refdata());
     498                 : #else
     499                 :         __str._M_data(_S_construct(size_type(), _CharT(), get_allocator()));
     500                 : #endif
     501            1634 :       }
     502                 : 
     503                 :       /**
     504                 :        *  @brief  Construct string from an initializer %list.
     505                 :        *  @param  l  std::initializer_list of characters.
     506                 :        *  @param  a  Allocator to use (default is default allocator).
     507                 :        */
     508                 :       basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc());
     509                 : #endif // __GXX_EXPERIMENTAL_CXX0X__
     510                 : 
     511                 :       /**
     512                 :        *  @brief  Construct string as copy of a range.
     513                 :        *  @param  beg  Start of range.
     514                 :        *  @param  end  End of range.
     515                 :        *  @param  a  Allocator to use (default is default allocator).
     516                 :        */
     517                 :       template<class _InputIterator>
     518                 :         basic_string(_InputIterator __beg, _InputIterator __end,
     519                 :                      const _Alloc& __a = _Alloc());
     520                 : 
     521                 :       /**
     522                 :        *  @brief  Destroy the string instance.
     523                 :        */
     524               0 :       ~basic_string()
     525               0 :       { _M_rep()->_M_dispose(this->get_allocator()); }
     526                 : 
     527                 :       /**
     528                 :        *  @brief  Assign the value of @a str to this string.
     529                 :        *  @param  str  Source string.
     530                 :        */
     531                 :       basic_string&
     532               0 :       operator=(const basic_string& __str) 
     533               0 :       { return this->assign(__str); }
     534                 : 
     535                 :       /**
     536                 :        *  @brief  Copy contents of @a s into this string.
     537                 :        *  @param  s  Source null-terminated string.
     538                 :        */
     539                 :       basic_string&
     540               0 :       operator=(const _CharT* __s) 
     541               0 :       { return this->assign(__s); }
     542                 : 
     543                 :       /**
     544                 :        *  @brief  Set value to string of length 1.
     545                 :        *  @param  c  Source character.
     546                 :        *
     547                 :        *  Assigning to a character makes this string length 1 and
     548                 :        *  (*this)[0] == @a c.
     549                 :        */
     550                 :       basic_string&
     551               0 :       operator=(_CharT __c) 
     552                 :       { 
     553               0 :         this->assign(1, __c); 
     554               0 :         return *this;
     555                 :       }
     556                 : 
     557                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     558                 :       /**
     559                 :        *  @brief  Move assign the value of @a str to this string.
     560                 :        *  @param  str  Source string.
     561                 :        *
     562                 :        *  The contents of @a str are moved into this string (without copying).
     563                 :        *  @a str is a valid, but unspecified string.
     564                 :        **/
     565                 :       basic_string&
     566              27 :       operator=(basic_string&& __str)
     567                 :       {
     568                 :         // NB: DR 1204.
     569              27 :         this->swap(__str);
     570              27 :         return *this;
     571                 :       }
     572                 : 
     573                 :       /**
     574                 :        *  @brief  Set value to string constructed from initializer %list.
     575                 :        *  @param  l  std::initializer_list.
     576                 :        */
     577                 :       basic_string&
     578               0 :       operator=(initializer_list<_CharT> __l)
     579                 :       {
     580               0 :         this->assign(__l.begin(), __l.size());
     581               0 :         return *this;
     582                 :       }
     583                 : #endif // __GXX_EXPERIMENTAL_CXX0X__
     584                 : 
     585                 :       // Iterators:
     586                 :       /**
     587                 :        *  Returns a read/write iterator that points to the first character in
     588                 :        *  the %string.  Unshares the string.
     589                 :        */
     590                 :       iterator
     591               0 :       begin()
     592                 :       {
     593               0 :         _M_leak();
     594               0 :         return iterator(_M_data());
     595                 :       }
     596                 : 
     597                 :       /**
     598                 :        *  Returns a read-only (constant) iterator that points to the first
     599                 :        *  character in the %string.
     600                 :        */
     601                 :       const_iterator
     602               0 :       begin() const
     603               0 :       { return const_iterator(_M_data()); }
     604                 : 
     605                 :       /**
     606                 :        *  Returns a read/write iterator that points one past the last
     607                 :        *  character in the %string.  Unshares the string.
     608                 :        */
     609                 :       iterator
     610               0 :       end()
     611                 :       {
     612               0 :         _M_leak();
     613               0 :         return iterator(_M_data() + this->size());
     614                 :       }
     615                 : 
     616                 :       /**
     617                 :        *  Returns a read-only (constant) iterator that points one past the
     618                 :        *  last character in the %string.
     619                 :        */
     620                 :       const_iterator
     621               0 :       end() const
     622               0 :       { return const_iterator(_M_data() + this->size()); }
     623                 : 
     624                 :       /**
     625                 :        *  Returns a read/write reverse iterator that points to the last
     626                 :        *  character in the %string.  Iteration is done in reverse element
     627                 :        *  order.  Unshares the string.
     628                 :        */
     629                 :       reverse_iterator
     630               0 :       rbegin()
     631               0 :       { return reverse_iterator(this->end()); }
     632                 : 
     633                 :       /**
     634                 :        *  Returns a read-only (constant) reverse iterator that points
     635                 :        *  to the last character in the %string.  Iteration is done in
     636                 :        *  reverse element order.
     637                 :        */
     638                 :       const_reverse_iterator
     639               0 :       rbegin() const
     640               0 :       { return const_reverse_iterator(this->end()); }
     641                 : 
     642                 :       /**
     643                 :        *  Returns a read/write reverse iterator that points to one before the
     644                 :        *  first character in the %string.  Iteration is done in reverse
     645                 :        *  element order.  Unshares the string.
     646                 :        */
     647                 :       reverse_iterator
     648               0 :       rend()
     649               0 :       { return reverse_iterator(this->begin()); }
     650                 : 
     651                 :       /**
     652                 :        *  Returns a read-only (constant) reverse iterator that points
     653                 :        *  to one before the first character in the %string.  Iteration
     654                 :        *  is done in reverse element order.
     655                 :        */
     656                 :       const_reverse_iterator
     657               0 :       rend() const
     658               0 :       { return const_reverse_iterator(this->begin()); }
     659                 : 
     660                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     661                 :       /**
     662                 :        *  Returns a read-only (constant) iterator that points to the first
     663                 :        *  character in the %string.
     664                 :        */
     665                 :       const_iterator
     666               0 :       cbegin() const
     667               0 :       { return const_iterator(this->_M_data()); }
     668                 : 
     669                 :       /**
     670                 :        *  Returns a read-only (constant) iterator that points one past the
     671                 :        *  last character in the %string.
     672                 :        */
     673                 :       const_iterator
     674               0 :       cend() const
     675               0 :       { return const_iterator(this->_M_data() + this->size()); }
     676                 : 
     677                 :       /**
     678                 :        *  Returns a read-only (constant) reverse iterator that points
     679                 :        *  to the last character in the %string.  Iteration is done in
     680                 :        *  reverse element order.
     681                 :        */
     682                 :       const_reverse_iterator
     683               0 :       crbegin() const
     684               0 :       { return const_reverse_iterator(this->end()); }
     685                 : 
     686                 :       /**
     687                 :        *  Returns a read-only (constant) reverse iterator that points
     688                 :        *  to one before the first character in the %string.  Iteration
     689                 :        *  is done in reverse element order.
     690                 :        */
     691                 :       const_reverse_iterator
     692               0 :       crend() const
     693               0 :       { return const_reverse_iterator(this->begin()); }
     694                 : #endif
     695                 : 
     696                 :     public:
     697                 :       // Capacity:
     698                 :       ///  Returns the number of characters in the string, not including any
     699                 :       ///  null-termination.
     700                 :       size_type
     701               0 :       size() const
     702               0 :       { return _M_rep()->_M_length; }
     703                 : 
     704                 :       ///  Returns the number of characters in the string, not including any
     705                 :       ///  null-termination.
     706                 :       size_type
     707               0 :       length() const
     708               0 :       { return _M_rep()->_M_length; }
     709                 : 
     710                 :       ///  Returns the size() of the largest possible %string.
     711                 :       size_type
     712               0 :       max_size() const
     713               0 :       { return _Rep::_S_max_size; }
     714                 : 
     715                 :       /**
     716                 :        *  @brief  Resizes the %string to the specified number of characters.
     717                 :        *  @param  n  Number of characters the %string should contain.
     718                 :        *  @param  c  Character to fill any new elements.
     719                 :        *
     720                 :        *  This function will %resize the %string to the specified
     721                 :        *  number of characters.  If the number is smaller than the
     722                 :        *  %string's current size the %string is truncated, otherwise
     723                 :        *  the %string is extended and new elements are %set to @a c.
     724                 :        */
     725                 :       void
     726                 :       resize(size_type __n, _CharT __c);
     727                 : 
     728                 :       /**
     729                 :        *  @brief  Resizes the %string to the specified number of characters.
     730                 :        *  @param  n  Number of characters the %string should contain.
     731                 :        *
     732                 :        *  This function will resize the %string to the specified length.  If
     733                 :        *  the new size is smaller than the %string's current size the %string
     734                 :        *  is truncated, otherwise the %string is extended and new characters
     735                 :        *  are default-constructed.  For basic types such as char, this means
     736                 :        *  setting them to 0.
     737                 :        */
     738                 :       void
     739               0 :       resize(size_type __n)
     740               0 :       { this->resize(__n, _CharT()); }
     741                 : 
     742                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     743                 :       ///  A non-binding request to reduce capacity() to size().
     744                 :       void
     745               0 :       shrink_to_fit()
     746                 :       {
     747                 :         __try
     748               0 :           { reserve(0); }
     749                 :         __catch(...)
     750                 :           { }
     751               0 :       }
     752                 : #endif
     753                 : 
     754                 :       /**
     755                 :        *  Returns the total number of characters that the %string can hold
     756                 :        *  before needing to allocate more memory.
     757                 :        */
     758                 :       size_type
     759               0 :       capacity() const
     760               0 :       { return _M_rep()->_M_capacity; }
     761                 : 
     762                 :       /**
     763                 :        *  @brief  Attempt to preallocate enough memory for specified number of
     764                 :        *          characters.
     765                 :        *  @param  res_arg  Number of characters required.
     766                 :        *  @throw  std::length_error  If @a res_arg exceeds @c max_size().
     767                 :        *
     768                 :        *  This function attempts to reserve enough memory for the
     769                 :        *  %string to hold the specified number of characters.  If the
     770                 :        *  number requested is more than max_size(), length_error is
     771                 :        *  thrown.
     772                 :        *
     773                 :        *  The advantage of this function is that if optimal code is a
     774                 :        *  necessity and the user can determine the string length that will be
     775                 :        *  required, the user can reserve the memory in %advance, and thus
     776                 :        *  prevent a possible reallocation of memory and copying of %string
     777                 :        *  data.
     778                 :        */
     779                 :       void
     780                 :       reserve(size_type __res_arg = 0);
     781                 : 
     782                 :       /**
     783                 :        *  Erases the string, making it empty.
     784                 :        */
     785                 :       void
     786               0 :       clear()
     787               0 :       { _M_mutate(0, this->size(), 0); }
     788                 : 
     789                 :       /**
     790                 :        *  Returns true if the %string is empty.  Equivalent to 
     791                 :        *  <code>*this == ""</code>.
     792                 :        */
     793                 :       bool
     794               0 :       empty() const
     795               0 :       { return this->size() == 0; }
     796                 : 
     797                 :       // Element access:
     798                 :       /**
     799                 :        *  @brief  Subscript access to the data contained in the %string.
     800                 :        *  @param  pos  The index of the character to access.
     801                 :        *  @return  Read-only (constant) reference to the character.
     802                 :        *
     803                 :        *  This operator allows for easy, array-style, data access.
     804                 :        *  Note that data access with this operator is unchecked and
     805                 :        *  out_of_range lookups are not defined. (For checked lookups
     806                 :        *  see at().)
     807                 :        */
     808                 :       const_reference
     809               0 :       operator[] (size_type __pos) const
     810                 :       {
     811                 :         _GLIBCXX_DEBUG_ASSERT(__pos <= size());
     812               0 :         return _M_data()[__pos];
     813                 :       }
     814                 : 
     815                 :       /**
     816                 :        *  @brief  Subscript access to the data contained in the %string.
     817                 :        *  @param  pos  The index of the character to access.
     818                 :        *  @return  Read/write reference to the character.
     819                 :        *
     820                 :        *  This operator allows for easy, array-style, data access.
     821                 :        *  Note that data access with this operator is unchecked and
     822                 :        *  out_of_range lookups are not defined. (For checked lookups
     823                 :        *  see at().)  Unshares the string.
     824                 :        */
     825                 :       reference
     826               0 :       operator[](size_type __pos)
     827                 :       {
     828                 :         // allow pos == size() as v3 extension:
     829                 :         _GLIBCXX_DEBUG_ASSERT(__pos <= size());
     830                 :         // but be strict in pedantic mode:
     831                 :         _GLIBCXX_DEBUG_PEDASSERT(__pos < size());
     832               0 :         _M_leak();
     833               0 :         return _M_data()[__pos];
     834                 :       }
     835                 : 
     836                 :       /**
     837                 :        *  @brief  Provides access to the data contained in the %string.
     838                 :        *  @param n The index of the character to access.
     839                 :        *  @return  Read-only (const) reference to the character.
     840                 :        *  @throw  std::out_of_range  If @a n is an invalid index.
     841                 :        *
     842                 :        *  This function provides for safer data access.  The parameter is
     843                 :        *  first checked that it is in the range of the string.  The function
     844                 :        *  throws out_of_range if the check fails.
     845                 :        */
     846                 :       const_reference
     847               0 :       at(size_type __n) const
     848                 :       {
     849               0 :         if (__n >= this->size())
     850               0 :           __throw_out_of_range(__N("basic_string::at"));
     851               0 :         return _M_data()[__n];
     852                 :       }
     853                 : 
     854                 :       /**
     855                 :        *  @brief  Provides access to the data contained in the %string.
     856                 :        *  @param n The index of the character to access.
     857                 :        *  @return  Read/write reference to the character.
     858                 :        *  @throw  std::out_of_range  If @a n is an invalid index.
     859                 :        *
     860                 :        *  This function provides for safer data access.  The parameter is
     861                 :        *  first checked that it is in the range of the string.  The function
     862                 :        *  throws out_of_range if the check fails.  Success results in
     863                 :        *  unsharing the string.
     864                 :        */
     865                 :       reference
     866               0 :       at(size_type __n)
     867                 :       {
     868               0 :         if (__n >= size())
     869               0 :           __throw_out_of_range(__N("basic_string::at"));
     870               0 :         _M_leak();
     871               0 :         return _M_data()[__n];
     872                 :       }
     873                 : 
     874                 :       // Modifiers:
     875                 :       /**
     876                 :        *  @brief  Append a string to this string.
     877                 :        *  @param str  The string to append.
     878                 :        *  @return  Reference to this string.
     879                 :        */
     880                 :       basic_string&
     881               0 :       operator+=(const basic_string& __str)
     882               0 :       { return this->append(__str); }
     883                 : 
     884                 :       /**
     885                 :        *  @brief  Append a C string.
     886                 :        *  @param s  The C string to append.
     887                 :        *  @return  Reference to this string.
     888                 :        */
     889                 :       basic_string&
     890               0 :       operator+=(const _CharT* __s)
     891               0 :       { return this->append(__s); }
     892                 : 
     893                 :       /**
     894                 :        *  @brief  Append a character.
     895                 :        *  @param c  The character to append.
     896                 :        *  @return  Reference to this string.
     897                 :        */
     898                 :       basic_string&
     899               0 :       operator+=(_CharT __c)
     900                 :       { 
     901               0 :         this->push_back(__c);
     902               0 :         return *this;
     903                 :       }
     904                 : 
     905                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     906                 :       /**
     907                 :        *  @brief  Append an initializer_list of characters.
     908                 :        *  @param l  The initializer_list of characters to be appended.
     909                 :        *  @return  Reference to this string.
     910                 :        */
     911                 :       basic_string&
     912               0 :       operator+=(initializer_list<_CharT> __l)
     913               0 :       { return this->append(__l.begin(), __l.size()); }
     914                 : #endif // __GXX_EXPERIMENTAL_CXX0X__
     915                 : 
     916                 :       /**
     917                 :        *  @brief  Append a string to this string.
     918                 :        *  @param str  The string to append.
     919                 :        *  @return  Reference to this string.
     920                 :        */
     921                 :       basic_string&
     922                 :       append(const basic_string& __str);
     923                 : 
     924                 :       /**
     925                 :        *  @brief  Append a substring.
     926                 :        *  @param str  The string to append.
     927                 :        *  @param pos  Index of the first character of str to append.
     928                 :        *  @param n  The number of characters to append.
     929                 :        *  @return  Reference to this string.
     930                 :        *  @throw  std::out_of_range if @a pos is not a valid index.
     931                 :        *
     932                 :        *  This function appends @a n characters from @a str starting at @a pos
     933                 :        *  to this string.  If @a n is is larger than the number of available
     934                 :        *  characters in @a str, the remainder of @a str is appended.
     935                 :        */
     936                 :       basic_string&
     937                 :       append(const basic_string& __str, size_type __pos, size_type __n);
     938                 : 
     939                 :       /**
     940                 :        *  @brief  Append a C substring.
     941                 :        *  @param s  The C string to append.
     942                 :        *  @param n  The number of characters to append.
     943                 :        *  @return  Reference to this string.
     944                 :        */
     945                 :       basic_string&
     946                 :       append(const _CharT* __s, size_type __n);
     947                 : 
     948                 :       /**
     949                 :        *  @brief  Append a C string.
     950                 :        *  @param s  The C string to append.
     951                 :        *  @return  Reference to this string.
     952                 :        */
     953                 :       basic_string&
     954               0 :       append(const _CharT* __s)
     955                 :       {
     956                 :         __glibcxx_requires_string(__s);
     957               0 :         return this->append(__s, traits_type::length(__s));
     958                 :       }
     959                 : 
     960                 :       /**
     961                 :        *  @brief  Append multiple characters.
     962                 :        *  @param n  The number of characters to append.
     963                 :        *  @param c  The character to use.
     964                 :        *  @return  Reference to this string.
     965                 :        *
     966                 :        *  Appends n copies of c to this string.
     967                 :        */
     968                 :       basic_string&
     969                 :       append(size_type __n, _CharT __c);
     970                 : 
     971                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     972                 :       /**
     973                 :        *  @brief  Append an initializer_list of characters.
     974                 :        *  @param l  The initializer_list of characters to append.
     975                 :        *  @return  Reference to this string.
     976                 :        */
     977                 :       basic_string&
     978               0 :       append(initializer_list<_CharT> __l)
     979               0 :       { return this->append(__l.begin(), __l.size()); }
     980                 : #endif // __GXX_EXPERIMENTAL_CXX0X__
     981                 : 
     982                 :       /**
     983                 :        *  @brief  Append a range of characters.
     984                 :        *  @param first  Iterator referencing the first character to append.
     985                 :        *  @param last  Iterator marking the end of the range.
     986                 :        *  @return  Reference to this string.
     987                 :        *
     988                 :        *  Appends characters in the range [first,last) to this string.
     989                 :        */
     990                 :       template<class _InputIterator>
     991                 :         basic_string&
     992                 :         append(_InputIterator __first, _InputIterator __last)
     993                 :         { return this->replace(_M_iend(), _M_iend(), __first, __last); }
     994                 : 
     995                 :       /**
     996                 :        *  @brief  Append a single character.
     997                 :        *  @param c  Character to append.
     998                 :        */
     999                 :       void
    1000               0 :       push_back(_CharT __c)
    1001                 :       { 
    1002               0 :         const size_type __len = 1 + this->size();
    1003               0 :         if (__len > this->capacity() || _M_rep()->_M_is_shared())
    1004               0 :           this->reserve(__len);
    1005               0 :         traits_type::assign(_M_data()[this->size()], __c);
    1006               0 :         _M_rep()->_M_set_length_and_sharable(__len);
    1007               0 :       }
    1008                 : 
    1009                 :       /**
    1010                 :        *  @brief  Set value to contents of another string.
    1011                 :        *  @param  str  Source string to use.
    1012                 :        *  @return  Reference to this string.
    1013                 :        */
    1014                 :       basic_string&
    1015                 :       assign(const basic_string& __str);
    1016                 : 
    1017                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1018                 :       /**
    1019                 :        *  @brief  Set value to contents of another string.
    1020                 :        *  @param  str  Source string to use.
    1021                 :        *  @return  Reference to this string.
    1022                 :        *
    1023                 :        *  This function sets this string to the exact contents of @a str.
    1024                 :        *  @a str is a valid, but unspecified string.
    1025                 :        */
    1026                 :       basic_string&
    1027               0 :       assign(basic_string&& __str)
    1028                 :       {
    1029               0 :         this->swap(__str);
    1030               0 :         return *this;
    1031                 :       }
    1032                 : #endif // __GXX_EXPERIMENTAL_CXX0X__
    1033                 : 
    1034                 :       /**
    1035                 :        *  @brief  Set value to a substring of a string.
    1036                 :        *  @param str  The string to use.
    1037                 :        *  @param pos  Index of the first character of str.
    1038                 :        *  @param n  Number of characters to use.
    1039                 :        *  @return  Reference to this string.
    1040                 :        *  @throw  std::out_of_range if @a pos is not a valid index.
    1041                 :        *
    1042                 :        *  This function sets this string to the substring of @a str consisting
    1043                 :        *  of @a n characters at @a pos.  If @a n is is larger than the number
    1044                 :        *  of available characters in @a str, the remainder of @a str is used.
    1045                 :        */
    1046                 :       basic_string&
    1047               0 :       assign(const basic_string& __str, size_type __pos, size_type __n)
    1048                 :       { return this->assign(__str._M_data()
    1049                 :                             + __str._M_check(__pos, "basic_string::assign"),
    1050               0 :                             __str._M_limit(__pos, __n)); }
    1051                 : 
    1052                 :       /**
    1053                 :        *  @brief  Set value to a C substring.
    1054                 :        *  @param s  The C string to use.
    1055                 :        *  @param n  Number of characters to use.
    1056                 :        *  @return  Reference to this string.
    1057                 :        *
    1058                 :        *  This function sets the value of this string to the first @a n
    1059                 :        *  characters of @a s.  If @a n is is larger than the number of
    1060                 :        *  available characters in @a s, the remainder of @a s is used.
    1061                 :        */
    1062                 :       basic_string&
    1063                 :       assign(const _CharT* __s, size_type __n);
    1064                 : 
    1065                 :       /**
    1066                 :        *  @brief  Set value to contents of a C string.
    1067                 :        *  @param s  The C string to use.
    1068                 :        *  @return  Reference to this string.
    1069                 :        *
    1070                 :        *  This function sets the value of this string to the value of @a s.
    1071                 :        *  The data is copied, so there is no dependence on @a s once the
    1072                 :        *  function returns.
    1073                 :        */
    1074                 :       basic_string&
    1075               0 :       assign(const _CharT* __s)
    1076                 :       {
    1077                 :         __glibcxx_requires_string(__s);
    1078               0 :         return this->assign(__s, traits_type::length(__s));
    1079                 :       }
    1080                 : 
    1081                 :       /**
    1082                 :        *  @brief  Set value to multiple characters.
    1083                 :        *  @param n  Length of the resulting string.
    1084                 :        *  @param c  The character to use.
    1085                 :        *  @return  Reference to this string.
    1086                 :        *
    1087                 :        *  This function sets the value of this string to @a n copies of
    1088                 :        *  character @a c.
    1089                 :        */
    1090                 :       basic_string&
    1091               0 :       assign(size_type __n, _CharT __c)
    1092               0 :       { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
    1093                 : 
    1094                 :       /**
    1095                 :        *  @brief  Set value to a range of characters.
    1096                 :        *  @param first  Iterator referencing the first character to append.
    1097                 :        *  @param last  Iterator marking the end of the range.
    1098                 :        *  @return  Reference to this string.
    1099                 :        *
    1100                 :        *  Sets value of string to characters in the range [first,last).
    1101                 :       */
    1102                 :       template<class _InputIterator>
    1103                 :         basic_string&
    1104                 :         assign(_InputIterator __first, _InputIterator __last)
    1105                 :         { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
    1106                 : 
    1107                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1108                 :       /**
    1109                 :        *  @brief  Set value to an initializer_list of characters.
    1110                 :        *  @param l  The initializer_list of characters to assign.
    1111                 :        *  @return  Reference to this string.
    1112                 :        */
    1113                 :       basic_string&
    1114               0 :       assign(initializer_list<_CharT> __l)
    1115               0 :       { return this->assign(__l.begin(), __l.size()); }
    1116                 : #endif // __GXX_EXPERIMENTAL_CXX0X__
    1117                 : 
    1118                 :       /**
    1119                 :        *  @brief  Insert multiple characters.
    1120                 :        *  @param p  Iterator referencing location in string to insert at.
    1121                 :        *  @param n  Number of characters to insert
    1122                 :        *  @param c  The character to insert.
    1123                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1124                 :        *
    1125                 :        *  Inserts @a n copies of character @a c starting at the position
    1126                 :        *  referenced by iterator @a p.  If adding characters causes the length
    1127                 :        *  to exceed max_size(), length_error is thrown.  The value of the
    1128                 :        *  string doesn't change if an error is thrown.
    1129                 :       */
    1130                 :       void
    1131               0 :       insert(iterator __p, size_type __n, _CharT __c)
    1132               0 :       { this->replace(__p, __p, __n, __c);  }
    1133                 : 
    1134                 :       /**
    1135                 :        *  @brief  Insert a range of characters.
    1136                 :        *  @param p  Iterator referencing location in string to insert at.
    1137                 :        *  @param beg  Start of range.
    1138                 :        *  @param end  End of range.
    1139                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1140                 :        *
    1141                 :        *  Inserts characters in range [beg,end).  If adding characters causes
    1142                 :        *  the length to exceed max_size(), length_error is thrown.  The value
    1143                 :        *  of the string doesn't change if an error is thrown.
    1144                 :       */
    1145                 :       template<class _InputIterator>
    1146                 :         void
    1147                 :         insert(iterator __p, _InputIterator __beg, _InputIterator __end)
    1148                 :         { this->replace(__p, __p, __beg, __end); }
    1149                 : 
    1150                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1151                 :       /**
    1152                 :        *  @brief  Insert an initializer_list of characters.
    1153                 :        *  @param p  Iterator referencing location in string to insert at.
    1154                 :        *  @param l  The initializer_list of characters to insert.
    1155                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1156                 :        */
    1157                 :       void
    1158               0 :       insert(iterator __p, initializer_list<_CharT> __l)
    1159                 :       {
    1160                 :         _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
    1161               0 :         this->insert(__p - _M_ibegin(), __l.begin(), __l.size());
    1162               0 :       }
    1163                 : #endif // __GXX_EXPERIMENTAL_CXX0X__
    1164                 : 
    1165                 :       /**
    1166                 :        *  @brief  Insert value of a string.
    1167                 :        *  @param pos1  Iterator referencing location in string to insert at.
    1168                 :        *  @param str  The string to insert.
    1169                 :        *  @return  Reference to this string.
    1170                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1171                 :        *
    1172                 :        *  Inserts value of @a str starting at @a pos1.  If adding characters
    1173                 :        *  causes the length to exceed max_size(), length_error is thrown.  The
    1174                 :        *  value of the string doesn't change if an error is thrown.
    1175                 :       */
    1176                 :       basic_string&
    1177               0 :       insert(size_type __pos1, const basic_string& __str)
    1178               0 :       { return this->insert(__pos1, __str, size_type(0), __str.size()); }
    1179                 : 
    1180                 :       /**
    1181                 :        *  @brief  Insert a substring.
    1182                 :        *  @param pos1  Iterator referencing location in string to insert at.
    1183                 :        *  @param str  The string to insert.
    1184                 :        *  @param pos2  Start of characters in str to insert.
    1185                 :        *  @param n  Number of characters to insert.
    1186                 :        *  @return  Reference to this string.
    1187                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1188                 :        *  @throw  std::out_of_range  If @a pos1 > size() or
    1189                 :        *  @a pos2 > @a str.size().
    1190                 :        *
    1191                 :        *  Starting at @a pos1, insert @a n character of @a str beginning with
    1192                 :        *  @a pos2.  If adding characters causes the length to exceed
    1193                 :        *  max_size(), length_error is thrown.  If @a pos1 is beyond the end of
    1194                 :        *  this string or @a pos2 is beyond the end of @a str, out_of_range is
    1195                 :        *  thrown.  The value of the string doesn't change if an error is
    1196                 :        *  thrown.
    1197                 :       */
    1198                 :       basic_string&
    1199               0 :       insert(size_type __pos1, const basic_string& __str,
    1200                 :              size_type __pos2, size_type __n)
    1201                 :       { return this->insert(__pos1, __str._M_data()
    1202                 :                             + __str._M_check(__pos2, "basic_string::insert"),
    1203               0 :                             __str._M_limit(__pos2, __n)); }
    1204                 : 
    1205                 :       /**
    1206                 :        *  @brief  Insert a C substring.
    1207                 :        *  @param pos  Iterator referencing location in string to insert at.
    1208                 :        *  @param s  The C string to insert.
    1209                 :        *  @param n  The number of characters to insert.
    1210                 :        *  @return  Reference to this string.
    1211                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1212                 :        *  @throw  std::out_of_range  If @a pos is beyond the end of this
    1213                 :        *  string.
    1214                 :        *
    1215                 :        *  Inserts the first @a n characters of @a s starting at @a pos.  If
    1216                 :        *  adding characters causes the length to exceed max_size(),
    1217                 :        *  length_error is thrown.  If @a pos is beyond end(), out_of_range is
    1218                 :        *  thrown.  The value of the string doesn't change if an error is
    1219                 :        *  thrown.
    1220                 :       */
    1221                 :       basic_string&
    1222                 :       insert(size_type __pos, const _CharT* __s, size_type __n);
    1223                 : 
    1224                 :       /**
    1225                 :        *  @brief  Insert a C string.
    1226                 :        *  @param pos  Iterator referencing location in string to insert at.
    1227                 :        *  @param s  The C string to insert.
    1228                 :        *  @return  Reference to this string.
    1229                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1230                 :        *  @throw  std::out_of_range  If @a pos is beyond the end of this
    1231                 :        *  string.
    1232                 :        *
    1233                 :        *  Inserts the first @a n characters of @a s starting at @a pos.  If
    1234                 :        *  adding characters causes the length to exceed max_size(),
    1235                 :        *  length_error is thrown.  If @a pos is beyond end(), out_of_range is
    1236                 :        *  thrown.  The value of the string doesn't change if an error is
    1237                 :        *  thrown.
    1238                 :       */
    1239                 :       basic_string&
    1240               0 :       insert(size_type __pos, const _CharT* __s)
    1241                 :       {
    1242                 :         __glibcxx_requires_string(__s);
    1243               0 :         return this->insert(__pos, __s, traits_type::length(__s));
    1244                 :       }
    1245                 : 
    1246                 :       /**
    1247                 :        *  @brief  Insert multiple characters.
    1248                 :        *  @param pos  Index in string to insert at.
    1249                 :        *  @param n  Number of characters to insert
    1250                 :        *  @param c  The character to insert.
    1251                 :        *  @return  Reference to this string.
    1252                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1253                 :        *  @throw  std::out_of_range  If @a pos is beyond the end of this
    1254                 :        *  string.
    1255                 :        *
    1256                 :        *  Inserts @a n copies of character @a c starting at index @a pos.  If
    1257                 :        *  adding characters causes the length to exceed max_size(),
    1258                 :        *  length_error is thrown.  If @a pos > length(), out_of_range is
    1259                 :        *  thrown.  The value of the string doesn't change if an error is
    1260                 :        *  thrown.
    1261                 :       */
    1262                 :       basic_string&
    1263               0 :       insert(size_type __pos, size_type __n, _CharT __c)
    1264                 :       { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
    1265               0 :                               size_type(0), __n, __c); }
    1266                 : 
    1267                 :       /**
    1268                 :        *  @brief  Insert one character.
    1269                 :        *  @param p  Iterator referencing position in string to insert at.
    1270                 :        *  @param c  The character to insert.
    1271                 :        *  @return  Iterator referencing newly inserted char.
    1272                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1273                 :        *
    1274                 :        *  Inserts character @a c at position referenced by @a p.  If adding
    1275                 :        *  character causes the length to exceed max_size(), length_error is
    1276                 :        *  thrown.  If @a p is beyond end of string, out_of_range is thrown.
    1277                 :        *  The value of the string doesn't change if an error is thrown.
    1278                 :       */
    1279                 :       iterator
    1280               0 :       insert(iterator __p, _CharT __c)
    1281                 :       {
    1282                 :         _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
    1283               0 :         const size_type __pos = __p - _M_ibegin();
    1284               0 :         _M_replace_aux(__pos, size_type(0), size_type(1), __c);
    1285               0 :         _M_rep()->_M_set_leaked();
    1286               0 :         return iterator(_M_data() + __pos);
    1287                 :       }
    1288                 : 
    1289                 :       /**
    1290                 :        *  @brief  Remove characters.
    1291                 :        *  @param pos  Index of first character to remove (default 0).
    1292                 :        *  @param n  Number of characters to remove (default remainder).
    1293                 :        *  @return  Reference to this string.
    1294                 :        *  @throw  std::out_of_range  If @a pos is beyond the end of this
    1295                 :        *  string.
    1296                 :        *
    1297                 :        *  Removes @a n characters from this string starting at @a pos.  The
    1298                 :        *  length of the string is reduced by @a n.  If there are < @a n
    1299                 :        *  characters to remove, the remainder of the string is truncated.  If
    1300                 :        *  @a p is beyond end of string, out_of_range is thrown.  The value of
    1301                 :        *  the string doesn't change if an error is thrown.
    1302                 :       */
    1303                 :       basic_string&
    1304               0 :       erase(size_type __pos = 0, size_type __n = npos)
    1305                 :       { 
    1306               0 :         _M_mutate(_M_check(__pos, "basic_string::erase"),
    1307                 :                   _M_limit(__pos, __n), size_type(0));
    1308               0 :         return *this;
    1309                 :       }
    1310                 : 
    1311                 :       /**
    1312                 :        *  @brief  Remove one character.
    1313                 :        *  @param position  Iterator referencing the character to remove.
    1314                 :        *  @return  iterator referencing same location after removal.
    1315                 :        *
    1316                 :        *  Removes the character at @a position from this string. The value
    1317                 :        *  of the string doesn't change if an error is thrown.
    1318                 :       */
    1319                 :       iterator
    1320               0 :       erase(iterator __position)
    1321                 :       {
    1322                 :         _GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin()
    1323                 :                                  && __position < _M_iend());
    1324               0 :         const size_type __pos = __position - _M_ibegin();
    1325               0 :         _M_mutate(__pos, size_type(1), size_type(0));
    1326               0 :         _M_rep()->_M_set_leaked();
    1327               0 :         return iterator(_M_data() + __pos);
    1328                 :       }
    1329                 : 
    1330                 :       /**
    1331                 :        *  @brief  Remove a range of characters.
    1332                 :        *  @param first  Iterator referencing the first character to remove.
    1333                 :        *  @param last  Iterator referencing the end of the range.
    1334                 :        *  @return  Iterator referencing location of first after removal.
    1335                 :        *
    1336                 :        *  Removes the characters in the range [first,last) from this string.
    1337                 :        *  The value of the string doesn't change if an error is thrown.
    1338                 :       */
    1339                 :       iterator
    1340                 :       erase(iterator __first, iterator __last);
    1341                 :  
    1342                 :       /**
    1343                 :        *  @brief  Replace characters with value from another string.
    1344                 :        *  @param pos  Index of first character to replace.
    1345                 :        *  @param n  Number of characters to be replaced.
    1346                 :        *  @param str  String to insert.
    1347                 :        *  @return  Reference to this string.
    1348                 :        *  @throw  std::out_of_range  If @a pos is beyond the end of this
    1349                 :        *  string.
    1350                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1351                 :        *
    1352                 :        *  Removes the characters in the range [pos,pos+n) from this string.
    1353                 :        *  In place, the value of @a str is inserted.  If @a pos is beyond end
    1354                 :        *  of string, out_of_range is thrown.  If the length of the result
    1355                 :        *  exceeds max_size(), length_error is thrown.  The value of the string
    1356                 :        *  doesn't change if an error is thrown.
    1357                 :       */
    1358                 :       basic_string&
    1359               0 :       replace(size_type __pos, size_type __n, const basic_string& __str)
    1360               0 :       { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
    1361                 : 
    1362                 :       /**
    1363                 :        *  @brief  Replace characters with value from another string.
    1364                 :        *  @param pos1  Index of first character to replace.
    1365                 :        *  @param n1  Number of characters to be replaced.
    1366                 :        *  @param str  String to insert.
    1367                 :        *  @param pos2  Index of first character of str to use.
    1368                 :        *  @param n2  Number of characters from str to use.
    1369                 :        *  @return  Reference to this string.
    1370                 :        *  @throw  std::out_of_range  If @a pos1 > size() or @a pos2 >
    1371                 :        *  str.size().
    1372                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1373                 :        *
    1374                 :        *  Removes the characters in the range [pos1,pos1 + n) from this
    1375                 :        *  string.  In place, the value of @a str is inserted.  If @a pos is
    1376                 :        *  beyond end of string, out_of_range is thrown.  If the length of the
    1377                 :        *  result exceeds max_size(), length_error is thrown.  The value of the
    1378                 :        *  string doesn't change if an error is thrown.
    1379                 :       */
    1380                 :       basic_string&
    1381               0 :       replace(size_type __pos1, size_type __n1, const basic_string& __str,
    1382                 :               size_type __pos2, size_type __n2)
    1383                 :       { return this->replace(__pos1, __n1, __str._M_data()
    1384                 :                              + __str._M_check(__pos2, "basic_string::replace"),
    1385               0 :                              __str._M_limit(__pos2, __n2)); }
    1386                 : 
    1387                 :       /**
    1388                 :        *  @brief  Replace characters with value of a C substring.
    1389                 :        *  @param pos  Index of first character to replace.
    1390                 :        *  @param n1  Number of characters to be replaced.
    1391                 :        *  @param s  C string to insert.
    1392                 :        *  @param n2  Number of characters from @a s to use.
    1393                 :        *  @return  Reference to this string.
    1394                 :        *  @throw  std::out_of_range  If @a pos1 > size().
    1395                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1396                 :        *
    1397                 :        *  Removes the characters in the range [pos,pos + n1) from this string.
    1398                 :        *  In place, the first @a n2 characters of @a s are inserted, or all
    1399                 :        *  of @a s if @a n2 is too large.  If @a pos is beyond end of string,
    1400                 :        *  out_of_range is thrown.  If the length of result exceeds max_size(),
    1401                 :        *  length_error is thrown.  The value of the string doesn't change if
    1402                 :        *  an error is thrown.
    1403                 :       */
    1404                 :       basic_string&
    1405                 :       replace(size_type __pos, size_type __n1, const _CharT* __s,
    1406                 :               size_type __n2);
    1407                 : 
    1408                 :       /**
    1409                 :        *  @brief  Replace characters with value of a C string.
    1410                 :        *  @param pos  Index of first character to replace.
    1411                 :        *  @param n1  Number of characters to be replaced.
    1412                 :        *  @param s  C string to insert.
    1413                 :        *  @return  Reference to this string.
    1414                 :        *  @throw  std::out_of_range  If @a pos > size().
    1415                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1416                 :        *
    1417                 :        *  Removes the characters in the range [pos,pos + n1) from this string.
    1418                 :        *  In place, the characters of @a s are inserted.  If @a pos is beyond
    1419                 :        *  end of string, out_of_range is thrown.  If the length of result
    1420                 :        *  exceeds max_size(), length_error is thrown.  The value of the string
    1421                 :        *  doesn't change if an error is thrown.
    1422                 :       */
    1423                 :       basic_string&
    1424               0 :       replace(size_type __pos, size_type __n1, const _CharT* __s)
    1425                 :       {
    1426                 :         __glibcxx_requires_string(__s);
    1427               0 :         return this->replace(__pos, __n1, __s, traits_type::length(__s));
    1428                 :       }
    1429                 : 
    1430                 :       /**
    1431                 :        *  @brief  Replace characters with multiple characters.
    1432                 :        *  @param pos  Index of first character to replace.
    1433                 :        *  @param n1  Number of characters to be replaced.
    1434                 :        *  @param n2  Number of characters to insert.
    1435                 :        *  @param c  Character to insert.
    1436                 :        *  @return  Reference to this string.
    1437                 :        *  @throw  std::out_of_range  If @a pos > size().
    1438                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1439                 :        *
    1440                 :        *  Removes the characters in the range [pos,pos + n1) from this string.
    1441                 :        *  In place, @a n2 copies of @a c are inserted.  If @a pos is beyond
    1442                 :        *  end of string, out_of_range is thrown.  If the length of result
    1443                 :        *  exceeds max_size(), length_error is thrown.  The value of the string
    1444                 :        *  doesn't change if an error is thrown.
    1445                 :       */
    1446                 :       basic_string&
    1447               0 :       replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
    1448                 :       { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
    1449               0 :                               _M_limit(__pos, __n1), __n2, __c); }
    1450                 : 
    1451                 :       /**
    1452                 :        *  @brief  Replace range of characters with string.
    1453                 :        *  @param i1  Iterator referencing start of range to replace.
    1454                 :        *  @param i2  Iterator referencing end of range to replace.
    1455                 :        *  @param str  String value to insert.
    1456                 :        *  @return  Reference to this string.
    1457                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1458                 :        *
    1459                 :        *  Removes the characters in the range [i1,i2).  In place, the value of
    1460                 :        *  @a str is inserted.  If the length of result exceeds max_size(),
    1461                 :        *  length_error is thrown.  The value of the string doesn't change if
    1462                 :        *  an error is thrown.
    1463                 :       */
    1464                 :       basic_string&
    1465               0 :       replace(iterator __i1, iterator __i2, const basic_string& __str)
    1466               0 :       { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
    1467                 : 
    1468                 :       /**
    1469                 :        *  @brief  Replace range of characters with C substring.
    1470                 :        *  @param i1  Iterator referencing start of range to replace.
    1471                 :        *  @param i2  Iterator referencing end of range to replace.
    1472                 :        *  @param s  C string value to insert.
    1473                 :        *  @param n  Number of characters from s to insert.
    1474                 :        *  @return  Reference to this string.
    1475                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1476                 :        *
    1477                 :        *  Removes the characters in the range [i1,i2).  In place, the first @a
    1478                 :        *  n characters of @a s are inserted.  If the length of result exceeds
    1479                 :        *  max_size(), length_error is thrown.  The value of the string doesn't
    1480                 :        *  change if an error is thrown.
    1481                 :       */
    1482                 :       basic_string&
    1483               0 :       replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
    1484                 :       {
    1485                 :         _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
    1486                 :                                  && __i2 <= _M_iend());
    1487               0 :         return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
    1488                 :       }
    1489                 : 
    1490                 :       /**
    1491                 :        *  @brief  Replace range of characters with C string.
    1492                 :        *  @param i1  Iterator referencing start of range to replace.
    1493                 :        *  @param i2  Iterator referencing end of range to replace.
    1494                 :        *  @param s  C string value to insert.
    1495                 :        *  @return  Reference to this string.
    1496                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1497                 :        *
    1498                 :        *  Removes the characters in the range [i1,i2).  In place, the
    1499                 :        *  characters of @a s are inserted.  If the length of result exceeds
    1500                 :        *  max_size(), length_error is thrown.  The value of the string doesn't
    1501                 :        *  change if an error is thrown.
    1502                 :       */
    1503                 :       basic_string&
    1504               0 :       replace(iterator __i1, iterator __i2, const _CharT* __s)
    1505                 :       {
    1506                 :         __glibcxx_requires_string(__s);
    1507               0 :         return this->replace(__i1, __i2, __s, traits_type::length(__s));
    1508                 :       }
    1509                 : 
    1510                 :       /**
    1511                 :        *  @brief  Replace range of characters with multiple characters
    1512                 :        *  @param i1  Iterator referencing start of range to replace.
    1513                 :        *  @param i2  Iterator referencing end of range to replace.
    1514                 :        *  @param n  Number of characters to insert.
    1515                 :        *  @param c  Character to insert.
    1516                 :        *  @return  Reference to this string.
    1517                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1518                 :        *
    1519                 :        *  Removes the characters in the range [i1,i2).  In place, @a n copies
    1520                 :        *  of @a c are inserted.  If the length of result exceeds max_size(),
    1521                 :        *  length_error is thrown.  The value of the string doesn't change if
    1522                 :        *  an error is thrown.
    1523                 :       */
    1524                 :       basic_string&
    1525               0 :       replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
    1526                 :       {
    1527                 :         _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
    1528                 :                                  && __i2 <= _M_iend());
    1529               0 :         return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
    1530                 :       }
    1531                 : 
    1532                 :       /**
    1533                 :        *  @brief  Replace range of characters with range.
    1534                 :        *  @param i1  Iterator referencing start of range to replace.
    1535                 :        *  @param i2  Iterator referencing end of range to replace.
    1536                 :        *  @param k1  Iterator referencing start of range to insert.
    1537                 :        *  @param k2  Iterator referencing end of range to insert.
    1538                 :        *  @return  Reference to this string.
    1539                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1540                 :        *
    1541                 :        *  Removes the characters in the range [i1,i2).  In place, characters
    1542                 :        *  in the range [k1,k2) are inserted.  If the length of result exceeds
    1543                 :        *  max_size(), length_error is thrown.  The value of the string doesn't
    1544                 :        *  change if an error is thrown.
    1545                 :       */
    1546                 :       template<class _InputIterator>
    1547                 :         basic_string&
    1548                 :         replace(iterator __i1, iterator __i2,
    1549                 :                 _InputIterator __k1, _InputIterator __k2)
    1550                 :         {
    1551                 :           _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
    1552                 :                                    && __i2 <= _M_iend());
    1553                 :           __glibcxx_requires_valid_range(__k1, __k2);
    1554                 :           typedef typename std::__is_integer<_InputIterator>::__type _Integral;
    1555                 :           return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
    1556                 :         }
    1557                 : 
    1558                 :       // Specializations for the common case of pointer and iterator:
    1559                 :       // useful to avoid the overhead of temporary buffering in _M_replace.
    1560                 :       basic_string&
    1561               0 :       replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
    1562                 :       {
    1563                 :         _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
    1564                 :                                  && __i2 <= _M_iend());
    1565                 :         __glibcxx_requires_valid_range(__k1, __k2);
    1566                 :         return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
    1567               0 :                              __k1, __k2 - __k1);
    1568                 :       }
    1569                 : 
    1570                 :       basic_string&
    1571               0 :       replace(iterator __i1, iterator __i2,
    1572                 :               const _CharT* __k1, const _CharT* __k2)
    1573                 :       {
    1574                 :         _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
    1575                 :                                  && __i2 <= _M_iend());
    1576                 :         __glibcxx_requires_valid_range(__k1, __k2);
    1577                 :         return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
    1578               0 :                              __k1, __k2 - __k1);
    1579                 :       }
    1580                 : 
    1581                 :       basic_string&
    1582               0 :       replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
    1583                 :       {
    1584                 :         _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
    1585                 :                                  && __i2 <= _M_iend());
    1586                 :         __glibcxx_requires_valid_range(__k1, __k2);
    1587                 :         return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
    1588               0 :                              __k1.base(), __k2 - __k1);
    1589                 :       }
    1590                 : 
    1591                 :       basic_string&
    1592               0 :       replace(iterator __i1, iterator __i2,
    1593                 :               const_iterator __k1, const_iterator __k2)
    1594                 :       {
    1595                 :         _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
    1596                 :                                  && __i2 <= _M_iend());
    1597                 :         __glibcxx_requires_valid_range(__k1, __k2);
    1598                 :         return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
    1599               0 :                              __k1.base(), __k2 - __k1);
    1600                 :       }
    1601                 :       
    1602                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1603                 :       /**
    1604                 :        *  @brief  Replace range of characters with initializer_list.
    1605                 :        *  @param i1  Iterator referencing start of range to replace.
    1606                 :        *  @param i2  Iterator referencing end of range to replace.
    1607                 :        *  @param l  The initializer_list of characters to insert.
    1608                 :        *  @return  Reference to this string.
    1609                 :        *  @throw  std::length_error  If new length exceeds @c max_size().
    1610                 :        *
    1611                 :        *  Removes the characters in the range [i1,i2).  In place, characters
    1612                 :        *  in the range [k1,k2) are inserted.  If the length of result exceeds
    1613                 :        *  max_size(), length_error is thrown.  The value of the string doesn't
    1614                 :        *  change if an error is thrown.
    1615                 :       */
    1616               0 :       basic_string& replace(iterator __i1, iterator __i2,
    1617                 :                             initializer_list<_CharT> __l)
    1618               0 :       { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
    1619                 : #endif // __GXX_EXPERIMENTAL_CXX0X__
    1620                 : 
    1621                 :     private:
    1622                 :       template<class _Integer>
    1623                 :         basic_string&
    1624                 :         _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
    1625                 :                             _Integer __val, __true_type)
    1626                 :         { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
    1627                 : 
    1628                 :       template<class _InputIterator>
    1629                 :         basic_string&
    1630                 :         _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
    1631                 :                             _InputIterator __k2, __false_type);
    1632                 : 
    1633                 :       basic_string&
    1634                 :       _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
    1635                 :                      _CharT __c);
    1636                 : 
    1637                 :       basic_string&
    1638                 :       _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
    1639                 :                       size_type __n2);
    1640                 : 
    1641                 :       // _S_construct_aux is used to implement the 21.3.1 para 15 which
    1642                 :       // requires special behaviour if _InIter is an integral type
    1643                 :       template<class _InIterator>
    1644                 :         static _CharT*
    1645               3 :         _S_construct_aux(_InIterator __beg, _InIterator __end,
    1646                 :                          const _Alloc& __a, __false_type)
    1647                 :         {
    1648                 :           typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
    1649               3 :           return _S_construct(__beg, __end, __a, _Tag());
    1650                 :         }
    1651                 : 
    1652                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1653                 :       // 438. Ambiguity in the "do the right thing" clause
    1654                 :       template<class _Integer>
    1655                 :         static _CharT*
    1656               0 :         _S_construct_aux(_Integer __beg, _Integer __end,
    1657                 :                          const _Alloc& __a, __true_type)
    1658                 :         { return _S_construct_aux_2(static_cast<size_type>(__beg),
    1659               0 :                                     __end, __a); }
    1660                 : 
    1661                 :       static _CharT*
    1662               0 :       _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
    1663               0 :       { return _S_construct(__req, __c, __a); }
    1664                 : 
    1665                 :       template<class _InIterator>
    1666                 :         static _CharT*
    1667               3 :         _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
    1668                 :         {
    1669                 :           typedef typename std::__is_integer<_InIterator>::__type _Integral;
    1670               3 :           return _S_construct_aux(__beg, __end, __a, _Integral());
    1671                 :         }
    1672                 : 
    1673                 :       // For Input Iterators, used in istreambuf_iterators, etc.
    1674                 :       template<class _InIterator>
    1675                 :         static _CharT*
    1676                 :          _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
    1677                 :                       input_iterator_tag);
    1678                 : 
    1679                 :       // For forward_iterators up to random_access_iterators, used for
    1680                 :       // string::iterator, _CharT*, etc.
    1681                 :       template<class _FwdIterator>
    1682                 :         static _CharT*
    1683                 :         _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
    1684                 :                      forward_iterator_tag);
    1685                 : 
    1686                 :       static _CharT*
    1687                 :       _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
    1688                 : 
    1689                 :     public:
    1690                 : 
    1691                 :       /**
    1692                 :        *  @brief  Copy substring into C string.
    1693                 :        *  @param s  C string to copy value into.
    1694                 :        *  @param n  Number of characters to copy.
    1695                 :        *  @param pos  Index of first character to copy.
    1696                 :        *  @return  Number of characters actually copied
    1697                 :        *  @throw  std::out_of_range  If pos > size().
    1698                 :        *
    1699                 :        *  Copies up to @a n characters starting at @a pos into the C string @a
    1700                 :        *  s.  If @a pos is %greater than size(), out_of_range is thrown.
    1701                 :       */
    1702                 :       size_type
    1703                 :       copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
    1704                 : 
    1705                 :       /**
    1706                 :        *  @brief  Swap contents with another string.
    1707                 :        *  @param s  String to swap with.
    1708                 :        *
    1709                 :        *  Exchanges the contents of this string with that of @a s in constant
    1710                 :        *  time.
    1711                 :       */
    1712                 :       void
    1713                 :       swap(basic_string& __s);
    1714                 : 
    1715                 :       // String operations:
    1716                 :       /**
    1717                 :        *  @brief  Return const pointer to null-terminated contents.
    1718                 :        *
    1719                 :        *  This is a handle to internal data.  Do not modify or dire things may
    1720                 :        *  happen.
    1721                 :       */
    1722                 :       const _CharT*
    1723               0 :       c_str() const
    1724               0 :       { return _M_data(); }
    1725                 : 
    1726                 :       /**
    1727                 :        *  @brief  Return const pointer to contents.
    1728                 :        *
    1729                 :        *  This is a handle to internal data.  Do not modify or dire things may
    1730                 :        *  happen.
    1731                 :       */
    1732                 :       const _CharT*
    1733               0 :       data() const
    1734               0 :       { return _M_data(); }
    1735                 : 
    1736                 :       /**
    1737                 :        *  @brief  Return copy of allocator used to construct this string.
    1738                 :       */
    1739                 :       allocator_type
    1740               0 :       get_allocator() const
    1741               0 :       { return _M_dataplus; }
    1742                 : 
    1743                 :       /**
    1744                 :        *  @brief  Find position of a C substring.
    1745                 :        *  @param s  C string to locate.
    1746                 :        *  @param pos  Index of character to search from.
    1747                 :        *  @param n  Number of characters from @a s to search for.
    1748                 :        *  @return  Index of start of first occurrence.
    1749                 :        *
    1750                 :        *  Starting from @a pos, searches forward for the first @a n characters
    1751                 :        *  in @a s within this string.  If found, returns the index where it
    1752                 :        *  begins.  If not found, returns npos.
    1753                 :       */
    1754                 :       size_type
    1755                 :       find(const _CharT* __s, size_type __pos, size_type __n) const;
    1756                 : 
    1757                 :       /**
    1758                 :        *  @brief  Find position of a string.
    1759                 :        *  @param str  String to locate.
    1760                 :        *  @param pos  Index of character to search from (default 0).
    1761                 :        *  @return  Index of start of first occurrence.
    1762                 :        *
    1763                 :        *  Starting from @a pos, searches forward for value of @a str within
    1764                 :        *  this string.  If found, returns the index where it begins.  If not
    1765                 :        *  found, returns npos.
    1766                 :       */
    1767                 :       size_type
    1768               0 :       find(const basic_string& __str, size_type __pos = 0) const
    1769               0 :       { return this->find(__str.data(), __pos, __str.size()); }
    1770                 : 
    1771                 :       /**
    1772                 :        *  @brief  Find position of a C string.
    1773                 :        *  @param s  C string to locate.
    1774                 :        *  @param pos  Index of character to search from (default 0).
    1775                 :        *  @return  Index of start of first occurrence.
    1776                 :        *
    1777                 :        *  Starting from @a pos, searches forward for the value of @a s within
    1778                 :        *  this string.  If found, returns the index where it begins.  If not
    1779                 :        *  found, returns npos.
    1780                 :       */
    1781                 :       size_type
    1782               0 :       find(const _CharT* __s, size_type __pos = 0) const
    1783                 :       {
    1784                 :         __glibcxx_requires_string(__s);
    1785               0 :         return this->find(__s, __pos, traits_type::length(__s));
    1786                 :       }
    1787                 : 
    1788                 :       /**
    1789                 :        *  @brief  Find position of a character.
    1790                 :        *  @param c  Character to locate.
    1791                 :        *  @param pos  Index of character to search from (default 0).
    1792                 :        *  @return  Index of first occurrence.
    1793                 :        *
    1794                 :        *  Starting from @a pos, searches forward for @a c within this string.
    1795                 :        *  If found, returns the index where it was found.  If not found,
    1796                 :        *  returns npos.
    1797                 :       */
    1798                 :       size_type
    1799                 :       find(_CharT __c, size_type __pos = 0) const;
    1800                 : 
    1801                 :       /**
    1802                 :        *  @brief  Find last position of a string.
    1803                 :        *  @param str  String to locate.
    1804                 :        *  @param pos  Index of character to search back from (default end).
    1805                 :        *  @return  Index of start of last occurrence.
    1806                 :        *
    1807                 :        *  Starting from @a pos, searches backward for value of @a str within
    1808                 :        *  this string.  If found, returns the index where it begins.  If not
    1809                 :        *  found, returns npos.
    1810                 :       */
    1811                 :       size_type
    1812               0 :       rfind(const basic_string& __str, size_type __pos = npos) const
    1813               0 :       { return this->rfind(__str.data(), __pos, __str.size()); }
    1814                 : 
    1815                 :       /**
    1816                 :        *  @brief  Find last position of a C substring.
    1817                 :        *  @param s  C string to locate.
    1818                 :        *  @param pos  Index of character to search back from.
    1819                 :        *  @param n  Number of characters from s to search for.
    1820                 :        *  @return  Index of start of last occurrence.
    1821                 :        *
    1822                 :        *  Starting from @a pos, searches backward for the first @a n
    1823                 :        *  characters in @a s within this string.  If found, returns the index
    1824                 :        *  where it begins.  If not found, returns npos.
    1825                 :       */
    1826                 :       size_type
    1827                 :       rfind(const _CharT* __s, size_type __pos, size_type __n) const;
    1828                 : 
    1829                 :       /**
    1830                 :        *  @brief  Find last position of a C string.
    1831                 :        *  @param s  C string to locate.
    1832                 :        *  @param pos  Index of character to start search at (default end).
    1833                 :        *  @return  Index of start of  last occurrence.
    1834                 :        *
    1835                 :        *  Starting from @a pos, searches backward for the value of @a s within
    1836                 :        *  this string.  If found, returns the index where it begins.  If not
    1837                 :        *  found, returns npos.
    1838                 :       */
    1839                 :       size_type
    1840               0 :       rfind(const _CharT* __s, size_type __pos = npos) const
    1841                 :       {
    1842                 :         __glibcxx_requires_string(__s);
    1843               0 :         return this->rfind(__s, __pos, traits_type::length(__s));
    1844                 :       }
    1845                 : 
    1846                 :       /**
    1847                 :        *  @brief  Find last position of a character.
    1848                 :        *  @param c  Character to locate.
    1849                 :        *  @param pos  Index of character to search back from (default end).
    1850                 :        *  @return  Index of last occurrence.
    1851                 :        *
    1852                 :        *  Starting from @a pos, searches backward for @a c within this string.
    1853                 :        *  If found, returns the index where it was found.  If not found,
    1854                 :        *  returns npos.
    1855                 :       */
    1856                 :       size_type
    1857                 :       rfind(_CharT __c, size_type __pos = npos) const;
    1858                 : 
    1859                 :       /**
    1860                 :        *  @brief  Find position of a character of string.
    1861                 :        *  @param str  String containing characters to locate.
    1862                 :        *  @param pos  Index of character to search from (default 0).
    1863                 :        *  @return  Index of first occurrence.
    1864                 :        *
    1865                 :        *  Starting from @a pos, searches forward for one of the characters of
    1866                 :        *  @a str within this string.  If found, returns the index where it was
    1867                 :        *  found.  If not found, returns npos.
    1868                 :       */
    1869                 :       size_type
    1870               0 :       find_first_of(const basic_string& __str, size_type __pos = 0) const
    1871               0 :       { return this->find_first_of(__str.data(), __pos, __str.size()); }
    1872                 : 
    1873                 :       /**
    1874                 :        *  @brief  Find position of a character of C substring.
    1875                 :        *  @param s  String containing characters to locate.
    1876                 :        *  @param pos  Index of character to search from.
    1877                 :        *  @param n  Number of characters from s to search for.
    1878                 :        *  @return  Index of first occurrence.
    1879                 :        *
    1880                 :        *  Starting from @a pos, searches forward for one of the first @a n
    1881                 :        *  characters of @a s within this string.  If found, returns the index
    1882                 :        *  where it was found.  If not found, returns npos.
    1883                 :       */
    1884                 :       size_type
    1885                 :       find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
    1886                 : 
    1887                 :       /**
    1888                 :        *  @brief  Find position of a character of C string.
    1889                 :        *  @param s  String containing characters to locate.
    1890                 :        *  @param pos  Index of character to search from (default 0).
    1891                 :        *  @return  Index of first occurrence.
    1892                 :        *
    1893                 :        *  Starting from @a pos, searches forward for one of the characters of
    1894                 :        *  @a s within this string.  If found, returns the index where it was
    1895                 :        *  found.  If not found, returns npos.
    1896                 :       */
    1897                 :       size_type
    1898               0 :       find_first_of(const _CharT* __s, size_type __pos = 0) const
    1899                 :       {
    1900                 :         __glibcxx_requires_string(__s);
    1901               0 :         return this->find_first_of(__s, __pos, traits_type::length(__s));
    1902                 :       }
    1903                 : 
    1904                 :       /**
    1905                 :        *  @brief  Find position of a character.
    1906                 :        *  @param c  Character to locate.
    1907                 :        *  @param pos  Index of character to search from (default 0).
    1908                 :        *  @return  Index of first occurrence.
    1909                 :        *
    1910                 :        *  Starting from @a pos, searches forward for the character @a c within
    1911                 :        *  this string.  If found, returns the index where it was found.  If
    1912                 :        *  not found, returns npos.
    1913                 :        *
    1914                 :        *  Note: equivalent to find(c, pos).
    1915                 :       */
    1916                 :       size_type
    1917               0 :       find_first_of(_CharT __c, size_type __pos = 0) const
    1918               0 :       { return this->find(__c, __pos); }
    1919                 : 
    1920                 :       /**
    1921                 :        *  @brief  Find last position of a character of string.
    1922                 :        *  @param str  String containing characters to locate.
    1923                 :        *  @param pos  Index of character to search back from (default end).
    1924                 :        *  @return  Index of last occurrence.
    1925                 :        *
    1926                 :        *  Starting from @a pos, searches backward for one of the characters of
    1927                 :        *  @a str within this string.  If found, returns the index where it was
    1928                 :        *  found.  If not found, returns npos.
    1929                 :       */
    1930                 :       size_type
    1931               0 :       find_last_of(const basic_string& __str, size_type __pos = npos) const
    1932               0 :       { return this->find_last_of(__str.data(), __pos, __str.size()); }
    1933                 : 
    1934                 :       /**
    1935                 :        *  @brief  Find last position of a character of C substring.
    1936                 :        *  @param s  C string containing characters to locate.
    1937                 :        *  @param pos  Index of character to search back from.
    1938                 :        *  @param n  Number of characters from s to search for.
    1939                 :        *  @return  Index of last occurrence.
    1940                 :        *
    1941                 :        *  Starting from @a pos, searches backward for one of the first @a n
    1942                 :        *  characters of @a s within this string.  If found, returns the index
    1943                 :        *  where it was found.  If not found, returns npos.
    1944                 :       */
    1945                 :       size_type
    1946                 :       find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
    1947                 : 
    1948                 :       /**
    1949                 :        *  @brief  Find last position of a character of C string.
    1950                 :        *  @param s  C string containing characters to locate.
    1951                 :        *  @param pos  Index of character to search back from (default end).
    1952                 :        *  @return  Index of last occurrence.
    1953                 :        *
    1954                 :        *  Starting from @a pos, searches backward for one of the characters of
    1955                 :        *  @a s within this string.  If found, returns the index where it was
    1956                 :        *  found.  If not found, returns npos.
    1957                 :       */
    1958                 :       size_type
    1959               0 :       find_last_of(const _CharT* __s, size_type __pos = npos) const
    1960                 :       {
    1961                 :         __glibcxx_requires_string(__s);
    1962               0 :         return this->find_last_of(__s, __pos, traits_type::length(__s));
    1963                 :       }
    1964                 : 
    1965                 :       /**
    1966                 :        *  @brief  Find last position of a character.
    1967                 :        *  @param c  Character to locate.
    1968                 :        *  @param pos  Index of character to search back from (default end).
    1969                 :        *  @return  Index of last occurrence.
    1970                 :        *
    1971                 :        *  Starting from @a pos, searches backward for @a c within this string.
    1972                 :        *  If found, returns the index where it was found.  If not found,
    1973                 :        *  returns npos.
    1974                 :        *
    1975                 :        *  Note: equivalent to rfind(c, pos).
    1976                 :       */
    1977                 :       size_type
    1978               0 :       find_last_of(_CharT __c, size_type __pos = npos) const
    1979               0 :       { return this->rfind(__c, __pos); }
    1980                 : 
    1981                 :       /**
    1982                 :        *  @brief  Find position of a character not in string.
    1983                 :        *  @param str  String containing characters to avoid.
    1984                 :        *  @param pos  Index of character to search from (default 0).
    1985                 :        *  @return  Index of first occurrence.
    1986                 :        *
    1987                 :        *  Starting from @a pos, searches forward for a character not contained
    1988                 :        *  in @a str within this string.  If found, returns the index where it
    1989                 :        *  was found.  If not found, returns npos.
    1990                 :       */
    1991                 :       size_type
    1992               0 :       find_first_not_of(const basic_string& __str, size_type __pos = 0) const
    1993               0 :       { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
    1994                 : 
    1995                 :       /**
    1996                 :        *  @brief  Find position of a character not in C substring.
    1997                 :        *  @param s  C string containing characters to avoid.
    1998                 :        *  @param pos  Index of character to search from.
    1999                 :        *  @param n  Number of characters from s to consider.
    2000                 :        *  @return  Index of first occurrence.
    2001                 :        *
    2002                 :        *  Starting from @a pos, searches forward for a character not contained
    2003                 :        *  in the first @a n characters of @a s within this string.  If found,
    2004                 :        *  returns the index where it was found.  If not found, returns npos.
    2005                 :       */
    2006                 :       size_type
    2007                 :       find_first_not_of(const _CharT* __s, size_type __pos,
    2008                 :                         size_type __n) const;
    2009                 : 
    2010                 :       /**
    2011                 :        *  @brief  Find position of a character not in C string.
    2012                 :        *  @param s  C string containing characters to avoid.
    2013                 :        *  @param pos  Index of character to search from (default 0).
    2014                 :        *  @return  Index of first occurrence.
    2015                 :        *
    2016                 :        *  Starting from @a pos, searches forward for a character not contained
    2017                 :        *  in @a s within this string.  If found, returns the index where it
    2018                 :        *  was found.  If not found, returns npos.
    2019                 :       */
    2020                 :       size_type
    2021               0 :       find_first_not_of(const _CharT* __s, size_type __pos = 0) const
    2022                 :       {
    2023                 :         __glibcxx_requires_string(__s);
    2024               0 :         return this->find_first_not_of(__s, __pos, traits_type::length(__s));
    2025                 :       }
    2026                 : 
    2027                 :       /**
    2028                 :        *  @brief  Find position of a different character.
    2029                 :        *  @param c  Character to avoid.
    2030                 :        *  @param pos  Index of character to search from (default 0).
    2031                 :        *  @return  Index of first occurrence.
    2032                 :        *
    2033                 :        *  Starting from @a pos, searches forward for a character other than @a c
    2034                 :        *  within this string.  If found, returns the index where it was found.
    2035                 :        *  If not found, returns npos.
    2036                 :       */
    2037                 :       size_type
    2038                 :       find_first_not_of(_CharT __c, size_type __pos = 0) const;
    2039                 : 
    2040                 :       /**
    2041                 :        *  @brief  Find last position of a character not in string.
    2042                 :        *  @param str  String containing characters to avoid.
    2043                 :        *  @param pos  Index of character to search back from (default end).
    2044                 :        *  @return  Index of last occurrence.
    2045                 :        *
    2046                 :        *  Starting from @a pos, searches backward for a character not
    2047                 :        *  contained in @a str within this string.  If found, returns the index
    2048                 :        *  where it was found.  If not found, returns npos.
    2049                 :       */
    2050                 :       size_type
    2051               0 :       find_last_not_of(const basic_string& __str, size_type __pos = npos) const
    2052               0 :       { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
    2053                 : 
    2054                 :       /**
    2055                 :        *  @brief  Find last position of a character not in C substring.
    2056                 :        *  @param s  C string containing characters to avoid.
    2057                 :        *  @param pos  Index of character to search back from.
    2058                 :        *  @param n  Number of characters from s to consider.
    2059                 :        *  @return  Index of last occurrence.
    2060                 :        *
    2061                 :        *  Starting from @a pos, searches backward for a character not
    2062                 :        *  contained in the first @a n characters of @a s within this string.
    2063                 :        *  If found, returns the index where it was found.  If not found,
    2064                 :        *  returns npos.
    2065                 :       */
    2066                 :       size_type
    2067                 :       find_last_not_of(const _CharT* __s, size_type __pos,
    2068                 :                        size_type __n) const;
    2069                 :       /**
    2070                 :        *  @brief  Find last position of a character not in C string.
    2071                 :        *  @param s  C string containing characters to avoid.
    2072                 :        *  @param pos  Index of character to search back from (default end).
    2073                 :        *  @return  Index of last occurrence.
    2074                 :        *
    2075                 :        *  Starting from @a pos, searches backward for a character not
    2076                 :        *  contained in @a s within this string.  If found, returns the index
    2077                 :        *  where it was found.  If not found, returns npos.
    2078                 :       */
    2079                 :       size_type
    2080               0 :       find_last_not_of(const _CharT* __s, size_type __pos = npos) const
    2081                 :       {
    2082                 :         __glibcxx_requires_string(__s);
    2083               0 :         return this->find_last_not_of(__s, __pos, traits_type::length(__s));
    2084                 :       }
    2085                 : 
    2086                 :       /**
    2087                 :        *  @brief  Find last position of a different character.
    2088                 :        *  @param c  Character to avoid.
    2089                 :        *  @param pos  Index of character to search back from (default end).
    2090                 :        *  @return  Index of last occurrence.
    2091                 :        *
    2092                 :        *  Starting from @a pos, searches backward for a character other than
    2093                 :        *  @a c within this string.  If found, returns the index where it was
    2094                 :        *  found.  If not found, returns npos.
    2095                 :       */
    2096                 :       size_type
    2097                 :       find_last_not_of(_CharT __c, size_type __pos = npos) const;
    2098                 : 
    2099                 :       /**
    2100                 :        *  @brief  Get a substring.
    2101                 :        *  @param pos  Index of first character (default 0).
    2102                 :        *  @param n  Number of characters in substring (default remainder).
    2103                 :        *  @return  The new string.
    2104                 :        *  @throw  std::out_of_range  If pos > size().
    2105                 :        *
    2106                 :        *  Construct and return a new string using the @a n characters starting
    2107                 :        *  at @a pos.  If the string is too short, use the remainder of the
    2108                 :        *  characters.  If @a pos is beyond the end of the string, out_of_range
    2109                 :        *  is thrown.
    2110                 :       */
    2111                 :       basic_string
    2112               0 :       substr(size_type __pos = 0, size_type __n = npos) const
    2113                 :       { return basic_string(*this,
    2114               0 :                             _M_check(__pos, "basic_string::substr"), __n); }
    2115                 : 
    2116                 :       /**
    2117                 :        *  @brief  Compare to a string.
    2118                 :        *  @param str  String to compare against.
    2119                 :        *  @return  Integer < 0, 0, or > 0.
    2120                 :        *
    2121                 :        *  Returns an integer < 0 if this string is ordered before @a str, 0 if
    2122                 :        *  their values are equivalent, or > 0 if this string is ordered after
    2123                 :        *  @a str.  Determines the effective length rlen of the strings to
    2124                 :        *  compare as the smallest of size() and str.size().  The function
    2125                 :        *  then compares the two strings by calling traits::compare(data(),
    2126                 :        *  str.data(),rlen).  If the result of the comparison is nonzero returns
    2127                 :        *  it, otherwise the shorter one is ordered first.
    2128                 :       */
    2129                 :       int
    2130               0 :       compare(const basic_string& __str) const
    2131                 :       {
    2132               0 :         const size_type __size = this->size();
    2133               0 :         const size_type __osize = __str.size();
    2134               0 :         const size_type __len = std::min(__size, __osize);
    2135                 : 
    2136               0 :         int __r = traits_type::compare(_M_data(), __str.data(), __len);
    2137               0 :         if (!__r)
    2138               0 :           __r = _S_compare(__size, __osize);
    2139               0 :         return __r;
    2140                 :       }
    2141                 : 
    2142                 :       /**
    2143                 :        *  @brief  Compare substring to a string.
    2144                 :        *  @param pos  Index of first character of substring.
    2145                 :        *  @param n  Number of characters in substring.
    2146                 :        *  @param str  String to compare against.
    2147                 :        *  @return  Integer < 0, 0, or > 0.
    2148                 :        *
    2149                 :        *  Form the substring of this string from the @a n characters starting
    2150                 :        *  at @a pos.  Returns an integer < 0 if the substring is ordered
    2151                 :        *  before @a str, 0 if their values are equivalent, or > 0 if the
    2152                 :        *  substring is ordered after @a str.  Determines the effective length
    2153                 :        *  rlen of the strings to compare as the smallest of the length of the
    2154                 :        *  substring and @a str.size().  The function then compares the two
    2155                 :        *  strings by calling traits::compare(substring.data(),str.data(),rlen).
    2156                 :        *  If the result of the comparison is nonzero returns it, otherwise the
    2157                 :        *  shorter one is ordered first.
    2158                 :       */
    2159                 :       int
    2160                 :       compare(size_type __pos, size_type __n, const basic_string& __str) const;
    2161                 : 
    2162                 :       /**
    2163                 :        *  @brief  Compare substring to a substring.
    2164                 :        *  @param pos1  Index of first character of substring.
    2165                 :        *  @param n1  Number of characters in substring.
    2166                 :        *  @param str  String to compare against.
    2167                 :        *  @param pos2  Index of first character of substring of str.
    2168                 :        *  @param n2  Number of characters in substring of str.
    2169                 :        *  @return  Integer < 0, 0, or > 0.
    2170                 :        *
    2171                 :        *  Form the substring of this string from the @a n1 characters starting
    2172                 :        *  at @a pos1.  Form the substring of @a str from the @a n2 characters
    2173                 :        *  starting at @a pos2.  Returns an integer < 0 if this substring is
    2174                 :        *  ordered before the substring of @a str, 0 if their values are
    2175                 :        *  equivalent, or > 0 if this substring is ordered after the substring
    2176                 :        *  of @a str.  Determines the effective length rlen of the strings
    2177                 :        *  to compare as the smallest of the lengths of the substrings.  The
    2178                 :        *  function then compares the two strings by calling
    2179                 :        *  traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
    2180                 :        *  If the result of the comparison is nonzero returns it, otherwise the
    2181                 :        *  shorter one is ordered first.
    2182                 :       */
    2183                 :       int
    2184                 :       compare(size_type __pos1, size_type __n1, const basic_string& __str,
    2185                 :               size_type __pos2, size_type __n2) const;
    2186                 : 
    2187                 :       /**
    2188                 :        *  @brief  Compare to a C string.
    2189                 :        *  @param s  C string to compare against.
    2190                 :        *  @return  Integer < 0, 0, or > 0.
    2191                 :        *
    2192                 :        *  Returns an integer < 0 if this string is ordered before @a s, 0 if
    2193                 :        *  their values are equivalent, or > 0 if this string is ordered after
    2194                 :        *  @a s.  Determines the effective length rlen of the strings to
    2195                 :        *  compare as the smallest of size() and the length of a string
    2196                 :        *  constructed from @a s.  The function then compares the two strings
    2197                 :        *  by calling traits::compare(data(),s,rlen).  If the result of the
    2198                 :        *  comparison is nonzero returns it, otherwise the shorter one is
    2199                 :        *  ordered first.
    2200                 :       */
    2201                 :       int
    2202                 :       compare(const _CharT* __s) const;
    2203                 : 
    2204                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    2205                 :       // 5 String::compare specification questionable
    2206                 :       /**
    2207                 :        *  @brief  Compare substring to a C string.
    2208                 :        *  @param pos  Index of first character of substring.
    2209                 :        *  @param n1  Number of characters in substring.
    2210                 :        *  @param s  C string to compare against.
    2211                 :        *  @return  Integer < 0, 0, or > 0.
    2212                 :        *
    2213                 :        *  Form the substring of this string from the @a n1 characters starting
    2214                 :        *  at @a pos.  Returns an integer < 0 if the substring is ordered
    2215                 :        *  before @a s, 0 if their values are equivalent, or > 0 if the
    2216                 :        *  substring is ordered after @a s.  Determines the effective length
    2217                 :        *  rlen of the strings to compare as the smallest of the length of the 
    2218                 :        *  substring and the length of a string constructed from @a s.  The
    2219                 :        *  function then compares the two string by calling
    2220                 :        *  traits::compare(substring.data(),s,rlen).  If the result of the
    2221                 :        *  comparison is nonzero returns it, otherwise the shorter one is
    2222                 :        *  ordered first.
    2223                 :       */
    2224                 :       int
    2225                 :       compare(size_type __pos, size_type __n1, const _CharT* __s) const;
    2226                 : 
    2227                 :       /**
    2228                 :        *  @brief  Compare substring against a character %array.
    2229                 :        *  @param pos1  Index of first character of substring.
    2230                 :        *  @param n1  Number of characters in substring.
    2231                 :        *  @param s  character %array to compare against.
    2232                 :        *  @param n2  Number of characters of s.
    2233                 :        *  @return  Integer < 0, 0, or > 0.
    2234                 :        *
    2235                 :        *  Form the substring of this string from the @a n1 characters starting
    2236                 :        *  at @a pos1.  Form a string from the first @a n2 characters of @a s.
    2237                 :        *  Returns an integer < 0 if this substring is ordered before the string
    2238                 :        *  from @a s, 0 if their values are equivalent, or > 0 if this substring
    2239                 :        *  is ordered after the string from @a s.   Determines the effective
    2240                 :        *  length rlen of the strings to compare as the smallest of the length
    2241                 :        *  of the substring and @a n2.  The function then compares the two
    2242                 :        *  strings by calling traits::compare(substring.data(),s,rlen).  If the
    2243                 :        *  result of the comparison is nonzero returns it, otherwise the shorter
    2244                 :        *  one is ordered first.
    2245                 :        *
    2246                 :        *  NB: s must have at least n2 characters, &apos;\\0&apos; has
    2247                 :        *  no special meaning.
    2248                 :       */
    2249                 :       int
    2250                 :       compare(size_type __pos, size_type __n1, const _CharT* __s,
    2251                 :               size_type __n2) const;
    2252                 :   };
    2253                 : 
    2254                 :   // operator+
    2255                 :   /**
    2256                 :    *  @brief  Concatenate two strings.
    2257                 :    *  @param lhs  First string.
    2258                 :    *  @param rhs  Last string.
    2259                 :    *  @return  New string with value of @a lhs followed by @a rhs.
    2260                 :    */
    2261                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2262                 :     basic_string<_CharT, _Traits, _Alloc>
    2263         6951267 :     operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2264                 :               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2265                 :     {
    2266         6951267 :       basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
    2267         6951267 :       __str.append(__rhs);
    2268                 :       return __str;
    2269                 :     }
    2270                 : 
    2271                 :   /**
    2272                 :    *  @brief  Concatenate C string and string.
    2273                 :    *  @param lhs  First string.
    2274                 :    *  @param rhs  Last string.
    2275                 :    *  @return  New string with value of @a lhs followed by @a rhs.
    2276                 :    */
    2277                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2278                 :     basic_string<_CharT,_Traits,_Alloc>
    2279                 :     operator+(const _CharT* __lhs,
    2280                 :               const basic_string<_CharT,_Traits,_Alloc>& __rhs);
    2281                 : 
    2282                 :   /**
    2283                 :    *  @brief  Concatenate character and string.
    2284                 :    *  @param lhs  First string.
    2285                 :    *  @param rhs  Last string.
    2286                 :    *  @return  New string with @a lhs followed by @a rhs.
    2287                 :    */
    2288                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2289                 :     basic_string<_CharT,_Traits,_Alloc>
    2290                 :     operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
    2291                 : 
    2292                 :   /**
    2293                 :    *  @brief  Concatenate string and C string.
    2294                 :    *  @param lhs  First string.
    2295                 :    *  @param rhs  Last string.
    2296                 :    *  @return  New string with @a lhs followed by @a rhs.
    2297                 :    */
    2298                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2299                 :     inline basic_string<_CharT, _Traits, _Alloc>
    2300         6951267 :     operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2301                 :              const _CharT* __rhs)
    2302                 :     {
    2303         6951267 :       basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
    2304         6951267 :       __str.append(__rhs);
    2305                 :       return __str;
    2306                 :     }
    2307                 : 
    2308                 :   /**
    2309                 :    *  @brief  Concatenate string and character.
    2310                 :    *  @param lhs  First string.
    2311                 :    *  @param rhs  Last string.
    2312                 :    *  @return  New string with @a lhs followed by @a rhs.
    2313                 :    */
    2314                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2315                 :     inline basic_string<_CharT, _Traits, _Alloc>
    2316               0 :     operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
    2317                 :     {
    2318                 :       typedef basic_string<_CharT, _Traits, _Alloc>       __string_type;
    2319                 :       typedef typename __string_type::size_type         __size_type;
    2320               0 :       __string_type __str(__lhs);
    2321               0 :       __str.append(__size_type(1), __rhs);
    2322                 :       return __str;
    2323                 :     }
    2324                 : 
    2325                 :   // operator ==
    2326                 :   /**
    2327                 :    *  @brief  Test equivalence of two strings.
    2328                 :    *  @param lhs  First string.
    2329                 :    *  @param rhs  Second string.
    2330                 :    *  @return  True if @a lhs.compare(@a rhs) == 0.  False otherwise.
    2331                 :    */
    2332                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2333                 :     inline bool
    2334               0 :     operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2335                 :                const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2336               0 :     { return __lhs.compare(__rhs) == 0; }
    2337                 : 
    2338                 :   template<typename _CharT>
    2339                 :     inline
    2340                 :     typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
    2341          356947 :     operator==(const basic_string<_CharT>& __lhs,
    2342                 :                const basic_string<_CharT>& __rhs)
    2343                 :     { return (__lhs.size() == __rhs.size()
    2344                 :               && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
    2345          356947 :                                                     __lhs.size())); }
    2346                 : 
    2347                 :   /**
    2348                 :    *  @brief  Test equivalence of C string and string.
    2349                 :    *  @param lhs  C string.
    2350                 :    *  @param rhs  String.
    2351                 :    *  @return  True if @a rhs.compare(@a lhs) == 0.  False otherwise.
    2352                 :    */
    2353                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2354                 :     inline bool
    2355               0 :     operator==(const _CharT* __lhs,
    2356                 :                const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2357               0 :     { return __rhs.compare(__lhs) == 0; }
    2358                 : 
    2359                 :   /**
    2360                 :    *  @brief  Test equivalence of string and C string.
    2361                 :    *  @param lhs  String.
    2362                 :    *  @param rhs  C string.
    2363                 :    *  @return  True if @a lhs.compare(@a rhs) == 0.  False otherwise.
    2364                 :    */
    2365                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2366                 :     inline bool
    2367              69 :     operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2368                 :                const _CharT* __rhs)
    2369              69 :     { return __lhs.compare(__rhs) == 0; }
    2370                 : 
    2371                 :   // operator !=
    2372                 :   /**
    2373                 :    *  @brief  Test difference of two strings.
    2374                 :    *  @param lhs  First string.
    2375                 :    *  @param rhs  Second string.
    2376                 :    *  @return  True if @a lhs.compare(@a rhs) != 0.  False otherwise.
    2377                 :    */
    2378                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2379                 :     inline bool
    2380          356550 :     operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2381                 :                const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2382          356550 :     { return !(__lhs == __rhs); }
    2383                 : 
    2384                 :   /**
    2385                 :    *  @brief  Test difference of C string and string.
    2386                 :    *  @param lhs  C string.
    2387                 :    *  @param rhs  String.
    2388                 :    *  @return  True if @a rhs.compare(@a lhs) != 0.  False otherwise.
    2389                 :    */
    2390                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2391                 :     inline bool
    2392                 :     operator!=(const _CharT* __lhs,
    2393                 :                const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2394                 :     { return !(__lhs == __rhs); }
    2395                 : 
    2396                 :   /**
    2397                 :    *  @brief  Test difference of string and C string.
    2398                 :    *  @param lhs  String.
    2399                 :    *  @param rhs  C string.
    2400                 :    *  @return  True if @a lhs.compare(@a rhs) != 0.  False otherwise.
    2401                 :    */
    2402                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2403                 :     inline bool
    2404               0 :     operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2405                 :                const _CharT* __rhs)
    2406               0 :     { return !(__lhs == __rhs); }
    2407                 : 
    2408                 :   // operator <
    2409                 :   /**
    2410                 :    *  @brief  Test if string precedes string.
    2411                 :    *  @param lhs  First string.
    2412                 :    *  @param rhs  Second string.
    2413                 :    *  @return  True if @a lhs precedes @a rhs.  False otherwise.
    2414                 :    */
    2415                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2416                 :     inline bool
    2417       148849924 :     operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2418                 :               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2419       148849924 :     { return __lhs.compare(__rhs) < 0; }
    2420                 : 
    2421                 :   /**
    2422                 :    *  @brief  Test if string precedes C string.
    2423                 :    *  @param lhs  String.
    2424                 :    *  @param rhs  C string.
    2425                 :    *  @return  True if @a lhs precedes @a rhs.  False otherwise.
    2426                 :    */
    2427                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2428                 :     inline bool
    2429                 :     operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2430                 :               const _CharT* __rhs)
    2431                 :     { return __lhs.compare(__rhs) < 0; }
    2432                 : 
    2433                 :   /**
    2434                 :    *  @brief  Test if C string precedes string.
    2435                 :    *  @param lhs  C string.
    2436                 :    *  @param rhs  String.
    2437                 :    *  @return  True if @a lhs precedes @a rhs.  False otherwise.
    2438                 :    */
    2439                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2440                 :     inline bool
    2441                 :     operator<(const _CharT* __lhs,
    2442                 :               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2443                 :     { return __rhs.compare(__lhs) > 0; }
    2444                 : 
    2445                 :   // operator >
    2446                 :   /**
    2447                 :    *  @brief  Test if string follows string.
    2448                 :    *  @param lhs  First string.
    2449                 :    *  @param rhs  Second string.
    2450                 :    *  @return  True if @a lhs follows @a rhs.  False otherwise.
    2451                 :    */
    2452                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2453                 :     inline bool
    2454                 :     operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2455                 :               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2456                 :     { return __lhs.compare(__rhs) > 0; }
    2457                 : 
    2458                 :   /**
    2459                 :    *  @brief  Test if string follows C string.
    2460                 :    *  @param lhs  String.
    2461                 :    *  @param rhs  C string.
    2462                 :    *  @return  True if @a lhs follows @a rhs.  False otherwise.
    2463                 :    */
    2464                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2465                 :     inline bool
    2466                 :     operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2467                 :               const _CharT* __rhs)
    2468                 :     { return __lhs.compare(__rhs) > 0; }
    2469                 : 
    2470                 :   /**
    2471                 :    *  @brief  Test if C string follows string.
    2472                 :    *  @param lhs  C string.
    2473                 :    *  @param rhs  String.
    2474                 :    *  @return  True if @a lhs follows @a rhs.  False otherwise.
    2475                 :    */
    2476                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2477                 :     inline bool
    2478                 :     operator>(const _CharT* __lhs,
    2479                 :               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2480                 :     { return __rhs.compare(__lhs) < 0; }
    2481                 : 
    2482                 :   // operator <=
    2483                 :   /**
    2484                 :    *  @brief  Test if string doesn't follow string.
    2485                 :    *  @param lhs  First string.
    2486                 :    *  @param rhs  Second string.
    2487                 :    *  @return  True if @a lhs doesn't follow @a rhs.  False otherwise.
    2488                 :    */
    2489                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2490                 :     inline bool
    2491                 :     operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2492                 :                const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2493                 :     { return __lhs.compare(__rhs) <= 0; }
    2494                 : 
    2495                 :   /**
    2496                 :    *  @brief  Test if string doesn't follow C string.
    2497                 :    *  @param lhs  String.
    2498                 :    *  @param rhs  C string.
    2499                 :    *  @return  True if @a lhs doesn't follow @a rhs.  False otherwise.
    2500                 :    */
    2501                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2502                 :     inline bool
    2503                 :     operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2504                 :                const _CharT* __rhs)
    2505                 :     { return __lhs.compare(__rhs) <= 0; }
    2506                 : 
    2507                 :   /**
    2508                 :    *  @brief  Test if C string doesn't follow string.
    2509                 :    *  @param lhs  C string.
    2510                 :    *  @param rhs  String.
    2511                 :    *  @return  True if @a lhs doesn't follow @a rhs.  False otherwise.
    2512                 :    */
    2513                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2514                 :     inline bool
    2515                 :     operator<=(const _CharT* __lhs,
    2516                 :                const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2517                 :     { return __rhs.compare(__lhs) >= 0; }
    2518                 : 
    2519                 :   // operator >=
    2520                 :   /**
    2521                 :    *  @brief  Test if string doesn't precede string.
    2522                 :    *  @param lhs  First string.
    2523                 :    *  @param rhs  Second string.
    2524                 :    *  @return  True if @a lhs doesn't precede @a rhs.  False otherwise.
    2525                 :    */
    2526                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2527                 :     inline bool
    2528                 :     operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2529                 :                const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2530                 :     { return __lhs.compare(__rhs) >= 0; }
    2531                 : 
    2532                 :   /**
    2533                 :    *  @brief  Test if string doesn't precede C string.
    2534                 :    *  @param lhs  String.
    2535                 :    *  @param rhs  C string.
    2536                 :    *  @return  True if @a lhs doesn't precede @a rhs.  False otherwise.
    2537                 :    */
    2538                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2539                 :     inline bool
    2540                 :     operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2541                 :                const _CharT* __rhs)
    2542                 :     { return __lhs.compare(__rhs) >= 0; }
    2543                 : 
    2544                 :   /**
    2545                 :    *  @brief  Test if C string doesn't precede string.
    2546                 :    *  @param lhs  C string.
    2547                 :    *  @param rhs  String.
    2548                 :    *  @return  True if @a lhs doesn't precede @a rhs.  False otherwise.
    2549                 :    */
    2550                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2551                 :     inline bool
    2552                 :     operator>=(const _CharT* __lhs,
    2553                 :              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2554                 :     { return __rhs.compare(__lhs) <= 0; }
    2555                 : 
    2556                 :   /**
    2557                 :    *  @brief  Swap contents of two strings.
    2558                 :    *  @param lhs  First string.
    2559                 :    *  @param rhs  Second string.
    2560                 :    *
    2561                 :    *  Exchanges the contents of @a lhs and @a rhs in constant time.
    2562                 :    */
    2563                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2564                 :     inline void
    2565                 :     swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
    2566                 :          basic_string<_CharT, _Traits, _Alloc>& __rhs)
    2567                 :     { __lhs.swap(__rhs); }
    2568                 : 
    2569                 :   /**
    2570                 :    *  @brief  Read stream into a string.
    2571                 :    *  @param is  Input stream.
    2572                 :    *  @param str  Buffer to store into.
    2573                 :    *  @return  Reference to the input stream.
    2574                 :    *
    2575                 :    *  Stores characters from @a is into @a str until whitespace is found, the
    2576                 :    *  end of the stream is encountered, or str.max_size() is reached.  If
    2577                 :    *  is.width() is non-zero, that is the limit on the number of characters
    2578                 :    *  stored into @a str.  Any previous contents of @a str are erased.
    2579                 :    */
    2580                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2581                 :     basic_istream<_CharT, _Traits>&
    2582                 :     operator>>(basic_istream<_CharT, _Traits>& __is,
    2583                 :                basic_string<_CharT, _Traits, _Alloc>& __str);
    2584                 : 
    2585                 :   template<>
    2586                 :     basic_istream<char>&
    2587                 :     operator>>(basic_istream<char>& __is, basic_string<char>& __str);
    2588                 : 
    2589                 :   /**
    2590                 :    *  @brief  Write string to a stream.
    2591                 :    *  @param os  Output stream.
    2592                 :    *  @param str  String to write out.
    2593                 :    *  @return  Reference to the output stream.
    2594                 :    *
    2595                 :    *  Output characters of @a str into os following the same rules as for
    2596                 :    *  writing a C string.
    2597                 :    */
    2598                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2599                 :     inline basic_ostream<_CharT, _Traits>&
    2600               0 :     operator<<(basic_ostream<_CharT, _Traits>& __os,
    2601                 :                const basic_string<_CharT, _Traits, _Alloc>& __str)
    2602                 :     {
    2603                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    2604                 :       // 586. string inserter not a formatted function
    2605               0 :       return __ostream_insert(__os, __str.data(), __str.size());
    2606                 :     }
    2607                 : 
    2608                 :   /**
    2609                 :    *  @brief  Read a line from stream into a string.
    2610                 :    *  @param is  Input stream.
    2611                 :    *  @param str  Buffer to store into.
    2612                 :    *  @param delim  Character marking end of line.
    2613                 :    *  @return  Reference to the input stream.
    2614                 :    *
    2615                 :    *  Stores characters from @a is into @a str until @a delim is found, the
    2616                 :    *  end of the stream is encountered, or str.max_size() is reached.  If
    2617                 :    *  is.width() is non-zero, that is the limit on the number of characters
    2618                 :    *  stored into @a str.  Any previous contents of @a str are erased.  If @a
    2619                 :    *  delim was encountered, it is extracted but not stored into @a str.
    2620                 :    */
    2621                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2622                 :     basic_istream<_CharT, _Traits>&
    2623                 :     getline(basic_istream<_CharT, _Traits>& __is,
    2624                 :             basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
    2625                 : 
    2626                 :   /**
    2627                 :    *  @brief  Read a line from stream into a string.
    2628                 :    *  @param is  Input stream.
    2629                 :    *  @param str  Buffer to store into.
    2630                 :    *  @return  Reference to the input stream.
    2631                 :    *
    2632                 :    *  Stores characters from is into @a str until &apos;\n&apos; is
    2633                 :    *  found, the end of the stream is encountered, or str.max_size()
    2634                 :    *  is reached.  If is.width() is non-zero, that is the limit on the
    2635                 :    *  number of characters stored into @a str.  Any previous contents
    2636                 :    *  of @a str are erased.  If end of line was encountered, it is
    2637                 :    *  extracted but not stored into @a str.
    2638                 :    */
    2639                 :   template<typename _CharT, typename _Traits, typename _Alloc>
    2640                 :     inline basic_istream<_CharT, _Traits>&
    2641                 :     getline(basic_istream<_CharT, _Traits>& __is,
    2642                 :             basic_string<_CharT, _Traits, _Alloc>& __str)
    2643                 :     { return getline(__is, __str, __is.widen('\n')); }
    2644                 : 
    2645                 :   template<>
    2646                 :     basic_istream<char>&
    2647                 :     getline(basic_istream<char>& __in, basic_string<char>& __str,
    2648                 :             char __delim);
    2649                 : 
    2650                 : #ifdef _GLIBCXX_USE_WCHAR_T
    2651                 :   template<>
    2652                 :     basic_istream<wchar_t>&
    2653                 :     getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
    2654                 :             wchar_t __delim);
    2655                 : #endif  
    2656                 : 
    2657                 : _GLIBCXX_END_NAMESPACE
    2658                 : 
    2659                 : #if (defined(__GXX_EXPERIMENTAL_CXX0X__) && defined(_GLIBCXX_USE_C99) \
    2660                 :      && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
    2661                 : 
    2662                 : #include <ext/string_conversions.h>
    2663                 : 
    2664                 : _GLIBCXX_BEGIN_NAMESPACE(std)
    2665                 : 
    2666                 :   // 21.4 Numeric Conversions [string.conversions].
    2667                 :   inline int
    2668                 :   stoi(const string& __str, size_t* __idx = 0, int __base = 10)
    2669                 :   { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
    2670                 :                                         __idx, __base); }
    2671                 : 
    2672                 :   inline long
    2673                 :   stol(const string& __str, size_t* __idx = 0, int __base = 10)
    2674                 :   { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
    2675                 :                              __idx, __base); }
    2676                 : 
    2677                 :   inline unsigned long
    2678                 :   stoul(const string& __str, size_t* __idx = 0, int __base = 10)
    2679                 :   { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
    2680                 :                              __idx, __base); }
    2681                 : 
    2682                 :   inline long long
    2683                 :   stoll(const string& __str, size_t* __idx = 0, int __base = 10)
    2684                 :   { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
    2685                 :                              __idx, __base); }
    2686                 : 
    2687                 :   inline unsigned long long
    2688                 :   stoull(const string& __str, size_t* __idx = 0, int __base = 10)
    2689                 :   { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
    2690                 :                              __idx, __base); }
    2691                 : 
    2692                 :   // NB: strtof vs strtod.
    2693                 :   inline float
    2694                 :   stof(const string& __str, size_t* __idx = 0)
    2695                 :   { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
    2696                 : 
    2697                 :   inline double
    2698                 :   stod(const string& __str, size_t* __idx = 0)
    2699                 :   { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
    2700                 : 
    2701                 :   inline long double
    2702                 :   stold(const string& __str, size_t* __idx = 0)
    2703                 :   { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
    2704                 : 
    2705                 :   // NB: (v)snprintf vs sprintf.
    2706                 : 
    2707                 :   // DR 1261.
    2708                 :   inline string
    2709                 :   to_string(int __val)
    2710                 :   { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
    2711                 :                                            "%d", __val); }
    2712                 : 
    2713                 :   inline string
    2714                 :   to_string(unsigned __val)
    2715                 :   { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
    2716                 :                                            4 * sizeof(unsigned),
    2717                 :                                            "%u", __val); }
    2718                 : 
    2719                 :   inline string
    2720                 :   to_string(long __val)
    2721                 :   { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
    2722                 :                                            "%ld", __val); }
    2723                 : 
    2724                 :   inline string
    2725                 :   to_string(unsigned long __val)
    2726                 :   { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
    2727                 :                                            4 * sizeof(unsigned long),
    2728                 :                                            "%lu", __val); }
    2729                 : 
    2730                 :   inline string
    2731                 :   to_string(long long __val)
    2732                 :   { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
    2733                 :                                            4 * sizeof(long long),
    2734                 :                                            "%lld", __val); }
    2735                 : 
    2736                 :   inline string
    2737                 :   to_string(unsigned long long __val)
    2738                 :   { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
    2739                 :                                            4 * sizeof(unsigned long long),
    2740                 :                                            "%llu", __val); }
    2741                 : 
    2742                 :   inline string
    2743                 :   to_string(float __val)
    2744                 :   {
    2745                 :     const int __n = 
    2746                 :       __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
    2747                 :     return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
    2748                 :                                            "%f", __val);
    2749                 :   }
    2750                 : 
    2751                 :   inline string
    2752                 :   to_string(double __val)
    2753                 :   {
    2754                 :     const int __n = 
    2755                 :       __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
    2756                 :     return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
    2757                 :                                            "%f", __val);
    2758                 :   }
    2759                 : 
    2760                 :   inline string
    2761                 :   to_string(long double __val)
    2762                 :   {
    2763                 :     const int __n = 
    2764                 :       __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
    2765                 :     return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
    2766                 :                                            "%Lf", __val);
    2767                 :   }
    2768                 : 
    2769                 : #ifdef _GLIBCXX_USE_WCHAR_T
    2770                 :   inline int 
    2771                 :   stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
    2772                 :   { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
    2773                 :                                         __idx, __base); }
    2774                 : 
    2775                 :   inline long 
    2776                 :   stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
    2777                 :   { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
    2778                 :                              __idx, __base); }
    2779                 : 
    2780                 :   inline unsigned long
    2781                 :   stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
    2782                 :   { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
    2783                 :                              __idx, __base); }
    2784                 : 
    2785                 :   inline long long
    2786                 :   stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
    2787                 :   { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
    2788                 :                              __idx, __base); }
    2789                 : 
    2790                 :   inline unsigned long long
    2791                 :   stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
    2792                 :   { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
    2793                 :                              __idx, __base); }
    2794                 : 
    2795                 :   // NB: wcstof vs wcstod.
    2796                 :   inline float
    2797                 :   stof(const wstring& __str, size_t* __idx = 0)
    2798                 :   { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
    2799                 : 
    2800                 :   inline double
    2801                 :   stod(const wstring& __str, size_t* __idx = 0)
    2802                 :   { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
    2803                 : 
    2804                 :   inline long double
    2805                 :   stold(const wstring& __str, size_t* __idx = 0)
    2806                 :   { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
    2807                 : 
    2808                 :   // DR 1261.
    2809                 :   inline wstring
    2810                 :   to_wstring(int __val)
    2811                 :   { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
    2812                 :                                             L"%d", __val); }
    2813                 : 
    2814                 :   inline wstring
    2815                 :   to_wstring(unsigned __val)
    2816                 :   { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
    2817                 :                                             4 * sizeof(unsigned),
    2818                 :                                             L"%u", __val); }
    2819                 : 
    2820                 :   inline wstring
    2821                 :   to_wstring(long __val)
    2822                 :   { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
    2823                 :                                             L"%ld", __val); }
    2824                 : 
    2825                 :   inline wstring
    2826                 :   to_wstring(unsigned long __val)
    2827                 :   { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
    2828                 :                                             4 * sizeof(unsigned long),
    2829                 :                                             L"%lu", __val); }
    2830                 : 
    2831                 :   inline wstring
    2832                 :   to_wstring(long long __val)
    2833                 :   { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
    2834                 :                                             4 * sizeof(long long),
    2835                 :                                             L"%lld", __val); }
    2836                 : 
    2837                 :   inline wstring
    2838                 :   to_wstring(unsigned long long __val)
    2839                 :   { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
    2840                 :                                             4 * sizeof(unsigned long long),
    2841                 :                                             L"%llu", __val); }
    2842                 : 
    2843                 :   inline wstring
    2844                 :   to_wstring(float __val)
    2845                 :   {
    2846                 :     const int __n =
    2847                 :       __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
    2848                 :     return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
    2849                 :                                             L"%f", __val);
    2850                 :   }
    2851                 : 
    2852                 :   inline wstring
    2853                 :   to_wstring(double __val)
    2854                 :   {
    2855                 :     const int __n =
    2856                 :       __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
    2857                 :     return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
    2858                 :                                             L"%f", __val);
    2859                 :   }
    2860                 : 
    2861                 :   inline wstring
    2862                 :   to_wstring(long double __val)
    2863                 :   {
    2864                 :     const int __n =
    2865                 :       __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
    2866                 :     return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
    2867                 :                                             L"%Lf", __val);
    2868                 :   }
    2869                 : #endif
    2870                 : 
    2871                 : _GLIBCXX_END_NAMESPACE
    2872                 : 
    2873                 : #endif /* __GXX_EXPERIMENTAL_CXX0X__ && _GLIBCXX_USE_C99 ... */
    2874                 : 
    2875                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    2876                 : 
    2877                 : #include <bits/functional_hash.h>
    2878                 : 
    2879                 : _GLIBCXX_BEGIN_NAMESPACE(std)
    2880                 : 
    2881                 :   // DR 1182.
    2882                 : 
    2883                 : #ifndef _GLIBCXX_COMPATIBILITY_CXX0X
    2884                 :   /// std::hash specialization for string.
    2885                 :   template<>
    2886                 :     struct hash<string>
    2887                 :     : public std::unary_function<string, size_t>
    2888                 :     {
    2889                 :       size_t
    2890                 :       operator()(const string& __s) const
    2891                 :       { return std::_Fnv_hash::hash(__s.data(), __s.length()); }
    2892                 :     };
    2893                 : 
    2894                 : #ifdef _GLIBCXX_USE_WCHAR_T
    2895                 :   /// std::hash specialization for wstring.
    2896                 :   template<>
    2897                 :     struct hash<wstring>
    2898                 :     : public std::unary_function<wstring, size_t>
    2899                 :     {
    2900                 :       size_t
    2901                 :       operator()(const wstring& __s) const
    2902                 :       { return std::_Fnv_hash::hash(__s.data(),
    2903                 :                                     __s.length() * sizeof(wchar_t)); }
    2904                 :     };
    2905                 : #endif
    2906                 : #endif /* _GLIBCXX_COMPATIBILITY_CXX0X */
    2907                 : 
    2908                 : #ifdef _GLIBCXX_USE_C99_STDINT_TR1
    2909                 :   /// std::hash specialization for u16string.
    2910                 :   template<>
    2911                 :     struct hash<u16string>
    2912                 :     : public std::unary_function<u16string, size_t>
    2913                 :     {
    2914                 :       size_t
    2915                 :       operator()(const u16string& __s) const
    2916                 :       { return std::_Fnv_hash::hash(__s.data(),
    2917                 :                                     __s.length() * sizeof(char16_t)); }
    2918                 :     };
    2919                 : 
    2920                 :   /// std::hash specialization for u32string.
    2921                 :   template<>
    2922                 :     struct hash<u32string>
    2923                 :     : public std::unary_function<u32string, size_t>
    2924                 :     {
    2925                 :       size_t
    2926                 :       operator()(const u32string& __s) const
    2927                 :       { return std::_Fnv_hash::hash(__s.data(),
    2928                 :                                     __s.length() * sizeof(char32_t)); }
    2929                 :     };
    2930                 : #endif
    2931                 : 
    2932                 : _GLIBCXX_END_NAMESPACE
    2933                 : 
    2934                 : #endif /* __GXX_EXPERIMENTAL_CXX0X__ */
    2935                 : 
    2936                 : #endif /* _BASIC_STRING_H */

Generated by: LCOV version 1.7