From 006621455482edd8abf46a05292120745f99f7ec Mon Sep 17 00:00:00 2001 From: Enrico Zini Date: Tue, 29 Sep 2009 15:08:02 +0100 Subject: Initial import --- .../include/c++/4.3/bits/basic_string.h.gcov.html | 2545 ++++++++++++++++++++ 1 file changed, 2545 insertions(+) create mode 100644 rep/usr/include/c++/4.3/bits/basic_string.h.gcov.html (limited to 'rep/usr/include/c++/4.3/bits/basic_string.h.gcov.html') diff --git a/rep/usr/include/c++/4.3/bits/basic_string.h.gcov.html b/rep/usr/include/c++/4.3/bits/basic_string.h.gcov.html new file mode 100644 index 0000000..909cd58 --- /dev/null +++ b/rep/usr/include/c++/4.3/bits/basic_string.h.gcov.html @@ -0,0 +1,2545 @@ + + + + + + + LCOV - lcov.info - /usr/include/c++/4.3/bits/basic_string.h + + + + + + + + + + + + + +
LTP GCOV extension - code coverage report
+ + + + + + + + + + + + + + + + + + + + + + + +
Current view:directory - usr/include/c++/4.3/bits - basic_string.h
Test:lcov.info
Date:2008-08-14Instrumented lines:178
Code covered:17.4 %Executed lines:31
+
+ + + + + + + + + 

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