vstring.h

Go to the documentation of this file.
00001 // Versatile string -*- C++ -*-
00002 
00003 // Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
00004 // Free Software Foundation, Inc.
00005 //
00006 // This file is part of the GNU ISO C++ Library.  This library is free
00007 // software; you can redistribute it and/or modify it under the
00008 // terms of the GNU General Public License as published by the
00009 // Free Software Foundation; either version 3, or (at your option)
00010 // any later version.
00011 
00012 // This library is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // GNU General Public License for more details.
00016 
00017 // Under Section 7 of GPL version 3, you are granted additional
00018 // permissions described in the GCC Runtime Library Exception, version
00019 // 3.1, as published by the Free Software Foundation.
00020 
00021 // You should have received a copy of the GNU General Public License and
00022 // a copy of the GCC Runtime Library Exception along with this program;
00023 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00024 // <http://www.gnu.org/licenses/>.
00025 
00026 /** @file ext/vstring.h
00027  *  This file is a GNU extension to the Standard C++ Library.
00028  */
00029 
00030 #ifndef _VSTRING_H
00031 #define _VSTRING_H 1
00032 
00033 #pragma GCC system_header
00034 
00035 #include <initializer_list>
00036 #include <ext/vstring_util.h>
00037 #include <ext/rc_string_base.h>
00038 #include <ext/sso_string_base.h>
00039 
00040 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
00041 
00042   /**
00043    *  @class __versa_string vstring.h
00044    *  @brief  Template class __versa_string. 
00045    *  @ingroup extensions
00046    *
00047    *  Data structure managing sequences of characters and
00048    *  character-like objects. 
00049    */
00050   template<typename _CharT, typename _Traits, typename _Alloc,
00051        template <typename, typename, typename> class _Base>
00052     class __versa_string
00053     : private _Base<_CharT, _Traits, _Alloc>
00054     {
00055       typedef _Base<_CharT, _Traits, _Alloc>                __vstring_base;    
00056       typedef typename __vstring_base::_CharT_alloc_type    _CharT_alloc_type;
00057 
00058       // Types:
00059     public:
00060       typedef _Traits                       traits_type;
00061       typedef typename _Traits::char_type           value_type;
00062       typedef _Alloc                        allocator_type;
00063       typedef typename _CharT_alloc_type::size_type     size_type;
00064       typedef typename _CharT_alloc_type::difference_type   difference_type;
00065       typedef typename _CharT_alloc_type::reference     reference;
00066       typedef typename _CharT_alloc_type::const_reference   const_reference;
00067       typedef typename _CharT_alloc_type::pointer       pointer;
00068       typedef typename _CharT_alloc_type::const_pointer     const_pointer;
00069       typedef __gnu_cxx::__normal_iterator<pointer, __versa_string>  iterator;
00070       typedef __gnu_cxx::__normal_iterator<const_pointer, __versa_string>
00071                                                             const_iterator;
00072       typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00073       typedef std::reverse_iterator<iterator>           reverse_iterator;
00074 
00075       // Data Member (public):
00076       ///  Value returned by various member functions when they fail.
00077       static const size_type    npos = static_cast<size_type>(-1);
00078 
00079     private:
00080       size_type
00081       _M_check(size_type __pos, const char* __s) const
00082       {
00083     if (__pos > this->size())
00084       std::__throw_out_of_range(__N(__s));
00085     return __pos;
00086       }
00087 
00088       void
00089       _M_check_length(size_type __n1, size_type __n2, const char* __s) const
00090       {
00091     if (this->max_size() - (this->size() - __n1) < __n2)
00092       std::__throw_length_error(__N(__s));
00093       }
00094 
00095       // NB: _M_limit doesn't check for a bad __pos value.
00096       size_type
00097       _M_limit(size_type __pos, size_type __off) const
00098       {
00099     const bool __testoff =  __off < this->size() - __pos;
00100     return __testoff ? __off : this->size() - __pos;
00101       }
00102 
00103       // True if _Rep and source do not overlap.
00104       bool
00105       _M_disjunct(const _CharT* __s) const
00106       {
00107     return (std::less<const _CharT*>()(__s, this->_M_data())
00108         || std::less<const _CharT*>()(this->_M_data()
00109                           + this->size(), __s));
00110       }
00111 
00112       // For the internal use we have functions similar to `begin'/`end'
00113       // but they do not call _M_leak.
00114       iterator
00115       _M_ibegin() const
00116       { return iterator(this->_M_data()); }
00117 
00118       iterator
00119       _M_iend() const
00120       { return iterator(this->_M_data() + this->_M_length()); }
00121 
00122     public:
00123       // Construct/copy/destroy:
00124       // NB: We overload ctors in some cases instead of using default
00125       // arguments, per 17.4.4.4 para. 2 item 2.
00126 
00127       /**
00128        *  @brief  Default constructor creates an empty string.
00129        */
00130       __versa_string()
00131       : __vstring_base() { }
00132       
00133       /**
00134        *  @brief  Construct an empty string using allocator @a a.
00135        */
00136       explicit
00137       __versa_string(const _Alloc& __a)
00138       : __vstring_base(__a) { }
00139 
00140       // NB: per LWG issue 42, semantics different from IS:
00141       /**
00142        *  @brief  Construct string with copy of value of @a str.
00143        *  @param  __str  Source string.
00144        */
00145       __versa_string(const __versa_string& __str)
00146       : __vstring_base(__str) { }
00147 
00148 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00149       /**
00150        *  @brief  String move constructor.
00151        *  @param  __str  Source string.
00152        *
00153        *  The newly-constructed %string contains the exact contents of
00154        *  @a str.  The contents of @a str are a valid, but unspecified
00155        *  string.
00156        */
00157       __versa_string(__versa_string&& __str)
00158       : __vstring_base(std::forward<__vstring_base>(__str)) { }
00159 
00160       /**
00161        *  @brief  Construct string from an initializer list.
00162        *  @param  __l  std::initializer_list of characters.
00163        *  @param  __a  Allocator to use (default is default allocator).
00164        */
00165       __versa_string(std::initializer_list<_CharT> __l,
00166              const _Alloc& __a = _Alloc())
00167       : __vstring_base(__l.begin(), __l.end(), __a) { }
00168 #endif
00169 
00170       /**
00171        *  @brief  Construct string as copy of a substring.
00172        *  @param  __str  Source string.
00173        *  @param  __pos  Index of first character to copy from.
00174        *  @param  __n  Number of characters to copy (default remainder).
00175        */
00176       __versa_string(const __versa_string& __str, size_type __pos,
00177              size_type __n = npos)
00178       : __vstring_base(__str._M_data()
00179                + __str._M_check(__pos,
00180                     "__versa_string::__versa_string"),
00181                __str._M_data() + __str._M_limit(__pos, __n)
00182                + __pos, _Alloc()) { }
00183 
00184       /**
00185        *  @brief  Construct string as copy of a substring.
00186        *  @param  __str  Source string.
00187        *  @param  __pos  Index of first character to copy from.
00188        *  @param  __n  Number of characters to copy.
00189        *  @param  __a  Allocator to use.
00190        */
00191       __versa_string(const __versa_string& __str, size_type __pos,
00192              size_type __n, const _Alloc& __a)
00193       : __vstring_base(__str._M_data()
00194                + __str._M_check(__pos,
00195                     "__versa_string::__versa_string"),
00196                __str._M_data() + __str._M_limit(__pos, __n)
00197                + __pos, __a) { }
00198 
00199       /**
00200        *  @brief  Construct string initialized by a character array.
00201        *  @param  __s  Source character array.
00202        *  @param  __n  Number of characters to copy.
00203        *  @param  __a  Allocator to use (default is default allocator).
00204        *
00205        *  NB: @a __s must have at least @a __n characters, '\\0' has no special
00206        *  meaning.
00207        */
00208       __versa_string(const _CharT* __s, size_type __n,
00209              const _Alloc& __a = _Alloc())
00210       : __vstring_base(__s, __s + __n, __a) { }
00211 
00212       /**
00213        *  @brief  Construct string as copy of a C string.
00214        *  @param  __s  Source C string.
00215        *  @param  __a  Allocator to use (default is default allocator).
00216        */
00217       __versa_string(const _CharT* __s, const _Alloc& __a = _Alloc())
00218       : __vstring_base(__s, __s ? __s + traits_type::length(__s) :
00219                __s + npos, __a) { }
00220 
00221       /**
00222        *  @brief  Construct string as multiple characters.
00223        *  @param  __n  Number of characters.
00224        *  @param  __c  Character to use.
00225        *  @param  __a  Allocator to use (default is default allocator).
00226        */
00227       __versa_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
00228       : __vstring_base(__n, __c, __a) { }
00229 
00230       /**
00231        *  @brief  Construct string as copy of a range.
00232        *  @param  __beg  Start of range.
00233        *  @param  __end  End of range.
00234        *  @param  __a  Allocator to use (default is default allocator).
00235        */
00236       template<class _InputIterator>
00237         __versa_string(_InputIterator __beg, _InputIterator __end,
00238                const _Alloc& __a = _Alloc())
00239     : __vstring_base(__beg, __end, __a) { }
00240 
00241       /**
00242        *  @brief  Destroy the string instance.
00243        */
00244       ~__versa_string() { } 
00245 
00246       /**
00247        *  @brief  Assign the value of @a str to this string.
00248        *  @param  __str  Source string.
00249        */
00250       __versa_string&
00251       operator=(const __versa_string& __str) 
00252       { return this->assign(__str); }
00253 
00254 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00255       /**
00256        *  @brief  String move assignment operator.
00257        *  @param  __str  Source string.
00258        *
00259        *  The contents of @a __str are moved into this string (without
00260        *  copying).  @a __str is a valid, but unspecified string.
00261        */
00262       __versa_string&
00263       operator=(__versa_string&& __str)
00264       {
00265     // NB: DR 1204.
00266     this->swap(__str);
00267     return *this;
00268       }
00269 
00270       /**
00271        *  @brief  Set value to string constructed from initializer list.
00272        *  @param  __l  std::initializer_list.
00273        */
00274       __versa_string&
00275       operator=(std::initializer_list<_CharT> __l)
00276       {
00277     this->assign(__l.begin(), __l.end());
00278     return *this;
00279       }
00280 #endif
00281 
00282       /**
00283        *  @brief  Copy contents of @a __s into this string.
00284        *  @param  __s  Source null-terminated string.
00285        */
00286       __versa_string&
00287       operator=(const _CharT* __s) 
00288       { return this->assign(__s); }
00289 
00290       /**
00291        *  @brief  Set value to string of length 1.
00292        *  @param  __c  Source character.
00293        *
00294        *  Assigning to a character makes this string length 1 and
00295        *  (*this)[0] == @a __c.
00296        */
00297       __versa_string&
00298       operator=(_CharT __c) 
00299       { 
00300     this->assign(1, __c); 
00301     return *this;
00302       }
00303 
00304       // Iterators:
00305       /**
00306        *  Returns a read/write iterator that points to the first character in
00307        *  the %string.  Unshares the string.
00308        */
00309       iterator
00310       begin()
00311       {
00312     this->_M_leak();
00313     return iterator(this->_M_data());
00314       }
00315 
00316       /**
00317        *  Returns a read-only (constant) iterator that points to the first
00318        *  character in the %string.
00319        */
00320       const_iterator
00321       begin() const
00322       { return const_iterator(this->_M_data()); }
00323 
00324       /**
00325        *  Returns a read/write iterator that points one past the last
00326        *  character in the %string.  Unshares the string.
00327        */
00328       iterator
00329       end()
00330       {
00331     this->_M_leak();
00332     return iterator(this->_M_data() + this->size());
00333       }
00334 
00335       /**
00336        *  Returns a read-only (constant) iterator that points one past the
00337        *  last character in the %string.
00338        */
00339       const_iterator
00340       end() const
00341       { return const_iterator(this->_M_data() + this->size()); }
00342 
00343       /**
00344        *  Returns a read/write reverse iterator that points to the last
00345        *  character in the %string.  Iteration is done in reverse element
00346        *  order.  Unshares the string.
00347        */
00348       reverse_iterator
00349       rbegin()
00350       { return reverse_iterator(this->end()); }
00351 
00352       /**
00353        *  Returns a read-only (constant) reverse iterator that points
00354        *  to the last character in the %string.  Iteration is done in
00355        *  reverse element order.
00356        */
00357       const_reverse_iterator
00358       rbegin() const
00359       { return const_reverse_iterator(this->end()); }
00360 
00361       /**
00362        *  Returns a read/write reverse iterator that points to one before the
00363        *  first character in the %string.  Iteration is done in reverse
00364        *  element order.  Unshares the string.
00365        */
00366       reverse_iterator
00367       rend()
00368       { return reverse_iterator(this->begin()); }
00369 
00370       /**
00371        *  Returns a read-only (constant) reverse iterator that points
00372        *  to one before the first character in the %string.  Iteration
00373        *  is done in reverse element order.
00374        */
00375       const_reverse_iterator
00376       rend() const
00377       { return const_reverse_iterator(this->begin()); }
00378 
00379 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00380       /**
00381        *  Returns a read-only (constant) iterator that points to the first
00382        *  character in the %string.
00383        */
00384       const_iterator
00385       cbegin() const
00386       { return const_iterator(this->_M_data()); }
00387 
00388       /**
00389        *  Returns a read-only (constant) iterator that points one past the
00390        *  last character in the %string.
00391        */
00392       const_iterator
00393       cend() const
00394       { return const_iterator(this->_M_data() + this->size()); }
00395 
00396       /**
00397        *  Returns a read-only (constant) reverse iterator that points
00398        *  to the last character in the %string.  Iteration is done in
00399        *  reverse element order.
00400        */
00401       const_reverse_iterator
00402       crbegin() const
00403       { return const_reverse_iterator(this->end()); }
00404 
00405       /**
00406        *  Returns a read-only (constant) reverse iterator that points
00407        *  to one before the first character in the %string.  Iteration
00408        *  is done in reverse element order.
00409        */
00410       const_reverse_iterator
00411       crend() const
00412       { return const_reverse_iterator(this->begin()); }
00413 #endif
00414 
00415     public:
00416       // Capacity:
00417       ///  Returns the number of characters in the string, not including any
00418       ///  null-termination.
00419       size_type
00420       size() const
00421       { return this->_M_length(); }
00422 
00423       ///  Returns the number of characters in the string, not including any
00424       ///  null-termination.
00425       size_type
00426       length() const
00427       { return this->_M_length(); }
00428 
00429       /// Returns the size() of the largest possible %string.
00430       size_type
00431       max_size() const
00432       { return this->_M_max_size(); }
00433 
00434       /**
00435        *  @brief  Resizes the %string to the specified number of characters.
00436        *  @param  __n  Number of characters the %string should contain.
00437        *  @param  __c  Character to fill any new elements.
00438        *
00439        *  This function will %resize the %string to the specified
00440        *  number of characters.  If the number is smaller than the
00441        *  %string's current size the %string is truncated, otherwise
00442        *  the %string is extended and new elements are set to @a __c.
00443        */
00444       void
00445       resize(size_type __n, _CharT __c);
00446 
00447       /**
00448        *  @brief  Resizes the %string to the specified number of characters.
00449        *  @param  __n  Number of characters the %string should contain.
00450        *
00451        *  This function will resize the %string to the specified
00452        *  length.  If the new size is smaller than the %string's
00453        *  current size the %string is truncated, otherwise the %string
00454        *  is extended and new characters are default-constructed.  For
00455        *  basic types such as char, this means setting them to 0.
00456        */
00457       void
00458       resize(size_type __n)
00459       { this->resize(__n, _CharT()); }
00460 
00461 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00462       /// A non-binding request to reduce capacity() to size().
00463       void
00464       shrink_to_fit()
00465       {
00466     __try
00467       { this->reserve(0); }
00468     __catch(...)
00469       { }
00470       }
00471 #endif
00472 
00473       /**
00474        *  Returns the total number of characters that the %string can
00475        *  hold before needing to allocate more memory.
00476        */
00477       size_type
00478       capacity() const
00479       { return this->_M_capacity(); }
00480 
00481       /**
00482        *  @brief  Attempt to preallocate enough memory for specified number of
00483        *          characters.
00484        *  @param  __res_arg  Number of characters required.
00485        *  @throw  std::length_error  If @a __res_arg exceeds @c max_size().
00486        *
00487        *  This function attempts to reserve enough memory for the
00488        *  %string to hold the specified number of characters.  If the
00489        *  number requested is more than max_size(), length_error is
00490        *  thrown.
00491        *
00492        *  The advantage of this function is that if optimal code is a
00493        *  necessity and the user can determine the string length that
00494        *  will be required, the user can reserve the memory in
00495        *  %advance, and thus prevent a possible reallocation of memory
00496        *  and copying of %string data.
00497        */
00498       void
00499       reserve(size_type __res_arg = 0)
00500       { this->_M_reserve(__res_arg); }
00501 
00502       /**
00503        *  Erases the string, making it empty.
00504        */
00505       void
00506       clear()
00507       { this->_M_clear(); }
00508 
00509       /**
00510        *  Returns true if the %string is empty.  Equivalent to 
00511        *  <code>*this == ""</code>.
00512        */
00513       bool
00514       empty() const
00515       { return this->size() == 0; }
00516 
00517       // Element access:
00518       /**
00519        *  @brief  Subscript access to the data contained in the %string.
00520        *  @param  __pos  The index of the character to access.
00521        *  @return  Read-only (constant) reference to the character.
00522        *
00523        *  This operator allows for easy, array-style, data access.
00524        *  Note that data access with this operator is unchecked and
00525        *  out_of_range lookups are not defined. (For checked lookups
00526        *  see at().)
00527        */
00528       const_reference
00529       operator[] (size_type __pos) const
00530       {
00531     _GLIBCXX_DEBUG_ASSERT(__pos <= this->size());
00532     return this->_M_data()[__pos];
00533       }
00534 
00535       /**
00536        *  @brief  Subscript access to the data contained in the %string.
00537        *  @param  __pos  The index of the character to access.
00538        *  @return  Read/write reference to the character.
00539        *
00540        *  This operator allows for easy, array-style, data access.
00541        *  Note that data access with this operator is unchecked and
00542        *  out_of_range lookups are not defined. (For checked lookups
00543        *  see at().)  Unshares the string.
00544        */
00545       reference
00546       operator[](size_type __pos)
00547       {
00548         // allow pos == size() as v3 extension:
00549     _GLIBCXX_DEBUG_ASSERT(__pos <= this->size());
00550         // but be strict in pedantic mode:
00551     _GLIBCXX_DEBUG_PEDASSERT(__pos < this->size());
00552     this->_M_leak();
00553     return this->_M_data()[__pos];
00554       }
00555 
00556       /**
00557        *  @brief  Provides access to the data contained in the %string.
00558        *  @param __n The index of the character to access.
00559        *  @return  Read-only (const) reference to the character.
00560        *  @throw  std::out_of_range  If @a __n is an invalid index.
00561        *
00562        *  This function provides for safer data access.  The parameter
00563        *  is first checked that it is in the range of the string.  The
00564        *  function throws out_of_range if the check fails.
00565        */
00566       const_reference
00567       at(size_type __n) const
00568       {
00569     if (__n >= this->size())
00570       std::__throw_out_of_range(__N("__versa_string::at"));
00571     return this->_M_data()[__n];
00572       }
00573 
00574       /**
00575        *  @brief  Provides access to the data contained in the %string.
00576        *  @param __n The index of the character to access.
00577        *  @return  Read/write reference to the character.
00578        *  @throw  std::out_of_range  If @a __n is an invalid index.
00579        *
00580        *  This function provides for safer data access.  The parameter
00581        *  is first checked that it is in the range of the string.  The
00582        *  function throws out_of_range if the check fails.  Success
00583        *  results in unsharing the string.
00584        */
00585       reference
00586       at(size_type __n)
00587       {
00588     if (__n >= this->size())
00589       std::__throw_out_of_range(__N("__versa_string::at"));
00590     this->_M_leak();
00591     return this->_M_data()[__n];
00592       }
00593 
00594 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00595       /**
00596        *  Returns a read/write reference to the data at the first
00597        *  element of the %string.
00598        */
00599       reference
00600       front()
00601       { return *begin(); }
00602 
00603       /**
00604        *  Returns a read-only (constant) reference to the data at the first
00605        *  element of the %string.
00606        */
00607       const_reference
00608       front() const
00609       { return *begin(); }
00610 
00611       /**
00612        *  Returns a read/write reference to the data at the last
00613        *  element of the %string.
00614        */
00615       reference
00616       back()
00617       { return *(end() - 1); }
00618 
00619       /**
00620        *  Returns a read-only (constant) reference to the data at the
00621        *  last element of the %string.
00622        */
00623       const_reference
00624       back() const
00625       { return *(end() - 1); }
00626 #endif
00627 
00628       // Modifiers:
00629       /**
00630        *  @brief  Append a string to this string.
00631        *  @param __str  The string to append.
00632        *  @return  Reference to this string.
00633        */
00634       __versa_string&
00635       operator+=(const __versa_string& __str)
00636       { return this->append(__str); }
00637 
00638       /**
00639        *  @brief  Append a C string.
00640        *  @param __s  The C string to append.
00641        *  @return  Reference to this string.
00642        */
00643       __versa_string&
00644       operator+=(const _CharT* __s)
00645       { return this->append(__s); }
00646 
00647       /**
00648        *  @brief  Append a character.
00649        *  @param __c  The character to append.
00650        *  @return  Reference to this string.
00651        */
00652       __versa_string&
00653       operator+=(_CharT __c)
00654       { 
00655     this->push_back(__c);
00656     return *this;
00657       }
00658 
00659 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00660       /**
00661        *  @brief  Append an initializer_list of characters.
00662        *  @param __l  The initializer_list of characters to be appended.
00663        *  @return  Reference to this string.
00664        */
00665       __versa_string&
00666       operator+=(std::initializer_list<_CharT> __l)
00667       { return this->append(__l.begin(), __l.end()); }
00668 #endif // __GXX_EXPERIMENTAL_CXX0X__
00669 
00670       /**
00671        *  @brief  Append a string to this string.
00672        *  @param __str  The string to append.
00673        *  @return  Reference to this string.
00674        */
00675       __versa_string&
00676       append(const __versa_string& __str)
00677       { return _M_append(__str._M_data(), __str.size()); }
00678 
00679       /**
00680        *  @brief  Append a substring.
00681        *  @param __str  The string to append.
00682        *  @param __pos  Index of the first character of str to append.
00683        *  @param __n  The number of characters to append.
00684        *  @return  Reference to this string.
00685        *  @throw  std::out_of_range if @a pos is not a valid index.
00686        *
00687        *  This function appends @a __n characters from @a __str
00688        *  starting at @a __pos to this string.  If @a __n is is larger
00689        *  than the number of available characters in @a __str, the
00690        *  remainder of @a __str is appended.
00691        */
00692       __versa_string&
00693       append(const __versa_string& __str, size_type __pos, size_type __n)
00694       { return _M_append(__str._M_data()
00695              + __str._M_check(__pos, "__versa_string::append"),
00696              __str._M_limit(__pos, __n)); }
00697 
00698       /**
00699        *  @brief  Append a C substring.
00700        *  @param __s  The C string to append.
00701        *  @param __n  The number of characters to append.
00702        *  @return  Reference to this string.
00703        */
00704       __versa_string&
00705       append(const _CharT* __s, size_type __n)
00706       {
00707     __glibcxx_requires_string_len(__s, __n);
00708     _M_check_length(size_type(0), __n, "__versa_string::append");
00709     return _M_append(__s, __n);
00710       }
00711 
00712       /**
00713        *  @brief  Append a C string.
00714        *  @param __s  The C string to append.
00715        *  @return  Reference to this string.
00716        */
00717       __versa_string&
00718       append(const _CharT* __s)
00719       {
00720     __glibcxx_requires_string(__s);
00721     const size_type __n = traits_type::length(__s);
00722     _M_check_length(size_type(0), __n, "__versa_string::append");
00723     return _M_append(__s, __n);
00724       }
00725 
00726       /**
00727        *  @brief  Append multiple characters.
00728        *  @param __n  The number of characters to append.
00729        *  @param __c  The character to use.
00730        *  @return  Reference to this string.
00731        *
00732        *  Appends n copies of c to this string.
00733        */
00734       __versa_string&
00735       append(size_type __n, _CharT __c)
00736       { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
00737 
00738 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00739       /**
00740        *  @brief  Append an initializer_list of characters.
00741        *  @param __l  The initializer_list of characters to append.
00742        *  @return  Reference to this string.
00743        */
00744       __versa_string&
00745       append(std::initializer_list<_CharT> __l)
00746       { return this->append(__l.begin(), __l.end()); }
00747 #endif // __GXX_EXPERIMENTAL_CXX0X__
00748 
00749       /**
00750        *  @brief  Append a range of characters.
00751        *  @param __first  Iterator referencing the first character to append.
00752        *  @param __last  Iterator marking the end of the range.
00753        *  @return  Reference to this string.
00754        *
00755        *  Appends characters in the range [first,last) to this string.
00756        */
00757       template<class _InputIterator>
00758         __versa_string&
00759         append(_InputIterator __first, _InputIterator __last)
00760         { return this->replace(_M_iend(), _M_iend(), __first, __last); }
00761 
00762       /**
00763        *  @brief  Append a single character.
00764        *  @param __c  Character to append.
00765        */
00766       void
00767       push_back(_CharT __c)
00768       { 
00769     const size_type __size = this->size();
00770     if (__size + 1 > this->capacity() || this->_M_is_shared())
00771       this->_M_mutate(__size, size_type(0), 0, size_type(1));
00772     traits_type::assign(this->_M_data()[__size], __c);
00773     this->_M_set_length(__size + 1);
00774       }
00775 
00776       /**
00777        *  @brief  Set value to contents of another string.
00778        *  @param  __str  Source string to use.
00779        *  @return  Reference to this string.
00780        */
00781       __versa_string&
00782       assign(const __versa_string& __str)
00783       {
00784     this->_M_assign(__str);
00785     return *this;
00786       }
00787 
00788 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00789       /**
00790        *  @brief  Set value to contents of another string.
00791        *  @param  __str  Source string to use.
00792        *  @return  Reference to this string.
00793        *
00794        *  This function sets this string to the exact contents of @a __str.
00795        *  @a __str is a valid, but unspecified string.
00796        */
00797       __versa_string&
00798       assign(__versa_string&& __str)
00799       {
00800     this->swap(__str);
00801     return *this;
00802       }
00803 #endif // __GXX_EXPERIMENTAL_CXX0X__
00804 
00805       /**
00806        *  @brief  Set value to a substring of a string.
00807        *  @param __str  The string to use.
00808        *  @param __pos  Index of the first character of str.
00809        *  @param __n  Number of characters to use.
00810        *  @return  Reference to this string.
00811        *  @throw  std::out_of_range if @a __pos is not a valid index.
00812        *
00813        *  This function sets this string to the substring of @a __str
00814        *  consisting of @a __n characters at @a __pos.  If @a __n is
00815        *  is larger than the number of available characters in @a
00816        *  __str, the remainder of @a __str is used.
00817        */
00818       __versa_string&
00819       assign(const __versa_string& __str, size_type __pos, size_type __n)
00820       { return _M_replace(size_type(0), this->size(), __str._M_data()
00821               + __str._M_check(__pos, "__versa_string::assign"),
00822               __str._M_limit(__pos, __n)); }
00823 
00824       /**
00825        *  @brief  Set value to a C substring.
00826        *  @param __s  The C string to use.
00827        *  @param __n  Number of characters to use.
00828        *  @return  Reference to this string.
00829        *
00830        *  This function sets the value of this string to the first @a
00831        *  __n characters of @a __s.  If @a __n is is larger than the
00832        *  number of available characters in @a __s, the remainder of
00833        *  @a __s is used.
00834        */
00835       __versa_string&
00836       assign(const _CharT* __s, size_type __n)
00837       {
00838     __glibcxx_requires_string_len(__s, __n);
00839     return _M_replace(size_type(0), this->size(), __s, __n);
00840       }
00841 
00842       /**
00843        *  @brief  Set value to contents of a C string.
00844        *  @param __s  The C string to use.
00845        *  @return  Reference to this string.
00846        *
00847        *  This function sets the value of this string to the value of
00848        *  @a __s.  The data is copied, so there is no dependence on @a
00849        *  __s once the function returns.
00850        */
00851       __versa_string&
00852       assign(const _CharT* __s)
00853       {
00854     __glibcxx_requires_string(__s);
00855     return _M_replace(size_type(0), this->size(), __s,
00856               traits_type::length(__s));
00857       }
00858 
00859       /**
00860        *  @brief  Set value to multiple characters.
00861        *  @param __n  Length of the resulting string.
00862        *  @param __c  The character to use.
00863        *  @return  Reference to this string.
00864        *
00865        *  This function sets the value of this string to @a __n copies of
00866        *  character @a __c.
00867        */
00868       __versa_string&
00869       assign(size_type __n, _CharT __c)
00870       { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
00871 
00872       /**
00873        *  @brief  Set value to a range of characters.
00874        *  @param __first  Iterator referencing the first character to append.
00875        *  @param __last  Iterator marking the end of the range.
00876        *  @return  Reference to this string.
00877        *
00878        *  Sets value of string to characters in the range
00879        *  [first,last).
00880       */
00881       template<class _InputIterator>
00882         __versa_string&
00883         assign(_InputIterator __first, _InputIterator __last)
00884         { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
00885 
00886 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00887       /**
00888        *  @brief  Set value to an initializer_list of characters.
00889        *  @param __l  The initializer_list of characters to assign.
00890        *  @return  Reference to this string.
00891        */
00892       __versa_string&
00893       assign(std::initializer_list<_CharT> __l)
00894       { return this->assign(__l.begin(), __l.end()); }
00895 #endif // __GXX_EXPERIMENTAL_CXX0X__
00896 
00897       /**
00898        *  @brief  Insert multiple characters.
00899        *  @param __p  Iterator referencing location in string to insert at.
00900        *  @param __n  Number of characters to insert
00901        *  @param __c  The character to insert.
00902        *  @throw  std::length_error  If new length exceeds @c max_size().
00903        *
00904        *  Inserts @a __n copies of character @a __c starting at the
00905        *  position referenced by iterator @a __p.  If adding
00906        *  characters causes the length to exceed max_size(),
00907        *  length_error is thrown.  The value of the string doesn't
00908        *  change if an error is thrown.
00909       */
00910       void
00911       insert(iterator __p, size_type __n, _CharT __c)
00912       { this->replace(__p, __p, __n, __c);  }
00913 
00914       /**
00915        *  @brief  Insert a range of characters.
00916        *  @param __p  Iterator referencing location in string to insert at.
00917        *  @param __beg  Start of range.
00918        *  @param __end  End of range.
00919        *  @throw  std::length_error  If new length exceeds @c max_size().
00920        *
00921        *  Inserts characters in range [beg,end).  If adding characters
00922        *  causes the length to exceed max_size(), length_error is
00923        *  thrown.  The value of the string doesn't change if an error
00924        *  is thrown.
00925       */
00926       template<class _InputIterator>
00927         void
00928         insert(iterator __p, _InputIterator __beg, _InputIterator __end)
00929         { this->replace(__p, __p, __beg, __end); }
00930 
00931 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00932       /**
00933        *  @brief  Insert an initializer_list of characters.
00934        *  @param __p  Iterator referencing location in string to insert at.
00935        *  @param __l  The initializer_list of characters to insert.
00936        *  @throw  std::length_error  If new length exceeds @c max_size().
00937        */
00938       void
00939       insert(iterator __p, std::initializer_list<_CharT> __l)
00940       { this->insert(__p, __l.begin(), __l.end()); }
00941 #endif // __GXX_EXPERIMENTAL_CXX0X__
00942 
00943       /**
00944        *  @brief  Insert value of a string.
00945        *  @param __pos1  Iterator referencing location in string to insert at.
00946        *  @param __str  The string to insert.
00947        *  @return  Reference to this string.
00948        *  @throw  std::length_error  If new length exceeds @c max_size().
00949        *
00950        *  Inserts value of @a __str starting at @a __pos1.  If adding
00951        *  characters causes the length to exceed max_size(),
00952        *  length_error is thrown.  The value of the string doesn't
00953        *  change if an error is thrown.
00954       */
00955       __versa_string&
00956       insert(size_type __pos1, const __versa_string& __str)
00957       { return this->replace(__pos1, size_type(0),
00958                  __str._M_data(), __str.size()); }
00959 
00960       /**
00961        *  @brief  Insert a substring.
00962        *  @param __pos1  Iterator referencing location in string to insert at.
00963        *  @param __str  The string to insert.
00964        *  @param __pos2  Start of characters in str to insert.
00965        *  @param __n  Number of characters to insert.
00966        *  @return  Reference to this string.
00967        *  @throw  std::length_error  If new length exceeds @c max_size().
00968        *  @throw  std::out_of_range  If @a __pos1 > size() or
00969        *  @a __pos2 > @a __str.size().
00970        *
00971        *  Starting at @a __pos1, insert @a __n character of @a __str
00972        *  beginning with @a __pos2.  If adding characters causes the
00973        *  length to exceed max_size(), length_error is thrown.  If @a
00974        *  __pos1 is beyond the end of this string or @a __pos2 is
00975        *  beyond the end of @a __str, out_of_range is thrown.  The
00976        *  value of the string doesn't change if an error is thrown.
00977       */
00978       __versa_string&
00979       insert(size_type __pos1, const __versa_string& __str,
00980          size_type __pos2, size_type __n)
00981       { return this->replace(__pos1, size_type(0), __str._M_data()
00982                  + __str._M_check(__pos2, "__versa_string::insert"),
00983                  __str._M_limit(__pos2, __n)); }
00984 
00985       /**
00986        *  @brief  Insert a C substring.
00987        *  @param __pos  Iterator referencing location in string to insert at.
00988        *  @param __s  The C string to insert.
00989        *  @param __n  The number of characters to insert.
00990        *  @return  Reference to this string.
00991        *  @throw  std::length_error  If new length exceeds @c max_size().
00992        *  @throw  std::out_of_range  If @a __pos is beyond the end of this
00993        *  string.
00994        *
00995        *  Inserts the first @a __n characters of @a __s starting at @a
00996        *  __pos.  If adding characters causes the length to exceed
00997        *  max_size(), length_error is thrown.  If @a __pos is beyond
00998        *  end(), out_of_range is thrown.  The value of the string
00999        *  doesn't change if an error is thrown.
01000       */
01001       __versa_string&
01002       insert(size_type __pos, const _CharT* __s, size_type __n)
01003       { return this->replace(__pos, size_type(0), __s, __n); }
01004 
01005       /**
01006        *  @brief  Insert a C string.
01007        *  @param __pos  Iterator referencing location in string to insert at.
01008        *  @param __s  The C string to insert.
01009        *  @return  Reference to this string.
01010        *  @throw  std::length_error  If new length exceeds @c max_size().
01011        *  @throw  std::out_of_range  If @a __pos is beyond the end of this
01012        *  string.
01013        *
01014        *  Inserts the first @a __n characters of @a __s starting at @a
01015        *  __pos.  If adding characters causes the length to exceed
01016        *  max_size(), length_error is thrown.  If @a __pos is beyond
01017        *  end(), out_of_range is thrown.  The value of the string
01018        *  doesn't change if an error is thrown.
01019       */
01020       __versa_string&
01021       insert(size_type __pos, const _CharT* __s)
01022       {
01023     __glibcxx_requires_string(__s);
01024     return this->replace(__pos, size_type(0), __s,
01025                  traits_type::length(__s));
01026       }
01027 
01028       /**
01029        *  @brief  Insert multiple characters.
01030        *  @param __pos  Index in string to insert at.
01031        *  @param __n  Number of characters to insert
01032        *  @param __c  The character to insert.
01033        *  @return  Reference to this string.
01034        *  @throw  std::length_error  If new length exceeds @c max_size().
01035        *  @throw  std::out_of_range  If @a __pos is beyond the end of this
01036        *  string.
01037        *
01038        *  Inserts @a __n copies of character @a __c starting at index
01039        *  @a __pos.  If adding characters causes the length to exceed
01040        *  max_size(), length_error is thrown.  If @a __pos > length(),
01041        *  out_of_range is thrown.  The value of the string doesn't
01042        *  change if an error is thrown.
01043       */
01044       __versa_string&
01045       insert(size_type __pos, size_type __n, _CharT __c)
01046       { return _M_replace_aux(_M_check(__pos, "__versa_string::insert"),
01047                   size_type(0), __n, __c); }
01048 
01049       /**
01050        *  @brief  Insert one character.
01051        *  @param __p  Iterator referencing position in string to insert at.
01052        *  @param __c  The character to insert.
01053        *  @return  Iterator referencing newly inserted char.
01054        *  @throw  std::length_error  If new length exceeds @c max_size().
01055        *
01056        *  Inserts character @a __c at position referenced by @a __p.
01057        *  If adding character causes the length to exceed max_size(),
01058        *  length_error is thrown.  If @a __p is beyond end of string,
01059        *  out_of_range is thrown.  The value of the string doesn't
01060        *  change if an error is thrown.
01061       */
01062       iterator
01063       insert(iterator __p, _CharT __c)
01064       {
01065     _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
01066     const size_type __pos = __p - _M_ibegin();
01067     _M_replace_aux(__pos, size_type(0), size_type(1), __c);
01068     this->_M_set_leaked();
01069     return iterator(this->_M_data() + __pos);
01070       }
01071 
01072       /**
01073        *  @brief  Remove characters.
01074        *  @param __pos  Index of first character to remove (default 0).
01075        *  @param __n  Number of characters to remove (default remainder).
01076        *  @return  Reference to this string.
01077        *  @throw  std::out_of_range  If @a __pos is beyond the end of this
01078        *  string.
01079        *
01080        *  Removes @a __n characters from this string starting at @a
01081        *  __pos.  The length of the string is reduced by @a __n.  If
01082        *  there are < @a __n characters to remove, the remainder of
01083        *  the string is truncated.  If @a __p is beyond end of string,
01084        *  out_of_range is thrown.  The value of the string doesn't
01085        *  change if an error is thrown.
01086       */
01087       __versa_string&
01088       erase(size_type __pos = 0, size_type __n = npos)
01089       { 
01090     this->_M_erase(_M_check(__pos, "__versa_string::erase"),
01091                _M_limit(__pos, __n));
01092     return *this;
01093       }
01094 
01095       /**
01096        *  @brief  Remove one character.
01097        *  @param __position  Iterator referencing the character to remove.
01098        *  @return  iterator referencing same location after removal.
01099        *
01100        *  Removes the character at @a __position from this string. The
01101        *  value of the string doesn't change if an error is thrown.
01102       */
01103       iterator
01104       erase(iterator __position)
01105       {
01106     _GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin()
01107                  && __position < _M_iend());
01108     const size_type __pos = __position - _M_ibegin();
01109     this->_M_erase(__pos, size_type(1));
01110     this->_M_set_leaked();
01111     return iterator(this->_M_data() + __pos);
01112       }
01113 
01114       /**
01115        *  @brief  Remove a range of characters.
01116        *  @param __first  Iterator referencing the first character to remove.
01117        *  @param __last  Iterator referencing the end of the range.
01118        *  @return  Iterator referencing location of first after removal.
01119        *
01120        *  Removes the characters in the range [first,last) from this
01121        *  string.  The value of the string doesn't change if an error
01122        *  is thrown.
01123       */
01124       iterator
01125       erase(iterator __first, iterator __last)
01126       {
01127     _GLIBCXX_DEBUG_PEDASSERT(__first >= _M_ibegin() && __first <= __last
01128                  && __last <= _M_iend());
01129         const size_type __pos = __first - _M_ibegin();
01130     this->_M_erase(__pos, __last - __first);
01131     this->_M_set_leaked();
01132     return iterator(this->_M_data() + __pos);
01133       }
01134 
01135       /**
01136        *  @brief  Replace characters with value from another string.
01137        *  @param __pos  Index of first character to replace.
01138        *  @param __n  Number of characters to be replaced.
01139        *  @param __str  String to insert.
01140        *  @return  Reference to this string.
01141        *  @throw  std::out_of_range  If @a __pos is beyond the end of this
01142        *  string.
01143        *  @throw  std::length_error  If new length exceeds @c max_size().
01144        *
01145        *  Removes the characters in the range [pos,pos+n) from this
01146        *  string.  In place, the value of @a __str is inserted.  If @a
01147        *  __pos is beyond end of string, out_of_range is thrown.  If
01148        *  the length of the result exceeds max_size(), length_error is
01149        *  thrown.  The value of the string doesn't change if an error
01150        *  is thrown.
01151       */
01152       __versa_string&
01153       replace(size_type __pos, size_type __n, const __versa_string& __str)
01154       { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
01155 
01156       /**
01157        *  @brief  Replace characters with value from another string.
01158        *  @param __pos1  Index of first character to replace.
01159        *  @param __n1  Number of characters to be replaced.
01160        *  @param __str  String to insert.
01161        *  @param __pos2  Index of first character of str to use.
01162        *  @param __n2  Number of characters from str to use.
01163        *  @return  Reference to this string.
01164        *  @throw  std::out_of_range  If @a __pos1 > size() or @a __pos2 >
01165        *  str.size().
01166        *  @throw  std::length_error  If new length exceeds @c max_size().
01167        *
01168        *  Removes the characters in the range [pos1,pos1 + n) from
01169        *  this string.  In place, the value of @a __str is inserted.
01170        *  If @a __pos is beyond end of string, out_of_range is thrown.
01171        *  If the length of the result exceeds max_size(), length_error
01172        *  is thrown.  The value of the string doesn't change if an
01173        *  error is thrown.
01174       */
01175       __versa_string&
01176       replace(size_type __pos1, size_type __n1, const __versa_string& __str,
01177           size_type __pos2, size_type __n2)
01178       {
01179     return this->replace(__pos1, __n1, __str._M_data()
01180                  + __str._M_check(__pos2,
01181                           "__versa_string::replace"),
01182                  __str._M_limit(__pos2, __n2));
01183       }
01184 
01185       /**
01186        *  @brief  Replace characters with value of a C substring.
01187        *  @param __pos  Index of first character to replace.
01188        *  @param __n1  Number of characters to be replaced.
01189        *  @param __s  C string to insert.
01190        *  @param __n2  Number of characters from @a __s to use.
01191        *  @return  Reference to this string.
01192        *  @throw  std::out_of_range  If @a __pos1 > size().
01193        *  @throw  std::length_error  If new length exceeds @c max_size().
01194        *
01195        *  Removes the characters in the range [pos,pos + n1) from this
01196        *  string.  In place, the first @a __n2 characters of @a __s
01197        *  are inserted, or all of @a __s if @a __n2 is too large.  If
01198        *  @a __pos is beyond end of string, out_of_range is thrown.
01199        *  If the length of result exceeds max_size(), length_error is
01200        *  thrown.  The value of the string doesn't change if an error
01201        *  is thrown.
01202       */
01203       __versa_string&
01204       replace(size_type __pos, size_type __n1, const _CharT* __s,
01205           size_type __n2)
01206       {
01207     __glibcxx_requires_string_len(__s, __n2);
01208     return _M_replace(_M_check(__pos, "__versa_string::replace"),
01209               _M_limit(__pos, __n1), __s, __n2);
01210       }
01211 
01212       /**
01213        *  @brief  Replace characters with value of a C string.
01214        *  @param __pos  Index of first character to replace.
01215        *  @param __n1  Number of characters to be replaced.
01216        *  @param __s  C string to insert.
01217        *  @return  Reference to this string.
01218        *  @throw  std::out_of_range  If @a __pos > size().
01219        *  @throw  std::length_error  If new length exceeds @c max_size().
01220        *
01221        *  Removes the characters in the range [pos,pos + n1) from this
01222        *  string.  In place, the first @a __n characters of @a __s are
01223        *  inserted.  If @a pos is beyond end of string, out_of_range
01224        *  is thrown.  If the length of result exceeds max_size(),
01225        *  length_error is thrown.  The value of the string doesn't
01226        *  change if an error is thrown.
01227       */
01228       __versa_string&
01229       replace(size_type __pos, size_type __n1, const _CharT* __s)
01230       {
01231     __glibcxx_requires_string(__s);
01232     return this->replace(__pos, __n1, __s, traits_type::length(__s));
01233       }
01234 
01235       /**
01236        *  @brief  Replace characters with multiple characters.
01237        *  @param __pos  Index of first character to replace.
01238        *  @param __n1  Number of characters to be replaced.
01239        *  @param __n2  Number of characters to insert.
01240        *  @param __c  Character to insert.
01241        *  @return  Reference to this string.
01242        *  @throw  std::out_of_range  If @a __pos > size().
01243        *  @throw  std::length_error  If new length exceeds @c max_size().
01244        *
01245        *  Removes the characters in the range [pos,pos + n1) from this
01246        *  string.  In place, @a __n2 copies of @a __c are inserted.
01247        *  If @a __pos is beyond end of string, out_of_range is thrown.
01248        *  If the length of result exceeds max_size(), length_error is
01249        *  thrown.  The value of the string doesn't change if an error
01250        *  is thrown.
01251       */
01252       __versa_string&
01253       replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
01254       { return _M_replace_aux(_M_check(__pos, "__versa_string::replace"),
01255                   _M_limit(__pos, __n1), __n2, __c); }
01256 
01257       /**
01258        *  @brief  Replace range of characters with string.
01259        *  @param __i1  Iterator referencing start of range to replace.
01260        *  @param __i2  Iterator referencing end of range to replace.
01261        *  @param __str  String value to insert.
01262        *  @return  Reference to this string.
01263        *  @throw  std::length_error  If new length exceeds @c max_size().
01264        *
01265        *  Removes the characters in the range [i1,i2).  In place, the
01266        *  value of @a __str is inserted.  If the length of result
01267        *  exceeds max_size(), length_error is thrown.  The value of
01268        *  the string doesn't change if an error is thrown.
01269       */
01270       __versa_string&
01271       replace(iterator __i1, iterator __i2, const __versa_string& __str)
01272       { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
01273 
01274       /**
01275        *  @brief  Replace range of characters with C substring.
01276        *  @param __i1  Iterator referencing start of range to replace.
01277        *  @param __i2  Iterator referencing end of range to replace.
01278        *  @param __s  C string value to insert.
01279        *  @param __n  Number of characters from s to insert.
01280        *  @return  Reference to this string.
01281        *  @throw  std::length_error  If new length exceeds @c max_size().
01282        *
01283        *  Removes the characters in the range [i1,i2).  In place, the
01284        *  first @a n characters of @a __s are inserted.  If the length
01285        *  of result exceeds max_size(), length_error is thrown.  The
01286        *  value of the string doesn't change if an error is thrown.
01287       */
01288       __versa_string&
01289       replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
01290       {
01291     _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01292                  && __i2 <= _M_iend());
01293     return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
01294       }
01295 
01296       /**
01297        *  @brief  Replace range of characters with C string.
01298        *  @param __i1  Iterator referencing start of range to replace.
01299        *  @param __i2  Iterator referencing end of range to replace.
01300        *  @param __s  C string value to insert.
01301        *  @return  Reference to this string.
01302        *  @throw  std::length_error  If new length exceeds @c max_size().
01303        *
01304        *  Removes the characters in the range [i1,i2).  In place, the
01305        *  characters of @a __s are inserted.  If the length of result
01306        *  exceeds max_size(), length_error is thrown.  The value of
01307        *  the string doesn't change if an error is thrown.
01308       */
01309       __versa_string&
01310       replace(iterator __i1, iterator __i2, const _CharT* __s)
01311       {
01312     __glibcxx_requires_string(__s);
01313     return this->replace(__i1, __i2, __s, traits_type::length(__s));
01314       }
01315 
01316       /**
01317        *  @brief  Replace range of characters with multiple characters
01318        *  @param __i1  Iterator referencing start of range to replace.
01319        *  @param __i2  Iterator referencing end of range to replace.
01320        *  @param __n  Number of characters to insert.
01321        *  @param __c  Character to insert.
01322        *  @return  Reference to this string.
01323        *  @throw  std::length_error  If new length exceeds @c max_size().
01324        *
01325        *  Removes the characters in the range [i1,i2).  In place, @a
01326        *  __n copies of @a __c are inserted.  If the length of result
01327        *  exceeds max_size(), length_error is thrown.  The value of
01328        *  the string doesn't change if an error is thrown.
01329       */
01330       __versa_string&
01331       replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
01332       {
01333     _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01334                  && __i2 <= _M_iend());
01335     return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
01336       }
01337 
01338       /**
01339        *  @brief  Replace range of characters with range.
01340        *  @param __i1  Iterator referencing start of range to replace.
01341        *  @param __i2  Iterator referencing end of range to replace.
01342        *  @param __k1  Iterator referencing start of range to insert.
01343        *  @param __k2  Iterator referencing end of range to insert.
01344        *  @return  Reference to this string.
01345        *  @throw  std::length_error  If new length exceeds @c max_size().
01346        *
01347        *  Removes the characters in the range [i1,i2).  In place,
01348        *  characters in the range [k1,k2) are inserted.  If the length
01349        *  of result exceeds max_size(), length_error is thrown.  The
01350        *  value of the string doesn't change if an error is thrown.
01351       */
01352       template<class _InputIterator>
01353         __versa_string&
01354         replace(iterator __i1, iterator __i2,
01355         _InputIterator __k1, _InputIterator __k2)
01356         {
01357       _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01358                    && __i2 <= _M_iend());
01359       __glibcxx_requires_valid_range(__k1, __k2);
01360       typedef typename std::__is_integer<_InputIterator>::__type _Integral;
01361       return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
01362     }
01363 
01364       // Specializations for the common case of pointer and iterator:
01365       // useful to avoid the overhead of temporary buffering in _M_replace.
01366       __versa_string&
01367       replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
01368       {
01369     _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01370                  && __i2 <= _M_iend());
01371     __glibcxx_requires_valid_range(__k1, __k2);
01372     return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
01373                  __k1, __k2 - __k1);
01374       }
01375 
01376       __versa_string&
01377       replace(iterator __i1, iterator __i2,
01378           const _CharT* __k1, const _CharT* __k2)
01379       {
01380     _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01381                  && __i2 <= _M_iend());
01382     __glibcxx_requires_valid_range(__k1, __k2);
01383     return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
01384                  __k1, __k2 - __k1);
01385       }
01386 
01387       __versa_string&
01388       replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
01389       {
01390     _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01391                  && __i2 <= _M_iend());
01392     __glibcxx_requires_valid_range(__k1, __k2);
01393     return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
01394                  __k1.base(), __k2 - __k1);
01395       }
01396 
01397       __versa_string&
01398       replace(iterator __i1, iterator __i2,
01399           const_iterator __k1, const_iterator __k2)
01400       {
01401     _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01402                  && __i2 <= _M_iend());
01403     __glibcxx_requires_valid_range(__k1, __k2);
01404     return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
01405                  __k1.base(), __k2 - __k1);
01406       }
01407       
01408 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01409       /**
01410        *  @brief  Replace range of characters with initializer_list.
01411        *  @param __i1  Iterator referencing start of range to replace.
01412        *  @param __i2  Iterator referencing end of range to replace.
01413        *  @param __l  The initializer_list of characters to insert.
01414        *  @return  Reference to this string.
01415        *  @throw  std::length_error  If new length exceeds @c max_size().
01416        *
01417        *  Removes the characters in the range [i1,i2).  In place,
01418        *  characters in the range [k1,k2) are inserted.  If the length
01419        *  of result exceeds max_size(), length_error is thrown.  The
01420        *  value of the string doesn't change if an error is thrown.
01421       */
01422       __versa_string& replace(iterator __i1, iterator __i2,
01423                   std::initializer_list<_CharT> __l)
01424       { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
01425 #endif // __GXX_EXPERIMENTAL_CXX0X__
01426 
01427     private:
01428       template<class _Integer>
01429     __versa_string&
01430     _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
01431                 _Integer __val, std::__true_type)
01432         { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
01433 
01434       template<class _InputIterator>
01435     __versa_string&
01436     _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
01437                 _InputIterator __k2, std::__false_type);
01438 
01439       __versa_string&
01440       _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
01441              _CharT __c);
01442 
01443       __versa_string&
01444       _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
01445          const size_type __len2);
01446 
01447       __versa_string&
01448       _M_append(const _CharT* __s, size_type __n);
01449 
01450     public:
01451 
01452       /**
01453        *  @brief  Copy substring into C string.
01454        *  @param __s  C string to copy value into.
01455        *  @param __n  Number of characters to copy.
01456        *  @param __pos  Index of first character to copy.
01457        *  @return  Number of characters actually copied
01458        *  @throw  std::out_of_range  If pos > size().
01459        *
01460        *  Copies up to @a __n characters starting at @a __pos into the
01461        *  C string @a s.  If @a __pos is greater than size(),
01462        *  out_of_range is thrown.
01463       */
01464       size_type
01465       copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
01466 
01467       /**
01468        *  @brief  Swap contents with another string.
01469        *  @param __s  String to swap with.
01470        *
01471        *  Exchanges the contents of this string with that of @a __s in
01472        *  constant time.
01473       */
01474       void
01475       swap(__versa_string& __s)
01476       { this->_M_swap(__s); }
01477 
01478       // String operations:
01479       /**
01480        *  @brief  Return const pointer to null-terminated contents.
01481        *
01482        *  This is a handle to internal data.  Do not modify or dire things may
01483        *  happen.
01484       */
01485       const _CharT*
01486       c_str() const
01487       { return this->_M_data(); }
01488 
01489       /**
01490        *  @brief  Return const pointer to contents.
01491        *
01492        *  This is a handle to internal data.  Do not modify or dire things may
01493        *  happen.
01494       */
01495       const _CharT*
01496       data() const
01497       { return this->_M_data(); }
01498 
01499       /**
01500        *  @brief  Return copy of allocator used to construct this string.
01501       */
01502       allocator_type
01503       get_allocator() const
01504       { return allocator_type(this->_M_get_allocator()); }
01505 
01506       /**
01507        *  @brief  Find position of a C substring.
01508        *  @param __s  C string to locate.
01509        *  @param __pos  Index of character to search from.
01510        *  @param __n  Number of characters from @a __s to search for.
01511        *  @return  Index of start of first occurrence.
01512        *
01513        *  Starting from @a __pos, searches forward for the first @a
01514        *  __n characters in @a __s within this string.  If found,
01515        *  returns the index where it begins.  If not found, returns
01516        *  npos.
01517       */
01518       size_type
01519       find(const _CharT* __s, size_type __pos, size_type __n) const;
01520 
01521       /**
01522        *  @brief  Find position of a string.
01523        *  @param __str  String to locate.
01524        *  @param __pos  Index of character to search from (default 0).
01525        *  @return  Index of start of first occurrence.
01526        *
01527        *  Starting from @a __pos, searches forward for value of @a
01528        *  __str within this string.  If found, returns the index where
01529        *  it begins.  If not found, returns npos.
01530       */
01531       size_type
01532       find(const __versa_string& __str, size_type __pos = 0) const
01533       { return this->find(__str.data(), __pos, __str.size()); }
01534 
01535       /**
01536        *  @brief  Find position of a C string.
01537        *  @param __s  C string to locate.
01538        *  @param __pos  Index of character to search from (default 0).
01539        *  @return  Index of start of first occurrence.
01540        *
01541        *  Starting from @a __pos, searches forward for the value of @a
01542        *  __s within this string.  If found, returns the index where
01543        *  it begins.  If not found, returns npos.
01544       */
01545       size_type
01546       find(const _CharT* __s, size_type __pos = 0) const
01547       {
01548     __glibcxx_requires_string(__s);
01549     return this->find(__s, __pos, traits_type::length(__s));
01550       }
01551 
01552       /**
01553        *  @brief  Find position of a character.
01554        *  @param __c  Character to locate.
01555        *  @param __pos  Index of character to search from (default 0).
01556        *  @return  Index of first occurrence.
01557        *
01558        *  Starting from @a __pos, searches forward for @a __c within
01559        *  this string.  If found, returns the index where it was
01560        *  found.  If not found, returns npos.
01561       */
01562       size_type
01563       find(_CharT __c, size_type __pos = 0) const;
01564 
01565       /**
01566        *  @brief  Find last position of a string.
01567        *  @param __str  String to locate.
01568        *  @param __pos  Index of character to search back from (default end).
01569        *  @return  Index of start of last occurrence.
01570        *
01571        *  Starting from @a __pos, searches backward for value of @a
01572        *  __str within this string.  If found, returns the index where
01573        *  it begins.  If not found, returns npos.
01574       */
01575       size_type
01576       rfind(const __versa_string& __str, size_type __pos = npos) const
01577       { return this->rfind(__str.data(), __pos, __str.size()); }
01578 
01579       /**
01580        *  @brief  Find last position of a C substring.
01581        *  @param __s  C string to locate.
01582        *  @param __pos  Index of character to search back from.
01583        *  @param __n  Number of characters from s to search for.
01584        *  @return  Index of start of last occurrence.
01585        *
01586        *  Starting from @a __pos, searches backward for the first @a
01587        *  __n characters in @a __s within this string.  If found,
01588        *  returns the index where it begins.  If not found, returns
01589        *  npos.
01590       */
01591       size_type
01592       rfind(const _CharT* __s, size_type __pos, size_type __n) const;
01593 
01594       /**
01595        *  @brief  Find last position of a C string.
01596        *  @param __s  C string to locate.
01597        *  @param __pos  Index of character to start search at (default end).
01598        *  @return  Index of start of  last occurrence.
01599        *
01600        *  Starting from @a __pos, searches backward for the value of
01601        *  @a __s within this string.  If found, returns the index
01602        *  where it begins.  If not found, returns npos.
01603       */
01604       size_type
01605       rfind(const _CharT* __s, size_type __pos = npos) const
01606       {
01607     __glibcxx_requires_string(__s);
01608     return this->rfind(__s, __pos, traits_type::length(__s));
01609       }
01610 
01611       /**
01612        *  @brief  Find last position of a character.
01613        *  @param __c  Character to locate.
01614        *  @param __pos  Index of character to search back from (default end).
01615        *  @return  Index of last occurrence.
01616        *
01617        *  Starting from @a __pos, searches backward for @a __c within
01618        *  this string.  If found, returns the index where it was
01619        *  found.  If not found, returns npos.
01620       */
01621       size_type
01622       rfind(_CharT __c, size_type __pos = npos) const;
01623 
01624       /**
01625        *  @brief  Find position of a character of string.
01626        *  @param __str  String containing characters to locate.
01627        *  @param __pos  Index of character to search from (default 0).
01628        *  @return  Index of first occurrence.
01629        *
01630        *  Starting from @a __pos, searches forward for one of the characters of
01631        *  @a __str within this string.  If found, returns the index where it was
01632        *  found.  If not found, returns npos.
01633       */
01634       size_type
01635       find_first_of(const __versa_string& __str, size_type __pos = 0) const
01636       { return this->find_first_of(__str.data(), __pos, __str.size()); }
01637 
01638       /**
01639        *  @brief  Find position of a character of C substring.
01640        *  @param __s  String containing characters to locate.
01641        *  @param __pos  Index of character to search from.
01642        *  @param __n  Number of characters from s to search for.
01643        *  @return  Index of first occurrence.
01644        *
01645        *  Starting from @a __pos, searches forward for one of the
01646        *  first @a __n characters of @a __s within this string.  If
01647        *  found, returns the index where it was found.  If not found,
01648        *  returns npos.
01649       */
01650       size_type
01651       find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
01652 
01653       /**
01654        *  @brief  Find position of a character of C string.
01655        *  @param __s  String containing characters to locate.
01656        *  @param __pos  Index of character to search from (default 0).
01657        *  @return  Index of first occurrence.
01658        *
01659        *  Starting from @a __pos, searches forward for one of the
01660        *  characters of @a __s within this string.  If found, returns
01661        *  the index where it was found.  If not found, returns npos.
01662       */
01663       size_type
01664       find_first_of(const _CharT* __s, size_type __pos = 0) const
01665       {
01666     __glibcxx_requires_string(__s);
01667     return this->find_first_of(__s, __pos, traits_type::length(__s));
01668       }
01669 
01670       /**
01671        *  @brief  Find position of a character.
01672        *  @param __c  Character to locate.
01673        *  @param __pos  Index of character to search from (default 0).
01674        *  @return  Index of first occurrence.
01675        *
01676        *  Starting from @a __pos, searches forward for the character
01677        *  @a __c within this string.  If found, returns the index
01678        *  where it was found.  If not found, returns npos.
01679        *
01680        *  Note: equivalent to find(c, pos).
01681       */
01682       size_type
01683       find_first_of(_CharT __c, size_type __pos = 0) const
01684       { return this->find(__c, __pos); }
01685 
01686       /**
01687        *  @brief  Find last position of a character of string.
01688        *  @param __str  String containing characters to locate.
01689        *  @param __pos  Index of character to search back from (default end).
01690        *  @return  Index of last occurrence.
01691        *
01692        *  Starting from @a __pos, searches backward for one of the
01693        *  characters of @a __str within this string.  If found,
01694        *  returns the index where it was found.  If not found, returns
01695        *  npos.
01696       */
01697       size_type
01698       find_last_of(const __versa_string& __str, size_type __pos = npos) const
01699       { return this->find_last_of(__str.data(), __pos, __str.size()); }
01700 
01701       /**
01702        *  @brief  Find last position of a character of C substring.
01703        *  @param __s  C string containing characters to locate.
01704        *  @param __pos  Index of character to search back from.
01705        *  @param __n  Number of characters from s to search for.
01706        *  @return  Index of last occurrence.
01707        *
01708        *  Starting from @a __pos, searches backward for one of the
01709        *  first @a __n characters of @a __s within this string.  If
01710        *  found, returns the index where it was found.  If not found,
01711        *  returns npos.
01712       */
01713       size_type
01714       find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
01715 
01716       /**
01717        *  @brief  Find last position of a character of C string.
01718        *  @param __s  C string containing characters to locate.
01719        *  @param __pos  Index of character to search back from (default end).
01720        *  @return  Index of last occurrence.
01721        *
01722        *  Starting from @a __pos, searches backward for one of the
01723        *  characters of @a __s within this string.  If found, returns
01724        *  the index where it was found.  If not found, returns npos.
01725       */
01726       size_type
01727       find_last_of(const _CharT* __s, size_type __pos = npos) const
01728       {
01729     __glibcxx_requires_string(__s);
01730     return this->find_last_of(__s, __pos, traits_type::length(__s));
01731       }
01732 
01733       /**
01734        *  @brief  Find last position of a character.
01735        *  @param __c  Character to locate.
01736        *  @param __pos  Index of character to search back from (default end).
01737        *  @return  Index of last occurrence.
01738        *
01739        *  Starting from @a __pos, searches backward for @a __c within
01740        *  this string.  If found, returns the index where it was
01741        *  found.  If not found, returns npos.
01742        *
01743        *  Note: equivalent to rfind(c, pos).
01744       */
01745       size_type
01746       find_last_of(_CharT __c, size_type __pos = npos) const
01747       { return this->rfind(__c, __pos); }
01748 
01749       /**
01750        *  @brief  Find position of a character not in string.
01751        *  @param __str  String containing characters to avoid.
01752        *  @param __pos  Index of character to search from (default 0).
01753        *  @return  Index of first occurrence.
01754        *
01755        *  Starting from @a __pos, searches forward for a character not
01756        *  contained in @a __str within this string.  If found, returns
01757        *  the index where it was found.  If not found, returns npos.
01758       */
01759       size_type
01760       find_first_not_of(const __versa_string& __str, size_type __pos = 0) const
01761       { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
01762 
01763       /**
01764        *  @brief  Find position of a character not in C substring.
01765        *  @param __s  C string containing characters to avoid.
01766        *  @param __pos  Index of character to search from.
01767        *  @param __n  Number of characters from s to consider.
01768        *  @return  Index of first occurrence.
01769        *
01770        *  Starting from @a __pos, searches forward for a character not
01771        *  contained in the first @a __n characters of @a __s within
01772        *  this string.  If found, returns the index where it was
01773        *  found.  If not found, returns npos.
01774       */
01775       size_type
01776       find_first_not_of(const _CharT* __s, size_type __pos,
01777             size_type __n) const;
01778 
01779       /**
01780        *  @brief  Find position of a character not in C string.
01781        *  @param __s  C string containing characters to avoid.
01782        *  @param __pos  Index of character to search from (default 0).
01783        *  @return  Index of first occurrence.
01784        *
01785        *  Starting from @a __pos, searches forward for a character not
01786        *  contained in @a __s within this string.  If found, returns
01787        *  the index where it was found.  If not found, returns npos.
01788       */
01789       size_type
01790       find_first_not_of(const _CharT* __s, size_type __pos = 0) const
01791       {
01792     __glibcxx_requires_string(__s);
01793     return this->find_first_not_of(__s, __pos, traits_type::length(__s));
01794       }
01795 
01796       /**
01797        *  @brief  Find position of a different character.
01798        *  @param __c  Character to avoid.
01799        *  @param __pos  Index of character to search from (default 0).
01800        *  @return  Index of first occurrence.
01801        *
01802        *  Starting from @a __pos, searches forward for a character
01803        *  other than @a __c within this string.  If found, returns the
01804        *  index where it was found.  If not found, returns npos.
01805       */
01806       size_type
01807       find_first_not_of(_CharT __c, size_type __pos = 0) const;
01808 
01809       /**
01810        *  @brief  Find last position of a character not in string.
01811        *  @param __str  String containing characters to avoid.
01812        *  @param __pos  Index of character to search back from (default end).
01813        *  @return  Index of last occurrence.
01814        *
01815        *  Starting from @a __pos, searches backward for a character
01816        *  not contained in @a __str within this string.  If found,
01817        *  returns the index where it was found.  If not found, returns
01818        *  npos.
01819       */
01820       size_type
01821       find_last_not_of(const __versa_string& __str,
01822                size_type __pos = npos) const
01823       { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
01824 
01825       /**
01826        *  @brief  Find last position of a character not in C substring.
01827        *  @param __s  C string containing characters to avoid.
01828        *  @param __pos  Index of character to search back from.
01829        *  @param __n  Number of characters from s to consider.
01830        *  @return  Index of last occurrence.
01831        *
01832        *  Starting from @a __pos, searches backward for a character
01833        *  not contained in the first @a __n characters of @a __s
01834        *  within this string.  If found, returns the index where it
01835        *  was found.  If not found, returns npos.
01836       */
01837       size_type
01838       find_last_not_of(const _CharT* __s, size_type __pos,
01839                size_type __n) const;
01840       /**
01841        *  @brief  Find last position of a character not in C string.
01842        *  @param __s  C string containing characters to avoid.
01843        *  @param __pos  Index of character to search back from (default end).
01844        *  @return  Index of last occurrence.
01845        *
01846        *  Starting from @a __pos, searches backward for a character
01847        *  not contained in @a __s within this string.  If found,
01848        *  returns the index where it was found.  If not found, returns
01849        *  npos.
01850       */
01851       size_type
01852       find_last_not_of(const _CharT* __s, size_type __pos = npos) const
01853       {
01854     __glibcxx_requires_string(__s);
01855     return this->find_last_not_of(__s, __pos, traits_type::length(__s));
01856       }
01857 
01858       /**
01859        *  @brief  Find last position of a different character.
01860        *  @param __c  Character to avoid.
01861        *  @param __pos  Index of character to search back from (default end).
01862        *  @return  Index of last occurrence.
01863        *
01864        *  Starting from @a __pos, searches backward for a character
01865        *  other than @a __c within this string.  If found, returns the
01866        *  index where it was found.  If not found, returns npos.
01867       */
01868       size_type
01869       find_last_not_of(_CharT __c, size_type __pos = npos) const;
01870 
01871       /**
01872        *  @brief  Get a substring.
01873        *  @param __pos  Index of first character (default 0).
01874        *  @param __n  Number of characters in substring (default remainder).
01875        *  @return  The new string.
01876        *  @throw  std::out_of_range  If pos > size().
01877        *
01878        *  Construct and return a new string using the @a __n
01879        *  characters starting at @a __pos.  If the string is too
01880        *  short, use the remainder of the characters.  If @a __pos is
01881        *  beyond the end of the string, out_of_range is thrown.
01882       */
01883       __versa_string
01884       substr(size_type __pos = 0, size_type __n = npos) const
01885       {
01886     return __versa_string(*this, _M_check(__pos, "__versa_string::substr"),
01887                   __n);
01888       }
01889 
01890       /**
01891        *  @brief  Compare to a string.
01892        *  @param __str  String to compare against.
01893        *  @return  Integer < 0, 0, or > 0.
01894        *
01895        *  Returns an integer < 0 if this string is ordered before @a
01896        *  __str, 0 if their values are equivalent, or > 0 if this
01897        *  string is ordered after @a __str.  Determines the effective
01898        *  length rlen of the strings to compare as the smallest of
01899        *  size() and str.size().  The function then compares the two
01900        *  strings by calling traits::compare(data(), str.data(),rlen).
01901        *  If the result of the comparison is nonzero returns it,
01902        *  otherwise the shorter one is ordered first.
01903       */
01904       int
01905       compare(const __versa_string& __str) const
01906       {
01907     if (this->_M_compare(__str))
01908       return 0;
01909 
01910     const size_type __size = this->size();
01911     const size_type __osize = __str.size();
01912     const size_type __len = std::min(__size, __osize);
01913 
01914     int __r = traits_type::compare(this->_M_data(), __str.data(), __len);
01915     if (!__r)
01916       __r = _S_compare(__size, __osize);
01917     return __r;
01918       }
01919 
01920       /**
01921        *  @brief  Compare substring to a string.
01922        *  @param __pos  Index of first character of substring.
01923        *  @param __n  Number of characters in substring.
01924        *  @param __str  String to compare against.
01925        *  @return  Integer < 0, 0, or > 0.
01926        *
01927        *  Form the substring of this string from the @a __n characters
01928        *  starting at @a __pos.  Returns an integer < 0 if the
01929        *  substring is ordered before @a __str, 0 if their values are
01930        *  equivalent, or > 0 if the substring is ordered after @a
01931        *  __str.  Determines the effective length rlen of the strings
01932        *  to compare as the smallest of the length of the substring
01933        *  and @a __str.size().  The function then compares the two
01934        *  strings by calling
01935        *  traits::compare(substring.data(),str.data(),rlen).  If the
01936        *  result of the comparison is nonzero returns it, otherwise
01937        *  the shorter one is ordered first.
01938       */
01939       int
01940       compare(size_type __pos, size_type __n,
01941           const __versa_string& __str) const;
01942 
01943       /**
01944        *  @brief  Compare substring to a substring.
01945        *  @param __pos1  Index of first character of substring.
01946        *  @param __n1  Number of characters in substring.
01947        *  @param __str  String to compare against.
01948        *  @param __pos2  Index of first character of substring of str.
01949        *  @param __n2  Number of characters in substring of str.
01950        *  @return  Integer < 0, 0, or > 0.
01951        *
01952        *  Form the substring of this string from the @a __n1
01953        *  characters starting at @a __pos1.  Form the substring of @a
01954        *  __str from the @a __n2 characters starting at @a __pos2.
01955        *  Returns an integer < 0 if this substring is ordered before
01956        *  the substring of @a __str, 0 if their values are equivalent,
01957        *  or > 0 if this substring is ordered after the substring of
01958        *  @a __str.  Determines the effective length rlen of the
01959        *  strings to compare as the smallest of the lengths of the
01960        *  substrings.  The function then compares the two strings by
01961        *  calling
01962        *  traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen).
01963        *  If the result of the comparison is nonzero returns it,
01964        *  otherwise the shorter one is ordered first.
01965       */
01966       int
01967       compare(size_type __pos1, size_type __n1, const __versa_string& __str,
01968           size_type __pos2, size_type __n2) const;
01969 
01970       /**
01971        *  @brief  Compare to a C string.
01972        *  @param __s  C string to compare against.
01973        *  @return  Integer < 0, 0, or > 0.
01974        *
01975        *  Returns an integer < 0 if this string is ordered before @a
01976        *  __s, 0 if their values are equivalent, or > 0 if this string
01977        *  is ordered after @a __s.  Determines the effective length
01978        *  rlen of the strings to compare as the smallest of size() and
01979        *  the length of a string constructed from @a __s.  The
01980        *  function then compares the two strings by calling
01981        *  traits::compare(data(),s,rlen).  If the result of the
01982        *  comparison is nonzero returns it, otherwise the shorter one
01983        *  is ordered first.
01984       */
01985       int
01986       compare(const _CharT* __s) const;
01987 
01988       // _GLIBCXX_RESOLVE_LIB_DEFECTS
01989       // 5 String::compare specification questionable
01990       /**
01991        *  @brief  Compare substring to a C string.
01992        *  @param __pos  Index of first character of substring.
01993        *  @param __n1  Number of characters in substring.
01994        *  @param __s  C string to compare against.
01995        *  @return  Integer < 0, 0, or > 0.
01996        *
01997        *  Form the substring of this string from the @a __n1
01998        *  characters starting at @a __pos.  Returns an integer < 0 if
01999        *  the substring is ordered before @a __s, 0 if their values
02000        *  are equivalent, or > 0 if the substring is ordered after @a
02001        *  __s.  Determines the effective length rlen of the strings to
02002        *  compare as the smallest of the length of the substring and
02003        *  the length of a string constructed from @a __s.  The
02004        *  function then compares the two string by calling
02005        *  traits::compare(substring.data(),s,rlen).  If the result of
02006        *  the comparison is nonzero returns it, otherwise the shorter
02007        *  one is ordered first.
02008       */
02009       int
02010       compare(size_type __pos, size_type __n1, const _CharT* __s) const;
02011 
02012       /**
02013        *  @brief  Compare substring against a character array.
02014        *  @param __pos1  Index of first character of substring.
02015        *  @param __n1  Number of characters in substring.
02016        *  @param __s  character array to compare against.
02017        *  @param __n2  Number of characters of s.
02018        *  @return  Integer < 0, 0, or > 0.
02019        *
02020        *  Form the substring of this string from the @a __n1
02021        *  characters starting at @a __pos1.  Form a string from the
02022        *  first @a __n2 characters of @a __s.  Returns an integer < 0
02023        *  if this substring is ordered before the string from @a __s,
02024        *  0 if their values are equivalent, or > 0 if this substring
02025        *  is ordered after the string from @a __s.  Determines the
02026        *  effective length rlen of the strings to compare as the
02027        *  smallest of the length of the substring and @a __n2.  The
02028        *  function then compares the two strings by calling
02029        *  traits::compare(substring.data(),s,rlen).  If the result of
02030        *  the comparison is nonzero returns it, otherwise the shorter
02031        *  one is ordered first.
02032        *
02033        *  NB: s must have at least n2 characters, <em>\\0</em> has no special
02034        *  meaning.
02035       */
02036       int
02037       compare(size_type __pos, size_type __n1, const _CharT* __s,
02038           size_type __n2) const;
02039     };
02040 
02041   // operator+
02042   /**
02043    *  @brief  Concatenate two strings.
02044    *  @param __lhs  First string.
02045    *  @param __rhs  Last string.
02046    *  @return  New string with value of @a __lhs followed by @a __rhs.
02047    */
02048   template<typename _CharT, typename _Traits, typename _Alloc,
02049        template <typename, typename, typename> class _Base>
02050     __versa_string<_CharT, _Traits, _Alloc, _Base>
02051     operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02052           const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs);
02053 
02054   /**
02055    *  @brief  Concatenate C string and string.
02056    *  @param __lhs  First string.
02057    *  @param __rhs  Last string.
02058    *  @return  New string with value of @a __lhs followed by @a __rhs.
02059    */
02060   template<typename _CharT, typename _Traits, typename _Alloc,
02061        template <typename, typename, typename> class _Base>
02062     __versa_string<_CharT, _Traits, _Alloc, _Base>
02063     operator+(const _CharT* __lhs,
02064           const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs);
02065 
02066   /**
02067    *  @brief  Concatenate character and string.
02068    *  @param __lhs  First string.
02069    *  @param __rhs  Last string.
02070    *  @return  New string with @a __lhs followed by @a __rhs.
02071    */
02072   template<typename _CharT, typename _Traits, typename _Alloc,
02073        template <typename, typename, typename> class _Base>
02074     __versa_string<_CharT, _Traits, _Alloc, _Base>
02075     operator+(_CharT __lhs,
02076           const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs);
02077 
02078   /**
02079    *  @brief  Concatenate string and C string.
02080    *  @param __lhs  First string.
02081    *  @param __rhs  Last string.
02082    *  @return  New string with @a __lhs followed by @a __rhs.
02083    */
02084   template<typename _CharT, typename _Traits, typename _Alloc,
02085        template <typename, typename, typename> class _Base>
02086     __versa_string<_CharT, _Traits, _Alloc, _Base>
02087     operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02088           const _CharT* __rhs);
02089 
02090   /**
02091    *  @brief  Concatenate string and character.
02092    *  @param __lhs  First string.
02093    *  @param __rhs  Last string.
02094    *  @return  New string with @a __lhs followed by @a __rhs.
02095    */
02096   template<typename _CharT, typename _Traits, typename _Alloc,
02097        template <typename, typename, typename> class _Base>
02098     __versa_string<_CharT, _Traits, _Alloc, _Base>
02099     operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02100           _CharT __rhs);
02101 
02102   // operator ==
02103   /**
02104    *  @brief  Test equivalence of two strings.
02105    *  @param __lhs  First string.
02106    *  @param __rhs  Second string.
02107    *  @return  True if @a __lhs.compare(@a __rhs) == 0.  False otherwise.
02108    */
02109   template<typename _CharT, typename _Traits, typename _Alloc,
02110        template <typename, typename, typename> class _Base>
02111     inline bool
02112     operator==(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02113            const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02114     { return __lhs.compare(__rhs) == 0; }
02115 
02116   template<typename _CharT,
02117        template <typename, typename, typename> class _Base>
02118     inline typename __enable_if<std::__is_char<_CharT>::__value, bool>::__type
02119     operator==(const __versa_string<_CharT, std::char_traits<_CharT>,
02120            std::allocator<_CharT>, _Base>& __lhs,
02121            const __versa_string<_CharT, std::char_traits<_CharT>,
02122            std::allocator<_CharT>, _Base>& __rhs)
02123     { return (__lhs.size() == __rhs.size()
02124           && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
02125                             __lhs.size())); }
02126 
02127   /**
02128    *  @brief  Test equivalence of C string and string.
02129    *  @param __lhs  C string.
02130    *  @param __rhs  String.
02131    *  @return  True if @a __rhs.compare(@a __lhs) == 0.  False otherwise.
02132    */
02133   template<typename _CharT, typename _Traits, typename _Alloc,
02134        template <typename, typename, typename> class _Base>
02135     inline bool
02136     operator==(const _CharT* __lhs,
02137            const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02138     { return __rhs.compare(__lhs) == 0; }
02139 
02140   /**
02141    *  @brief  Test equivalence of string and C string.
02142    *  @param __lhs  String.
02143    *  @param __rhs  C string.
02144    *  @return  True if @a __lhs.compare(@a __rhs) == 0.  False otherwise.
02145    */
02146   template<typename _CharT, typename _Traits, typename _Alloc,
02147        template <typename, typename, typename> class _Base>
02148     inline bool
02149     operator==(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02150            const _CharT* __rhs)
02151     { return __lhs.compare(__rhs) == 0; }
02152 
02153   // operator !=
02154   /**
02155    *  @brief  Test difference of two strings.
02156    *  @param __lhs  First string.
02157    *  @param __rhs  Second string.
02158    *  @return  True if @a __lhs.compare(@a __rhs) != 0.  False otherwise.
02159    */
02160   template<typename _CharT, typename _Traits, typename _Alloc,
02161        template <typename, typename, typename> class _Base>
02162     inline bool
02163     operator!=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02164            const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02165     { return !(__lhs == __rhs); }
02166 
02167   /**
02168    *  @brief  Test difference of C string and string.
02169    *  @param __lhs  C string.
02170    *  @param __rhs  String.
02171    *  @return  True if @a __rhs.compare(@a __lhs) != 0.  False otherwise.
02172    */
02173   template<typename _CharT, typename _Traits, typename _Alloc,
02174        template <typename, typename, typename> class _Base>
02175     inline bool
02176     operator!=(const _CharT* __lhs,
02177            const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02178     { return !(__lhs == __rhs); }
02179 
02180   /**
02181    *  @brief  Test difference of string and C string.
02182    *  @param __lhs  String.
02183    *  @param __rhs  C string.
02184    *  @return  True if @a __lhs.compare(@a __rhs) != 0.  False otherwise.
02185    */
02186   template<typename _CharT, typename _Traits, typename _Alloc,
02187        template <typename, typename, typename> class _Base>
02188     inline bool
02189     operator!=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02190            const _CharT* __rhs)
02191     { return !(__lhs == __rhs); }
02192 
02193   // operator <
02194   /**
02195    *  @brief  Test if string precedes string.
02196    *  @param __lhs  First string.
02197    *  @param __rhs  Second string.
02198    *  @return  True if @a __lhs precedes @a __rhs.  False otherwise.
02199    */
02200   template<typename _CharT, typename _Traits, typename _Alloc,
02201        template <typename, typename, typename> class _Base>
02202     inline bool
02203     operator<(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02204           const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02205     { return __lhs.compare(__rhs) < 0; }
02206 
02207   /**
02208    *  @brief  Test if string precedes C string.
02209    *  @param __lhs  String.
02210    *  @param __rhs  C string.
02211    *  @return  True if @a __lhs precedes @a __rhs.  False otherwise.
02212    */
02213   template<typename _CharT, typename _Traits, typename _Alloc,
02214        template <typename, typename, typename> class _Base>
02215     inline bool
02216     operator<(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02217           const _CharT* __rhs)
02218     { return __lhs.compare(__rhs) < 0; }
02219 
02220   /**
02221    *  @brief  Test if C string precedes string.
02222    *  @param __lhs  C string.
02223    *  @param __rhs  String.
02224    *  @return  True if @a __lhs precedes @a __rhs.  False otherwise.
02225    */
02226   template<typename _CharT, typename _Traits, typename _Alloc,
02227        template <typename, typename, typename> class _Base>
02228     inline bool
02229     operator<(const _CharT* __lhs,
02230           const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02231     { return __rhs.compare(__lhs) > 0; }
02232 
02233   // operator >
02234   /**
02235    *  @brief  Test if string follows string.
02236    *  @param __lhs  First string.
02237    *  @param __rhs  Second string.
02238    *  @return  True if @a __lhs follows @a __rhs.  False otherwise.
02239    */
02240   template<typename _CharT, typename _Traits, typename _Alloc,
02241        template <typename, typename, typename> class _Base>
02242     inline bool
02243     operator>(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02244           const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02245     { return __lhs.compare(__rhs) > 0; }
02246 
02247   /**
02248    *  @brief  Test if string follows C string.
02249    *  @param __lhs  String.
02250    *  @param __rhs  C string.
02251    *  @return  True if @a __lhs follows @a __rhs.  False otherwise.
02252    */
02253   template<typename _CharT, typename _Traits, typename _Alloc,
02254        template <typename, typename, typename> class _Base>
02255     inline bool
02256     operator>(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02257           const _CharT* __rhs)
02258     { return __lhs.compare(__rhs) > 0; }
02259 
02260   /**
02261    *  @brief  Test if C string follows string.
02262    *  @param __lhs  C string.
02263    *  @param __rhs  String.
02264    *  @return  True if @a __lhs follows @a __rhs.  False otherwise.
02265    */
02266   template<typename _CharT, typename _Traits, typename _Alloc,
02267        template <typename, typename, typename> class _Base>
02268     inline bool
02269     operator>(const _CharT* __lhs,
02270           const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02271     { return __rhs.compare(__lhs) < 0; }
02272 
02273   // operator <=
02274   /**
02275    *  @brief  Test if string doesn't follow string.
02276    *  @param __lhs  First string.
02277    *  @param __rhs  Second string.
02278    *  @return  True if @a __lhs doesn't follow @a __rhs.  False otherwise.
02279    */
02280   template<typename _CharT, typename _Traits, typename _Alloc,
02281        template <typename, typename, typename> class _Base>
02282     inline bool
02283     operator<=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02284            const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02285     { return __lhs.compare(__rhs) <= 0; }
02286 
02287   /**
02288    *  @brief  Test if string doesn't follow C string.
02289    *  @param __lhs  String.
02290    *  @param __rhs  C string.
02291    *  @return  True if @a __lhs doesn't follow @a __rhs.  False otherwise.
02292    */
02293   template<typename _CharT, typename _Traits, typename _Alloc,
02294        template <typename, typename, typename> class _Base>
02295     inline bool
02296     operator<=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02297            const _CharT* __rhs)
02298     { return __lhs.compare(__rhs) <= 0; }
02299 
02300   /**
02301    *  @brief  Test if C string doesn't follow string.
02302    *  @param __lhs  C string.
02303    *  @param __rhs  String.
02304    *  @return  True if @a __lhs doesn't follow @a __rhs.  False otherwise.
02305    */
02306   template<typename _CharT, typename _Traits, typename _Alloc,
02307        template <typename, typename, typename> class _Base>
02308     inline bool
02309     operator<=(const _CharT* __lhs,
02310            const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02311     { return __rhs.compare(__lhs) >= 0; }
02312 
02313   // operator >=
02314   /**
02315    *  @brief  Test if string doesn't precede string.
02316    *  @param __lhs  First string.
02317    *  @param __rhs  Second string.
02318    *  @return  True if @a __lhs doesn't precede @a __rhs.  False otherwise.
02319    */
02320   template<typename _CharT, typename _Traits, typename _Alloc,
02321        template <typename, typename, typename> class _Base>
02322     inline bool
02323     operator>=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02324            const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02325     { return __lhs.compare(__rhs) >= 0; }
02326 
02327   /**
02328    *  @brief  Test if string doesn't precede C string.
02329    *  @param __lhs  String.
02330    *  @param __rhs  C string.
02331    *  @return  True if @a __lhs doesn't precede @a __rhs.  False otherwise.
02332    */
02333   template<typename _CharT, typename _Traits, typename _Alloc,
02334        template <typename, typename, typename> class _Base>
02335     inline bool
02336     operator>=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02337            const _CharT* __rhs)
02338     { return __lhs.compare(__rhs) >= 0; }
02339 
02340   /**
02341    *  @brief  Test if C string doesn't precede string.
02342    *  @param __lhs  C string.
02343    *  @param __rhs  String.
02344    *  @return  True if @a __lhs doesn't precede @a __rhs.  False otherwise.
02345    */
02346   template<typename _CharT, typename _Traits, typename _Alloc,
02347        template <typename, typename, typename> class _Base>
02348     inline bool
02349     operator>=(const _CharT* __lhs,
02350            const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02351     { return __rhs.compare(__lhs) <= 0; }
02352 
02353   /**
02354    *  @brief  Swap contents of two strings.
02355    *  @param __lhs  First string.
02356    *  @param __rhs  Second string.
02357    *
02358    *  Exchanges the contents of @a __lhs and @a __rhs in constant time.
02359    */
02360   template<typename _CharT, typename _Traits, typename _Alloc,
02361        template <typename, typename, typename> class _Base>
02362     inline void
02363     swap(__versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02364      __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02365     { __lhs.swap(__rhs); }
02366 
02367 _GLIBCXX_END_NAMESPACE
02368 
02369 _GLIBCXX_BEGIN_NAMESPACE(std)
02370 
02371   /**
02372    *  @brief  Read stream into a string.
02373    *  @param __is  Input stream.
02374    *  @param __str  Buffer to store into.
02375    *  @return  Reference to the input stream.
02376    *
02377    *  Stores characters from @a __is into @a __str until whitespace is
02378    *  found, the end of the stream is encountered, or str.max_size()
02379    *  is reached.  If is.width() is non-zero, that is the limit on the
02380    *  number of characters stored into @a __str.  Any previous
02381    *  contents of @a __str are erased.
02382    */
02383   template<typename _CharT, typename _Traits, typename _Alloc,
02384            template <typename, typename, typename> class _Base>
02385     basic_istream<_CharT, _Traits>&
02386     operator>>(basic_istream<_CharT, _Traits>& __is,
02387            __gnu_cxx::__versa_string<_CharT, _Traits,
02388                                      _Alloc, _Base>& __str);
02389 
02390   /**
02391    *  @brief  Write string to a stream.
02392    *  @param __os  Output stream.
02393    *  @param __str  String to write out.
02394    *  @return  Reference to the output stream.
02395    *
02396    *  Output characters of @a __str into os following the same rules as for
02397    *  writing a C string.
02398    */
02399   template<typename _CharT, typename _Traits, typename _Alloc,
02400        template <typename, typename, typename> class _Base>
02401     inline basic_ostream<_CharT, _Traits>&
02402     operator<<(basic_ostream<_CharT, _Traits>& __os,
02403            const __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc,
02404            _Base>& __str)
02405     {
02406       // _GLIBCXX_RESOLVE_LIB_DEFECTS
02407       // 586. string inserter not a formatted function
02408       return __ostream_insert(__os, __str.data(), __str.size());
02409     }
02410 
02411   /**
02412    *  @brief  Read a line from stream into a string.
02413    *  @param __is  Input stream.
02414    *  @param __str  Buffer to store into.
02415    *  @param __delim  Character marking end of line.
02416    *  @return  Reference to the input stream.
02417    *
02418    *  Stores characters from @a __is into @a __str until @a __delim is
02419    *  found, the end of the stream is encountered, or str.max_size()
02420    *  is reached.  If is.width() is non-zero, that is the limit on the
02421    *  number of characters stored into @a __str.  Any previous
02422    *  contents of @a __str are erased.  If @a delim was encountered,
02423    *  it is extracted but not stored into @a __str.
02424    */
02425   template<typename _CharT, typename _Traits, typename _Alloc,
02426            template <typename, typename, typename> class _Base>
02427     basic_istream<_CharT, _Traits>&
02428     getline(basic_istream<_CharT, _Traits>& __is,
02429         __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str,
02430         _CharT __delim);
02431 
02432   /**
02433    *  @brief  Read a line from stream into a string.
02434    *  @param __is  Input stream.
02435    *  @param __str  Buffer to store into.
02436    *  @return  Reference to the input stream.
02437    *
02438    *  Stores characters from is into @a __str until &apos;\n&apos; is
02439    *  found, the end of the stream is encountered, or str.max_size()
02440    *  is reached.  If is.width() is non-zero, that is the limit on the
02441    *  number of characters stored into @a __str.  Any previous
02442    *  contents of @a __str are erased.  If end of line was
02443    *  encountered, it is extracted but not stored into @a __str.
02444    */
02445   template<typename _CharT, typename _Traits, typename _Alloc,
02446            template <typename, typename, typename> class _Base>
02447     inline basic_istream<_CharT, _Traits>&
02448     getline(basic_istream<_CharT, _Traits>& __is,
02449         __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str)
02450     { return getline(__is, __str, __is.widen('\n')); }      
02451 
02452 _GLIBCXX_END_NAMESPACE
02453 
02454 #if (defined(__GXX_EXPERIMENTAL_CXX0X__) && defined(_GLIBCXX_USE_C99))
02455 
02456 #include <ext/string_conversions.h>
02457 
02458 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
02459 
02460   // 21.4 Numeric Conversions [string.conversions].
02461   inline int
02462   stoi(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
02463   { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
02464                     __idx, __base); }
02465 
02466   inline long
02467   stol(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
02468   { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
02469                  __idx, __base); }
02470 
02471   inline unsigned long
02472   stoul(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
02473   { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
02474                  __idx, __base); }
02475 
02476   inline long long
02477   stoll(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
02478   { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
02479                  __idx, __base); }
02480 
02481   inline unsigned long long
02482   stoull(const __vstring& __str, std::size_t* __idx, int __base = 10)
02483   { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
02484                  __idx, __base); }
02485 
02486   // NB: strtof vs strtod.
02487   inline float
02488   stof(const __vstring& __str, std::size_t* __idx = 0)
02489   { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
02490 
02491   inline double
02492   stod(const __vstring& __str, std::size_t* __idx = 0)
02493   { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
02494 
02495   inline long double
02496   stold(const __vstring& __str, std::size_t* __idx = 0)
02497   { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
02498 
02499   // NB: (v)snprintf vs sprintf.
02500 
02501   // DR 1261.
02502   inline __vstring
02503   to_string(int __val)
02504   { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, 4 * sizeof(int),
02505                           "%d", __val); }
02506 
02507   inline __vstring
02508   to_string(unsigned __val)
02509   { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
02510                           4 * sizeof(unsigned),
02511                           "%u", __val); }
02512 
02513   inline __vstring
02514   to_string(long __val)
02515   { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
02516                           4 * sizeof(long),
02517                           "%ld", __val); }
02518 
02519   inline __vstring
02520   to_string(unsigned long __val)
02521   { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
02522                           4 * sizeof(unsigned long),
02523                           "%lu", __val); }
02524 
02525 
02526   inline __vstring
02527   to_string(long long __val)
02528   { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
02529                           4 * sizeof(long long),
02530                           "%lld", __val); }
02531 
02532   inline __vstring
02533   to_string(unsigned long long __val)
02534   { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
02535                           4 * sizeof(unsigned long long),
02536                           "%llu", __val); }
02537 
02538   inline __vstring
02539   to_string(float __val)
02540   {
02541     const int __n = __numeric_traits<float>::__max_exponent10 + 20;
02542     return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, __n,
02543                           "%f", __val);
02544   }
02545 
02546   inline __vstring
02547   to_string(double __val)
02548   {
02549     const int __n = __numeric_traits<double>::__max_exponent10 + 20;
02550     return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, __n,
02551                           "%f", __val);
02552   }
02553 
02554   inline __vstring
02555   to_string(long double __val)
02556   {
02557     const int __n = __numeric_traits<long double>::__max_exponent10 + 20;
02558     return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, __n,
02559                           "%Lf", __val);
02560   }
02561 
02562 #ifdef _GLIBCXX_USE_WCHAR_T
02563   inline int 
02564   stoi(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
02565   { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
02566                     __idx, __base); }
02567 
02568   inline long 
02569   stol(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
02570   { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
02571                  __idx, __base); }
02572 
02573   inline unsigned long
02574   stoul(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
02575   { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
02576                  __idx, __base); }
02577 
02578   inline long long
02579   stoll(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
02580   { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
02581                  __idx, __base); }
02582 
02583   inline unsigned long long
02584   stoull(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
02585   { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
02586                  __idx, __base); }
02587 
02588   // NB: wcstof vs wcstod.
02589   inline float
02590   stof(const __wvstring& __str, std::size_t* __idx = 0)
02591   { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
02592 
02593   inline double
02594   stod(const __wvstring& __str, std::size_t* __idx = 0)
02595   { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
02596 
02597   inline long double
02598   stold(const __wvstring& __str, std::size_t* __idx = 0)
02599   { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
02600 
02601 #ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF
02602   // DR 1261.
02603   inline __wvstring
02604   to_wstring(int __val)
02605   { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02606                            4 * sizeof(int),
02607                            L"%d", __val); }
02608 
02609   inline __wvstring
02610   to_wstring(unsigned __val)
02611   { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02612                            4 * sizeof(unsigned),
02613                            L"%u", __val); }
02614 
02615   inline __wvstring
02616   to_wstring(long __val)
02617   { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02618                            4 * sizeof(long),
02619                            L"%ld", __val); }
02620 
02621   inline __wvstring
02622   to_wstring(unsigned long __val)
02623   { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02624                            4 * sizeof(unsigned long),
02625                            L"%lu", __val); }
02626 
02627   inline __wvstring
02628   to_wstring(long long __val)
02629   { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02630                            4 * sizeof(long long),
02631                            L"%lld", __val); }
02632 
02633   inline __wvstring
02634   to_wstring(unsigned long long __val)
02635   { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02636                            4 * sizeof(unsigned long long),
02637                            L"%llu", __val); }
02638 
02639   inline __wvstring
02640   to_wstring(float __val)
02641   {
02642     const int __n = __numeric_traits<float>::__max_exponent10 + 20;
02643     return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf, __n,
02644                            L"%f", __val);
02645   }
02646 
02647   inline __wvstring
02648   to_wstring(double __val)
02649   {
02650     const int __n = __numeric_traits<double>::__max_exponent10 + 20;
02651     return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf, __n,
02652                            L"%f", __val);
02653   }
02654 
02655   inline __wvstring
02656   to_wstring(long double __val)
02657   {
02658     const int __n = __numeric_traits<long double>::__max_exponent10 + 20;
02659     return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf, __n,
02660                            L"%Lf", __val);
02661   }
02662 #endif
02663 #endif
02664 
02665 _GLIBCXX_END_NAMESPACE
02666 
02667 #endif
02668 
02669 #ifndef _GLIBCXX_EXPORT_TEMPLATE
02670 # include "vstring.tcc" 
02671 #endif
02672 
02673 #endif /* _VSTRING_H */

Generated on 9 Feb 2010 for libstdc++ by  doxygen 1.6.1