# debug/string

Go to the documentation of this file.

    00001 // Debugging string implementation -*- C++ -*-
    00002
    00003 // Copyright (C) 2003, 2005, 2006, 2009
    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 debug/string
    00027  *  This file is a GNU debug extension to the Standard C++ Library.
    00028  */
    00029
    00030 #ifndef _GLIBCXX_DEBUG_STRING
    00031 #define _GLIBCXX_DEBUG_STRING 1
    00032
    00033 #include <string>
    00034 #include <debug/safe_sequence.h>
    00035 #include <debug/safe_iterator.h>
    00036
    00037 namespace __gnu_debug
    00038 {
    00039   template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
    00040             typename _Allocator = std::allocator<_CharT> >
    00041     class basic_string
    00042     : public std::basic_string<_CharT, _Traits, _Allocator>,
    00043       public __gnu_debug::_Safe_sequence<basic_string<_CharT, _Traits,
    00044                               _Allocator> >
    00045     {
    00046       typedef std::basic_string<_CharT, _Traits, _Allocator> _Base;
    00047       typedef __gnu_debug::_Safe_sequence<basic_string>     _Safe_base;
    00048
    00049   public:
    00050     // types:
    00051     typedef _Traits                    traits_type;
    00052     typedef typename _Traits::char_type            value_type;
    00053     typedef _Allocator                     allocator_type;
    00054     typedef typename _Base::size_type                  size_type;
    00055     typedef typename _Base::difference_type            difference_type;
    00056     typedef typename _Base::reference                  reference;
    00057     typedef typename _Base::const_reference            const_reference;
    00058     typedef typename _Base::pointer                    pointer;
    00059     typedef typename _Base::const_pointer              const_pointer;
    00060
    00061     typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, basic_string>
    00062                                                        iterator;
    00063     typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
    00064                                          basic_string> const_iterator;
    00065
    00066     typedef std::reverse_iterator<iterator>            reverse_iterator;
    00067     typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;
    00068
    00069     using _Base::npos;
    00070
    00071     // 21.3.1 construct/copy/destroy:
    00072     explicit basic_string(const _Allocator& __a = _Allocator())
    00073     : _Base(__a)
    00074     { }
    00075
    00076     // Provides conversion from a release-mode string to a debug-mode string
    00077     basic_string(const _Base& __base) : _Base(__base), _Safe_base() { }
    00078
    00079     // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00080     // 42. string ctors specify wrong default allocator
    00081     basic_string(const basic_string& __str)
    00082     : _Base(__str, 0, _Base::npos, __str.get_allocator()), _Safe_base()
    00083     { }
    00084
    00085     // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00086     // 42. string ctors specify wrong default allocator
    00087     basic_string(const basic_string& __str, size_type __pos,
    00088            size_type __n = _Base::npos,
    00089            const _Allocator& __a = _Allocator())
    00090     : _Base(__str, __pos, __n, __a)
    00091     { }
    00092
    00093     basic_string(const _CharT* __s, size_type __n,
    00094            const _Allocator& __a = _Allocator())
    00095     : _Base(__gnu_debug::__check_string(__s, __n), __n, __a)
    00096     { }
    00097
    00098     basic_string(const _CharT* __s, const _Allocator& __a = _Allocator())
    00099     : _Base(__gnu_debug::__check_string(__s), __a)
    00100     { this->assign(__s); }
    00101
    00102     basic_string(size_type __n, _CharT __c,
    00103            const _Allocator& __a = _Allocator())
    00104     : _Base(__n, __c, __a)
    00105     { }
    00106
    00107     template<typename _InputIterator>
    00108       basic_string(_InputIterator __begin, _InputIterator __end,
    00109              const _Allocator& __a = _Allocator())
    00110       : _Base(__gnu_debug::__check_valid_range(__begin, __end), __end, __a)
    00111       { }
    00112
    00113 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00114     basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
    00115     : _Base(__l, __a)
    00116     { }
    00117 #endif // __GXX_EXPERIMENTAL_CXX0X__
    00118
    00119     ~basic_string() { }
    00120
    00121     basic_string&
    00122     operator=(const basic_string& __str)
    00123     {
    00124       *static_cast<_Base*>(this) = __str;
    00125       this->_M_invalidate_all();
    00126       return *this;
    00127     }
    00128
    00129     basic_string&
    00130     operator=(const _CharT* __s)
    00131     {
    00132       __glibcxx_check_string(__s);
    00133       *static_cast<_Base*>(this) = __s;
    00134       this->_M_invalidate_all();
    00135       return *this;
    00136     }
    00137
    00138     basic_string&
    00139     operator=(_CharT __c)
    00140     {
    00141       *static_cast<_Base*>(this) = __c;
    00142       this->_M_invalidate_all();
    00143       return *this;
    00144     }
    00145
    00146 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00147     basic_string&
    00148     operator=(initializer_list<_CharT> __l)
    00149     {
    00150       *static_cast<_Base*>(this) = __l;
    00151       this->_M_invalidate_all();
    00152       return *this;
    00153     }
    00154 #endif // __GXX_EXPERIMENTAL_CXX0X__
    00155
    00156     // 21.3.2 iterators:
    00157     iterator
    00158     begin()
    00159     { return iterator(_Base::begin(), this); }
    00160
    00161     const_iterator
    00162     begin() const
    00163     { return const_iterator(_Base::begin(), this); }
    00164
    00165     iterator
    00166     end()
    00167     { return iterator(_Base::end(), this); }
    00168
    00169     const_iterator
    00170     end() const
    00171     { return const_iterator(_Base::end(), this); }
    00172
    00173     reverse_iterator
    00174     rbegin()
    00175     { return reverse_iterator(end()); }
    00176
    00177     const_reverse_iterator
    00178     rbegin() const
    00179     { return const_reverse_iterator(end()); }
    00180
    00181     reverse_iterator
    00182     rend()
    00183     { return reverse_iterator(begin()); }
    00184
    00185     const_reverse_iterator
    00186     rend() const
    00187     { return const_reverse_iterator(begin()); }
    00188
    00189     // 21.3.3 capacity:
    00190     using _Base::size;
    00191     using _Base::length;
    00192     using _Base::max_size;
    00193
    00194     void
    00195     resize(size_type __n, _CharT __c)
    00196     {
    00197       _Base::resize(__n, __c);
    00198       this->_M_invalidate_all();
    00199     }
    00200
    00201     void
    00202     resize(size_type __n)
    00203     { this->resize(__n, _CharT()); }
    00204
    00205     using _Base::capacity;
    00206     using _Base::reserve;
    00207
    00208     void
    00209     clear()
    00210     {
    00211       _Base::clear();
    00212       this->_M_invalidate_all();
    00213     }
    00214
    00215     using _Base::empty;
    00216
    00217     // 21.3.4 element access:
    00218     const_reference
    00219     operator[](size_type __pos) const
    00220     {
    00221       _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
    00222                 _M_message(__gnu_debug::__msg_subscript_oob)
    00223                 ._M_sequence(*this, "this")
    00224                 ._M_integer(__pos, "__pos")
    00225                 ._M_integer(this->size(), "size"));
    00226       return _M_base()[__pos];
    00227     }
    00228
    00229     reference
    00230     operator[](size_type __pos)
    00231     {
    00232 #ifdef _GLIBCXX_DEBUG_PEDANTIC
    00233       __glibcxx_check_subscript(__pos);
    00234 #else
    00235       // as an extension v3 allows s[s.size()] when s is non-const.
    00236       _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
    00237                 _M_message(__gnu_debug::__msg_subscript_oob)
    00238                 ._M_sequence(*this, "this")
    00239                 ._M_integer(__pos, "__pos")
    00240                 ._M_integer(this->size(), "size"));
    00241 #endif
    00242       return _M_base()[__pos];
    00243     }
    00244
    00245     using _Base::at;
    00246
    00247     // 21.3.5 modifiers:
    00248     basic_string&
    00249     operator+=(const basic_string& __str)
    00250     {
    00251       _M_base() += __str;
    00252       this->_M_invalidate_all();
    00253       return *this;
    00254     }
    00255
    00256     basic_string&
    00257     operator+=(const _CharT* __s)
    00258     {
    00259       __glibcxx_check_string(__s);
    00260       _M_base() += __s;
    00261       this->_M_invalidate_all();
    00262       return *this;
    00263     }
    00264
    00265     basic_string&
    00266     operator+=(_CharT __c)
    00267     {
    00268       _M_base() += __c;
    00269       this->_M_invalidate_all();
    00270       return *this;
    00271     }
    00272
    00273 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00274     basic_string&
    00275     operator+=(initializer_list<_CharT> __l)
    00276     {
    00277       _M_base() += __l;
    00278       this->_M_invalidate_all();
    00279       return *this;
    00280     }
    00281 #endif // __GXX_EXPERIMENTAL_CXX0X__
    00282
    00283     basic_string&
    00284     append(const basic_string& __str)
    00285     {
    00286       _Base::append(__str);
    00287       this->_M_invalidate_all();
    00288       return *this;
    00289     }
    00290
    00291     basic_string&
    00292     append(const basic_string& __str, size_type __pos, size_type __n)
    00293     {
    00294       _Base::append(__str, __pos, __n);
    00295       this->_M_invalidate_all();
    00296       return *this;
    00297     }
    00298
    00299     basic_string&
    00300     append(const _CharT* __s, size_type __n)
    00301     {
    00302       __glibcxx_check_string_len(__s, __n);
    00303       _Base::append(__s, __n);
    00304       this->_M_invalidate_all();
    00305       return *this;
    00306     }
    00307
    00308     basic_string&
    00309     append(const _CharT* __s)
    00310     {
    00311       __glibcxx_check_string(__s);
    00312       _Base::append(__s);
    00313       this->_M_invalidate_all();
    00314       return *this;
    00315     }
    00316
    00317     basic_string&
    00318     append(size_type __n, _CharT __c)
    00319     {
    00320       _Base::append(__n, __c);
    00321       this->_M_invalidate_all();
    00322       return *this;
    00323     }
    00324
    00325     template<typename _InputIterator>
    00326       basic_string&
    00327       append(_InputIterator __first, _InputIterator __last)
    00328       {
    00329     __glibcxx_check_valid_range(__first, __last);
    00330     _Base::append(__first, __last);
    00331     this->_M_invalidate_all();
    00332     return *this;
    00333       }
    00334
    00335     // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00336     // 7. string clause minor problems
    00337     void
    00338     push_back(_CharT __c)
    00339     {
    00340       _Base::push_back(__c);
    00341       this->_M_invalidate_all();
    00342     }
    00343
    00344     basic_string&
    00345     assign(const basic_string& __x)
    00346     {
    00347       _Base::assign(__x);
    00348       this->_M_invalidate_all();
    00349       return *this;
    00350     }
    00351
    00352     basic_string&
    00353     assign(const basic_string& __str, size_type __pos, size_type __n)
    00354     {
    00355       _Base::assign(__str, __pos, __n);
    00356       this->_M_invalidate_all();
    00357       return *this;
    00358     }
    00359
    00360     basic_string&
    00361     assign(const _CharT* __s, size_type __n)
    00362     {
    00363       __glibcxx_check_string_len(__s, __n);
    00364       _Base::assign(__s, __n);
    00365       this->_M_invalidate_all();
    00366       return *this;
    00367     }
    00368
    00369     basic_string&
    00370     assign(const _CharT* __s)
    00371     {
    00372       __glibcxx_check_string(__s);
    00373       _Base::assign(__s);
    00374       this->_M_invalidate_all();
    00375       return *this;
    00376     }
    00377
    00378     basic_string&
    00379     assign(size_type __n, _CharT __c)
    00380     {
    00381       _Base::assign(__n, __c);
    00382       this->_M_invalidate_all();
    00383       return *this;
    00384     }
    00385
    00386     template<typename _InputIterator>
    00387       basic_string&
    00388       assign(_InputIterator __first, _InputIterator __last)
    00389       {
    00390     __glibcxx_check_valid_range(__first, __last);
    00391     _Base::assign(__first, __last);
    00392     this->_M_invalidate_all();
    00393     return *this;
    00394       }
    00395
    00396 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00397     basic_string&
    00398     assign(initializer_list<_CharT> __l)
    00399     {
    00400       _Base::assign(__l);
    00401       this->_M_invalidate_all();
    00402       return *this;
    00403     }
    00404 #endif // __GXX_EXPERIMENTAL_CXX0X__
    00405
    00406     basic_string&
    00407     insert(size_type __pos1, const basic_string& __str)
    00408     {
    00409       _Base::insert(__pos1, __str);
    00410       this->_M_invalidate_all();
    00411       return *this;
    00412     }
    00413
    00414     basic_string&
    00415     insert(size_type __pos1, const basic_string& __str,
    00416        size_type __pos2, size_type __n)
    00417     {
    00418       _Base::insert(__pos1, __str, __pos2, __n);
    00419       this->_M_invalidate_all();
    00420       return *this;
    00421     }
    00422
    00423     basic_string&
    00424     insert(size_type __pos, const _CharT* __s, size_type __n)
    00425     {
    00426       __glibcxx_check_string(__s);
    00427       _Base::insert(__pos, __s, __n);
    00428       this->_M_invalidate_all();
    00429       return *this;
    00430     }
    00431
    00432     basic_string&
    00433     insert(size_type __pos, const _CharT* __s)
    00434     {
    00435       __glibcxx_check_string(__s);
    00436       _Base::insert(__pos, __s);
    00437       this->_M_invalidate_all();
    00438       return *this;
    00439     }
    00440
    00441     basic_string&
    00442     insert(size_type __pos, size_type __n, _CharT __c)
    00443     {
    00444       _Base::insert(__pos, __n, __c);
    00445       this->_M_invalidate_all();
    00446       return *this;
    00447     }
    00448
    00449     iterator
    00450     insert(iterator __p, _CharT __c)
    00451     {
    00452       __glibcxx_check_insert(__p);
    00453       typename _Base::iterator __res = _Base::insert(__p.base(), __c);
    00454       this->_M_invalidate_all();
    00455       return iterator(__res, this);
    00456     }
    00457
    00458     void
    00459     insert(iterator __p, size_type __n, _CharT __c)
    00460     {
    00461       __glibcxx_check_insert(__p);
    00462       _Base::insert(__p.base(), __n, __c);
    00463       this->_M_invalidate_all();
    00464     }
    00465
    00466     template<typename _InputIterator>
    00467       void
    00468       insert(iterator __p, _InputIterator __first, _InputIterator __last)
    00469       {
    00470     __glibcxx_check_insert_range(__p, __first, __last);
    00471     _Base::insert(__p.base(), __first, __last);
    00472     this->_M_invalidate_all();
    00473       }
    00474
    00475 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00476     void
    00477     insert(iterator __p, initializer_list<_CharT> __l)
    00478     {
    00479       _Base::insert(__p, __l);
    00480       this->_M_invalidate_all();
    00481     }
    00482 #endif // __GXX_EXPERIMENTAL_CXX0X__
    00483
    00484     basic_string&
    00485     erase(size_type __pos = 0, size_type __n = _Base::npos)
    00486     {
    00487       _Base::erase(__pos, __n);
    00488       this->_M_invalidate_all();
    00489       return *this;
    00490     }
    00491
    00492     iterator
    00493     erase(iterator __position)
    00494     {
    00495       __glibcxx_check_erase(__position);
    00496       typename _Base::iterator __res = _Base::erase(__position.base());
    00497       this->_M_invalidate_all();
    00498       return iterator(__res, this);
    00499     }
    00500
    00501     iterator
    00502     erase(iterator __first, iterator __last)
    00503     {
    00504       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00505       // 151. can't currently clear() empty container
    00506       __glibcxx_check_erase_range(__first, __last);
    00507       typename _Base::iterator __res = _Base::erase(__first.base(),
    00508                                __last.base());
    00509       this->_M_invalidate_all();
    00510       return iterator(__res, this);
    00511     }
    00512
    00513     basic_string&
    00514     replace(size_type __pos1, size_type __n1, const basic_string& __str)
    00515     {
    00516       _Base::replace(__pos1, __n1, __str);
    00517       this->_M_invalidate_all();
    00518       return *this;
    00519     }
    00520
    00521     basic_string&
    00522     replace(size_type __pos1, size_type __n1, const basic_string& __str,
    00523         size_type __pos2, size_type __n2)
    00524     {
    00525       _Base::replace(__pos1, __n1, __str, __pos2, __n2);
    00526       this->_M_invalidate_all();
    00527       return *this;
    00528     }
    00529
    00530     basic_string&
    00531     replace(size_type __pos, size_type __n1, const _CharT* __s,
    00532         size_type __n2)
    00533     {
    00534       __glibcxx_check_string_len(__s, __n2);
    00535       _Base::replace(__pos, __n1, __s, __n2);
    00536       this->_M_invalidate_all();
    00537       return *this;
    00538     }
    00539
    00540     basic_string&
    00541     replace(size_type __pos, size_type __n1, const _CharT* __s)
    00542     {
    00543       __glibcxx_check_string(__s);
    00544       _Base::replace(__pos, __n1, __s);
    00545       this->_M_invalidate_all();
    00546       return *this;
    00547     }
    00548
    00549     basic_string&
    00550     replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
    00551     {
    00552       _Base::replace(__pos, __n1, __n2, __c);
    00553       this->_M_invalidate_all();
    00554       return *this;
    00555     }
    00556
    00557     basic_string&
    00558     replace(iterator __i1, iterator __i2, const basic_string& __str)
    00559     {
    00560       __glibcxx_check_erase_range(__i1, __i2);
    00561       _Base::replace(__i1.base(), __i2.base(), __str);
    00562       this->_M_invalidate_all();
    00563       return *this;
    00564     }
    00565
    00566     basic_string&
    00567     replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
    00568     {
    00569       __glibcxx_check_erase_range(__i1, __i2);
    00570       __glibcxx_check_string_len(__s, __n);
    00571       _Base::replace(__i1.base(), __i2.base(), __s, __n);
    00572       this->_M_invalidate_all();
    00573       return *this;
    00574     }
    00575
    00576     basic_string&
    00577     replace(iterator __i1, iterator __i2, const _CharT* __s)
    00578     {
    00579       __glibcxx_check_erase_range(__i1, __i2);
    00580       __glibcxx_check_string(__s);
    00581       _Base::replace(__i1.base(), __i2.base(), __s);
    00582       this->_M_invalidate_all();
    00583       return *this;
    00584     }
    00585
    00586     basic_string&
    00587     replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
    00588     {
    00589       __glibcxx_check_erase_range(__i1, __i2);
    00590       _Base::replace(__i1.base(), __i2.base(), __n, __c);
    00591       this->_M_invalidate_all();
    00592       return *this;
    00593     }
    00594
    00595     template<typename _InputIterator>
    00596       basic_string&
    00597       replace(iterator __i1, iterator __i2,
    00598           _InputIterator __j1, _InputIterator __j2)
    00599       {
    00600     __glibcxx_check_erase_range(__i1, __i2);
    00601     __glibcxx_check_valid_range(__j1, __j2);
    00602     _Base::replace(__i1.base(), __i2.base(), __j1, __j2);
    00603     this->_M_invalidate_all();
    00604     return *this;
    00605       }
    00606
    00607 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00608       basic_string& replace(iterator __i1, iterator __i2,
    00609                 initializer_list<_CharT> __l)
    00610       {
    00611     __glibcxx_check_erase_range(__i1, __i2);
    00612     _Base::replace(__i1.base(), __i2.base(), __l);
    00613     this->_M_invalidate_all();
    00614     return *this;
    00615       }
    00616 #endif // __GXX_EXPERIMENTAL_CXX0X__
    00617
    00618     size_type
    00619     copy(_CharT* __s, size_type __n, size_type __pos = 0) const
    00620     {
    00621       __glibcxx_check_string_len(__s, __n);
    00622       return _Base::copy(__s, __n, __pos);
    00623     }
    00624
    00625     void
    00626     swap(basic_string<_CharT,_Traits,_Allocator>& __x)
    00627     {
    00628       _Base::swap(__x);
    00629       this->_M_swap(__x);
    00630       this->_M_invalidate_all();
    00631       __x._M_invalidate_all();
    00632     }
    00633
    00634     // 21.3.6 string operations:
    00635     const _CharT*
    00636     c_str() const
    00637     {
    00638       const _CharT* __res = _Base::c_str();
    00639       this->_M_invalidate_all();
    00640       return __res;
    00641     }
    00642
    00643     const _CharT*
    00644     data() const
    00645     {
    00646       const _CharT* __res = _Base::data();
    00647       this->_M_invalidate_all();
    00648       return __res;
    00649     }
    00650
    00651     using _Base::get_allocator;
    00652
    00653     size_type
    00654     find(const basic_string& __str, size_type __pos = 0) const
    00655     { return _Base::find(__str, __pos); }
    00656
    00657     size_type
    00658     find(const _CharT* __s, size_type __pos, size_type __n) const
    00659     {
    00660       __glibcxx_check_string(__s);
    00661       return _Base::find(__s, __pos, __n);
    00662     }
    00663
    00664     size_type
    00665     find(const _CharT* __s, size_type __pos = 0) const
    00666     {
    00667       __glibcxx_check_string(__s);
    00668       return _Base::find(__s, __pos);
    00669     }
    00670
    00671     size_type
    00672     find(_CharT __c, size_type __pos = 0) const
    00673     { return _Base::find(__c, __pos); }
    00674
    00675     size_type
    00676     rfind(const basic_string& __str, size_type __pos = _Base::npos) const
    00677     { return _Base::rfind(__str, __pos); }
    00678
    00679     size_type
    00680     rfind(const _CharT* __s, size_type __pos, size_type __n) const
    00681     {
    00682       __glibcxx_check_string_len(__s, __n);
    00683       return _Base::rfind(__s, __pos, __n);
    00684     }
    00685
    00686     size_type
    00687     rfind(const _CharT* __s, size_type __pos = _Base::npos) const
    00688     {
    00689       __glibcxx_check_string(__s);
    00690       return _Base::rfind(__s, __pos);
    00691     }
    00692
    00693     size_type
    00694     rfind(_CharT __c, size_type __pos = _Base::npos) const
    00695     { return _Base::rfind(__c, __pos); }
    00696
    00697     size_type
    00698     find_first_of(const basic_string& __str, size_type __pos = 0) const
    00699     { return _Base::find_first_of(__str, __pos); }
    00700
    00701     size_type
    00702     find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
    00703     {
    00704       __glibcxx_check_string(__s);
    00705       return _Base::find_first_of(__s, __pos, __n);
    00706     }
    00707
    00708     size_type
    00709     find_first_of(const _CharT* __s, size_type __pos = 0) const
    00710     {
    00711       __glibcxx_check_string(__s);
    00712       return _Base::find_first_of(__s, __pos);
    00713     }
    00714
    00715     size_type
    00716     find_first_of(_CharT __c, size_type __pos = 0) const
    00717     { return _Base::find_first_of(__c, __pos); }
    00718
    00719     size_type
    00720     find_last_of(const basic_string& __str,
    00721          size_type __pos = _Base::npos) const
    00722     { return _Base::find_last_of(__str, __pos); }
    00723
    00724     size_type
    00725     find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
    00726     {
    00727       __glibcxx_check_string(__s);
    00728       return _Base::find_last_of(__s, __pos, __n);
    00729     }
    00730
    00731     size_type
    00732     find_last_of(const _CharT* __s, size_type __pos = _Base::npos) const
    00733     {
    00734       __glibcxx_check_string(__s);
    00735       return _Base::find_last_of(__s, __pos);
    00736     }
    00737
    00738     size_type
    00739     find_last_of(_CharT __c, size_type __pos = _Base::npos) const
    00740     { return _Base::find_last_of(__c, __pos); }
    00741
    00742     size_type
    00743     find_first_not_of(const basic_string& __str, size_type __pos = 0) const
    00744     { return _Base::find_first_not_of(__str, __pos); }
    00745
    00746     size_type
    00747     find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    00748     {
    00749       __glibcxx_check_string_len(__s, __n);
    00750       return _Base::find_first_not_of(__s, __pos, __n);
    00751     }
    00752
    00753     size_type
    00754     find_first_not_of(const _CharT* __s, size_type __pos = 0) const
    00755     {
    00756       __glibcxx_check_string(__s);
    00757       return _Base::find_first_not_of(__s, __pos);
    00758     }
    00759
    00760     size_type
    00761     find_first_not_of(_CharT __c, size_type __pos = 0) const
    00762     { return _Base::find_first_not_of(__c, __pos); }
    00763
    00764     size_type
    00765     find_last_not_of(const basic_string& __str,
    00766                   size_type __pos = _Base::npos) const
    00767     { return _Base::find_last_not_of(__str, __pos); }
    00768
    00769     size_type
    00770     find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    00771     {
    00772       __glibcxx_check_string(__s);
    00773       return _Base::find_last_not_of(__s, __pos, __n);
    00774     }
    00775
    00776     size_type
    00777     find_last_not_of(const _CharT* __s, size_type __pos = _Base::npos) const
    00778     {
    00779       __glibcxx_check_string(__s);
    00780       return _Base::find_last_not_of(__s, __pos);
    00781     }
    00782
    00783     size_type
    00784     find_last_not_of(_CharT __c, size_type __pos = _Base::npos) const
    00785     { return _Base::find_last_not_of(__c, __pos); }
    00786
    00787     basic_string
    00788     substr(size_type __pos = 0, size_type __n = _Base::npos) const
    00789     { return basic_string(_Base::substr(__pos, __n)); }
    00790
    00791     int
    00792     compare(const basic_string& __str) const
    00793     { return _Base::compare(__str); }
    00794
    00795     int
    00796     compare(size_type __pos1, size_type __n1,
    00797           const basic_string& __str) const
    00798     { return _Base::compare(__pos1, __n1, __str); }
    00799
    00800     int
    00801     compare(size_type __pos1, size_type __n1, const basic_string& __str,
    00802           size_type __pos2, size_type __n2) const
    00803     { return _Base::compare(__pos1, __n1, __str, __pos2, __n2); }
    00804
    00805     int
    00806     compare(const _CharT* __s) const
    00807     {
    00808       __glibcxx_check_string(__s);
    00809       return _Base::compare(__s);
    00810     }
    00811
    00812     //  _GLIBCXX_RESOLVE_LIB_DEFECTS
    00813     //  5. string::compare specification questionable
    00814     int
    00815     compare(size_type __pos1, size_type __n1, const _CharT* __s) const
    00816     {
    00817       __glibcxx_check_string(__s);
    00818       return _Base::compare(__pos1, __n1, __s);
    00819     }
    00820
    00821     //  _GLIBCXX_RESOLVE_LIB_DEFECTS
    00822     //  5. string::compare specification questionable
    00823     int
    00824     compare(size_type __pos1, size_type __n1,const _CharT* __s,
    00825           size_type __n2) const
    00826     {
    00827       __glibcxx_check_string_len(__s, __n2);
    00828       return _Base::compare(__pos1, __n1, __s, __n2);
    00829     }
    00830
    00831     _Base&
    00832     _M_base() { return *this; }
    00833
    00834     const _Base&
    00835     _M_base() const { return *this; }
    00836
    00837     using _Safe_base::_M_invalidate_all;
    00838   };
    00839
    00840   template<typename _CharT, typename _Traits, typename _Allocator>
    00841     inline basic_string<_CharT,_Traits,_Allocator>
    00842     operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00843           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00844     { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
    00845
    00846   template<typename _CharT, typename _Traits, typename _Allocator>
    00847     inline basic_string<_CharT,_Traits,_Allocator>
    00848     operator+(const _CharT* __lhs,
    00849           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00850     {
    00851       __glibcxx_check_string(__lhs);
    00852       return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
    00853     }
    00854
    00855   template<typename _CharT, typename _Traits, typename _Allocator>
    00856     inline basic_string<_CharT,_Traits,_Allocator>
    00857     operator+(_CharT __lhs,
    00858           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00859     { return basic_string<_CharT,_Traits,_Allocator>(1, __lhs) += __rhs; }
    00860
    00861   template<typename _CharT, typename _Traits, typename _Allocator>
    00862     inline basic_string<_CharT,_Traits,_Allocator>
    00863     operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00864           const _CharT* __rhs)
    00865     {
    00866       __glibcxx_check_string(__rhs);
    00867       return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
    00868     }
    00869
    00870   template<typename _CharT, typename _Traits, typename _Allocator>
    00871     inline basic_string<_CharT,_Traits,_Allocator>
    00872     operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00873           _CharT __rhs)
    00874     { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
    00875
    00876   template<typename _CharT, typename _Traits, typename _Allocator>
    00877     inline bool
    00878     operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00879            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00880     { return __lhs._M_base() == __rhs._M_base(); }
    00881
    00882   template<typename _CharT, typename _Traits, typename _Allocator>
    00883     inline bool
    00884     operator==(const _CharT* __lhs,
    00885            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00886     {
    00887       __glibcxx_check_string(__lhs);
    00888       return __lhs == __rhs._M_base();
    00889     }
    00890
    00891   template<typename _CharT, typename _Traits, typename _Allocator>
    00892     inline bool
    00893     operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00894            const _CharT* __rhs)
    00895     {
    00896       __glibcxx_check_string(__rhs);
    00897       return __lhs._M_base() == __rhs;
    00898     }
    00899
    00900   template<typename _CharT, typename _Traits, typename _Allocator>
    00901     inline bool
    00902     operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00903            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00904     { return __lhs._M_base() != __rhs._M_base(); }
    00905
    00906   template<typename _CharT, typename _Traits, typename _Allocator>
    00907     inline bool
    00908     operator!=(const _CharT* __lhs,
    00909            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00910     {
    00911       __glibcxx_check_string(__lhs);
    00912       return __lhs != __rhs._M_base();
    00913     }
    00914
    00915   template<typename _CharT, typename _Traits, typename _Allocator>
    00916     inline bool
    00917     operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00918            const _CharT* __rhs)
    00919     {
    00920       __glibcxx_check_string(__rhs);
    00921       return __lhs._M_base() != __rhs;
    00922     }
    00923
    00924   template<typename _CharT, typename _Traits, typename _Allocator>
    00925     inline bool
    00926     operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00927           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00928     { return __lhs._M_base() < __rhs._M_base(); }
    00929
    00930   template<typename _CharT, typename _Traits, typename _Allocator>
    00931     inline bool
    00932     operator<(const _CharT* __lhs,
    00933           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00934     {
    00935       __glibcxx_check_string(__lhs);
    00936       return __lhs < __rhs._M_base();
    00937     }
    00938
    00939   template<typename _CharT, typename _Traits, typename _Allocator>
    00940     inline bool
    00941     operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00942           const _CharT* __rhs)
    00943     {
    00944       __glibcxx_check_string(__rhs);
    00945       return __lhs._M_base() < __rhs;
    00946     }
    00947
    00948   template<typename _CharT, typename _Traits, typename _Allocator>
    00949     inline bool
    00950     operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00951            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00952     { return __lhs._M_base() <= __rhs._M_base(); }
    00953
    00954   template<typename _CharT, typename _Traits, typename _Allocator>
    00955     inline bool
    00956     operator<=(const _CharT* __lhs,
    00957            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00958     {
    00959       __glibcxx_check_string(__lhs);
    00960       return __lhs <= __rhs._M_base();
    00961     }
    00962
    00963   template<typename _CharT, typename _Traits, typename _Allocator>
    00964     inline bool
    00965     operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00966            const _CharT* __rhs)
    00967     {
    00968       __glibcxx_check_string(__rhs);
    00969       return __lhs._M_base() <= __rhs;
    00970     }
    00971
    00972   template<typename _CharT, typename _Traits, typename _Allocator>
    00973     inline bool
    00974     operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00975            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00976     { return __lhs._M_base() >= __rhs._M_base(); }
    00977
    00978   template<typename _CharT, typename _Traits, typename _Allocator>
    00979     inline bool
    00980     operator>=(const _CharT* __lhs,
    00981            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    00982     {
    00983       __glibcxx_check_string(__lhs);
    00984       return __lhs >= __rhs._M_base();
    00985     }
    00986
    00987   template<typename _CharT, typename _Traits, typename _Allocator>
    00988     inline bool
    00989     operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00990            const _CharT* __rhs)
    00991     {
    00992       __glibcxx_check_string(__rhs);
    00993       return __lhs._M_base() >= __rhs;
    00994     }
    00995
    00996   template<typename _CharT, typename _Traits, typename _Allocator>
    00997     inline bool
    00998     operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    00999           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    01000     { return __lhs._M_base() > __rhs._M_base(); }
    01001
    01002   template<typename _CharT, typename _Traits, typename _Allocator>
    01003     inline bool
    01004     operator>(const _CharT* __lhs,
    01005           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
    01006     {
    01007       __glibcxx_check_string(__lhs);
    01008       return __lhs > __rhs._M_base();
    01009     }
    01010
    01011   template<typename _CharT, typename _Traits, typename _Allocator>
    01012     inline bool
    01013     operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
    01014           const _CharT* __rhs)
    01015     {
    01016       __glibcxx_check_string(__rhs);
    01017       return __lhs._M_base() > __rhs;
    01018     }
    01019
    01020   // 21.3.7.8:
    01021   template<typename _CharT, typename _Traits, typename _Allocator>
    01022     inline void
    01023     swap(basic_string<_CharT,_Traits,_Allocator>& __lhs,
    01024      basic_string<_CharT,_Traits,_Allocator>& __rhs)
    01025     { __lhs.swap(__rhs); }
    01026
    01027   template<typename _CharT, typename _Traits, typename _Allocator>
    01028     std::basic_ostream<_CharT, _Traits>&
    01029     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
    01030            const basic_string<_CharT, _Traits, _Allocator>& __str)
    01031     { return __os << __str._M_base(); }
    01032
    01033   template<typename _CharT, typename _Traits, typename _Allocator>
    01034     std::basic_istream<_CharT,_Traits>&
    01035     operator>>(std::basic_istream<_CharT,_Traits>& __is,
    01036            basic_string<_CharT,_Traits,_Allocator>& __str)
    01037     {
    01038       std::basic_istream<_CharT,_Traits>& __res = __is >> __str._M_base();
    01039       __str._M_invalidate_all();
    01040       return __res;
    01041     }
    01042
    01043   template<typename _CharT, typename _Traits, typename _Allocator>
    01044     std::basic_istream<_CharT,_Traits>&
    01045     getline(std::basic_istream<_CharT,_Traits>& __is,
    01046         basic_string<_CharT,_Traits,_Allocator>& __str, _CharT __delim)
    01047     {
    01048       std::basic_istream<_CharT,_Traits>& __res = getline(__is,
    01049                               __str._M_base(),
    01050                             __delim);
    01051       __str._M_invalidate_all();
    01052       return __res;
    01053     }
    01054
    01055   template<typename _CharT, typename _Traits, typename _Allocator>
    01056     std::basic_istream<_CharT,_Traits>&
    01057     getline(std::basic_istream<_CharT,_Traits>& __is,
    01058         basic_string<_CharT,_Traits,_Allocator>& __str)
    01059     {
    01060       std::basic_istream<_CharT,_Traits>& __res = getline(__is,
    01061                               __str._M_base());
    01062       __str._M_invalidate_all();
    01063       return __res;
    01064     }
    01065
    01066   typedef basic_string<char>    string;
    01067
    01068 #ifdef _GLIBCXX_USE_WCHAR_T
    01069   typedef basic_string<wchar_t> wstring;
    01070 #endif
    01071
    01072 } // namespace __gnu_debug
    01073
    01074 #endif