home *** CD-ROM | disk | FTP | other *** search
/ Beginning C++ Through Gam…rogramming (2nd Edition) / BCGP2E.ISO / bloodshed / devcpp-4.9.9.2_setup.exe / string < prev    next >
Text File  |  2005-01-29  |  29KB  |  1,002 lines
  1. // Debugging string implementation -*- C++ -*-
  2.  
  3. // Copyright (C) 2003
  4. // Free Software Foundation, Inc.
  5. //
  6. // This file is part of the GNU ISO C++ Library.  This library is free
  7. // software; you can redistribute it and/or modify it under the
  8. // terms of the GNU General Public License as published by the
  9. // Free Software Foundation; either version 2, or (at your option)
  10. // any later version.
  11.  
  12. // This library is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. // GNU General Public License for more details.
  16.  
  17. // You should have received a copy of the GNU General Public License along
  18. // with this library; see the file COPYING.  If not, write to the Free
  19. // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20. // USA.
  21.  
  22. // As a special exception, you may use this file as part of a free software
  23. // library without restriction.  Specifically, if other files instantiate
  24. // templates or use macros or inline functions from this file, or you compile
  25. // this file and link it with other files to produce an executable, this
  26. // file does not by itself cause the resulting executable to be covered by
  27. // the GNU General Public License.  This exception does not however
  28. // invalidate any other reasons why the executable file might be covered by
  29. // the GNU General Public License.
  30.  
  31. #ifndef _GLIBCXX_DEBUG_STRING
  32. #define _GLIBCXX_DEBUG_STRING 1
  33.  
  34. #include <string>
  35. #include <debug/safe_sequence.h>
  36. #include <debug/safe_iterator.h>
  37.  
  38. namespace __gnu_debug
  39. {
  40.   template<typename _CharT, typename _Traits, typename _Allocator>
  41.     class basic_string
  42.     : public std::basic_string<_CharT, _Traits, _Allocator>,
  43.       public __gnu_debug::_Safe_sequence<basic_string<_CharT, _Traits,
  44.                               _Allocator> >
  45.     {
  46.       typedef std::basic_string<_CharT, _Traits, _Allocator> _Base;
  47.       typedef __gnu_debug::_Safe_sequence<basic_string>     _Safe_base;
  48.  
  49.   public:
  50.     // types:
  51.     typedef _Traits                       traits_type;
  52.     typedef typename _Traits::char_type               value_type;
  53.     typedef _Allocator                       allocator_type;
  54.     typedef typename _Allocator::size_type             size_type;
  55.     typedef typename _Allocator::difference_type       difference_type;
  56.     typedef typename _Allocator::reference             reference;
  57.     typedef typename _Allocator::const_reference       const_reference;
  58.     typedef typename _Allocator::pointer               pointer;
  59.     typedef typename _Allocator::const_pointer         const_pointer;
  60.  
  61.     typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, basic_string>
  62.                                                        iterator;
  63.     typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
  64.                                          basic_string> const_iterator;
  65.  
  66.     typedef std::reverse_iterator<iterator>            reverse_iterator;
  67.     typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;
  68.  
  69.     using _Base::npos;
  70.  
  71.     // 21.3.1 construct/copy/destroy:
  72.     explicit basic_string(const _Allocator& __a = _Allocator())
  73.     : _Base(__a)
  74.     { }
  75.  
  76.     // Provides conversion from a release-mode string to a debug-mode string
  77.     basic_string(const _Base& __base) : _Base(__base), _Safe_base() { }
  78.  
  79.     // _GLIBCXX_RESOLVE_LIB_DEFECTS
  80.     // 42. string ctors specify wrong default allocator
  81.     basic_string(const basic_string& __str)
  82.     : _Base(__str, 0, _Base::npos, __str.get_allocator()), _Safe_base()
  83.     { }
  84.  
  85.     // _GLIBCXX_RESOLVE_LIB_DEFECTS
  86.     // 42. string ctors specify wrong default allocator
  87.     basic_string(const basic_string& __str, size_type __pos,
  88.            size_type __n = _Base::npos,
  89.            const _Allocator& __a = _Allocator())
  90.     : _Base(__str, __pos, __n, __a)
  91.     { }
  92.  
  93.     basic_string(const _CharT* __s, size_type __n,
  94.            const _Allocator& __a = _Allocator())
  95.     : _Base(__gnu_debug::__check_string(__s, __n), __n, __a)
  96.     { }
  97.  
  98.     basic_string(const _CharT* __s, const _Allocator& __a = _Allocator())
  99.     : _Base(__gnu_debug::__check_string(__s), __a)
  100.     { this->assign(__s); }
  101.  
  102.     basic_string(size_type __n, _CharT __c,
  103.            const _Allocator& __a = _Allocator())
  104.     : _Base(__n, __c, __a)
  105.     { }
  106.  
  107.     template<typename _InputIterator>
  108.       basic_string(_InputIterator __begin, _InputIterator __end,
  109.              const _Allocator& __a = _Allocator())
  110.       : _Base(__gnu_debug::__check_valid_range(__begin, __end), __end, __a)
  111.       { }
  112.  
  113.     ~basic_string() { }
  114.  
  115.     basic_string&
  116.     operator=(const basic_string& __str)
  117.     {
  118.       *static_cast<_Base*>(this) = __str;
  119.       this->_M_invalidate_all();
  120.       return *this;
  121.     }
  122.  
  123.     basic_string&
  124.     operator=(const _CharT* __s)
  125.     {
  126.       __glibcxx_check_string(__s);
  127.       *static_cast<_Base*>(this) = __s;
  128.       this->_M_invalidate_all();
  129.       return *this;
  130.     }
  131.  
  132.     basic_string&
  133.     operator=(_CharT __c)
  134.     {
  135.       *static_cast<_Base*>(this) = __c;
  136.       this->_M_invalidate_all();
  137.       return *this;
  138.     }
  139.  
  140.     // 21.3.2 iterators:
  141.     iterator
  142.     begin()
  143.     { return iterator(_Base::begin(), this); }
  144.  
  145.     const_iterator
  146.     begin() const
  147.     { return const_iterator(_Base::begin(), this); }
  148.  
  149.     iterator
  150.     end()
  151.     { return iterator(_Base::end(), this); }
  152.  
  153.     const_iterator
  154.     end() const
  155.     { return const_iterator(_Base::end(), this); }
  156.  
  157.     reverse_iterator
  158.     rbegin()
  159.     { return reverse_iterator(end()); }
  160.  
  161.     const_reverse_iterator
  162.     rbegin() const
  163.     { return const_reverse_iterator(end()); }
  164.  
  165.     reverse_iterator
  166.     rend()
  167.     { return reverse_iterator(begin()); }
  168.  
  169.     const_reverse_iterator
  170.     rend() const
  171.     { return const_reverse_iterator(begin()); }
  172.  
  173.     // 21.3.3 capacity:
  174.     using _Base::size;
  175.     using _Base::length;
  176.     using _Base::max_size;
  177.  
  178.     void
  179.     resize(size_type __n, _CharT __c)
  180.     {
  181.       _Base::resize(__n, __c);
  182.       this->_M_invalidate_all();
  183.     }
  184.  
  185.     void
  186.     resize(size_type __n)
  187.     { this->resize(__n, _CharT()); }
  188.  
  189.     using _Base::capacity;
  190.     using _Base::reserve;
  191.  
  192.     void
  193.     clear()
  194.     {
  195.       _Base::clear();
  196.       this->_M_invalidate_all();
  197.     }
  198.  
  199.     using _Base::empty;
  200.  
  201.     // 21.3.4 element access:
  202.     const_reference
  203.     operator[](size_type __pos) const
  204.     {
  205.       _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
  206.                 _M_message(::__gnu_debug::__msg_subscript_oob)
  207.                 ._M_sequence(*this, "this")
  208.                 ._M_integer(__pos, "__pos")
  209.                 ._M_integer(this->size(), "size"));
  210.       return _M_base()[__pos];
  211.     }
  212.  
  213.     reference
  214.     operator[](size_type __pos)
  215.     {
  216.       __glibcxx_check_subscript(__pos);
  217.       return _M_base()[__pos];
  218.     }
  219.  
  220.     using _Base::at;
  221.  
  222.     // 21.3.5 modifiers:
  223.     basic_string&
  224.     operator+=(const basic_string& __str)
  225.     {
  226.       _M_base() += __str;
  227.       this->_M_invalidate_all();
  228.       return *this;
  229.     }
  230.  
  231.     basic_string&
  232.     operator+=(const _CharT* __s)
  233.     {
  234.       __glibcxx_check_string(__s);
  235.       _M_base() += __s;
  236.       this->_M_invalidate_all();
  237.       return *this;
  238.     }
  239.  
  240.     basic_string&
  241.     operator+=(_CharT __c)
  242.     {
  243.       _M_base() += __c;
  244.       this->_M_invalidate_all();
  245.       return *this;
  246.     }
  247.  
  248.     basic_string&
  249.     append(const basic_string& __str)
  250.     {
  251.       _Base::append(__str);
  252.       this->_M_invalidate_all();
  253.       return *this;
  254.     }
  255.  
  256.     basic_string&
  257.     append(const basic_string& __str, size_type __pos, size_type __n)
  258.     {
  259.       _Base::append(__str, __pos, __n);
  260.       this->_M_invalidate_all();
  261.       return *this;
  262.     }
  263.  
  264.     basic_string&
  265.     append(const _CharT* __s, size_type __n)
  266.     {
  267.       __glibcxx_check_string_len(__s, __n);
  268.       _Base::append(__s, __n);
  269.       this->_M_invalidate_all();
  270.       return *this;
  271.     }
  272.  
  273.     basic_string&
  274.     append(const _CharT* __s)
  275.     {
  276.       __glibcxx_check_string(__s);
  277.       _Base::append(__s);
  278.       this->_M_invalidate_all();
  279.       return *this;
  280.     }
  281.  
  282.     basic_string&
  283.     append(size_type __n, _CharT __c)
  284.     {
  285.       _Base::append(__n, __c);
  286.       this->_M_invalidate_all();
  287.       return *this;
  288.     }
  289.  
  290.     template<typename _InputIterator>
  291.       basic_string&
  292.       append(_InputIterator __first, _InputIterator __last)
  293.       {
  294.     __glibcxx_check_valid_range(__first, __last);
  295.     _Base::append(__first, __last);
  296.     this->_M_invalidate_all();
  297.     return *this;
  298.       }
  299.  
  300.     // _GLIBCXX_RESOLVE_LIB_DEFECTS
  301.     // 7. string clause minor problems
  302.     void
  303.     push_back(_CharT __c)
  304.     {
  305.       _Base::push_back(__c);
  306.       this->_M_invalidate_all();
  307.     }
  308.  
  309.     basic_string&
  310.     assign(const basic_string& __x)
  311.     {
  312.       _Base::assign(__x);
  313.       this->_M_invalidate_all();
  314.       return *this;
  315.     }
  316.  
  317.     basic_string&
  318.     assign(const basic_string& __str, size_type __pos, size_type __n)
  319.     {
  320.       _Base::assign(__str, __pos, __n);
  321.       this->_M_invalidate_all();
  322.       return *this;
  323.     }
  324.  
  325.     basic_string&
  326.     assign(const _CharT* __s, size_type __n)
  327.     {
  328.       __glibcxx_check_string_len(__s, __n);
  329.       _Base::assign(__s, __n);
  330.       this->_M_invalidate_all();
  331.       return *this;
  332.     }
  333.  
  334.     basic_string&
  335.     assign(const _CharT* __s)
  336.     {
  337.       __glibcxx_check_string(__s);
  338.       _Base::assign(__s);
  339.       this->_M_invalidate_all();
  340.       return *this;
  341.     }
  342.  
  343.     basic_string&
  344.     assign(size_type __n, _CharT __c)
  345.     {
  346.       _Base::assign(__n, __c);
  347.       this->_M_invalidate_all();
  348.       return *this;
  349.     }
  350.  
  351.     template<typename _InputIterator>
  352.       basic_string&
  353.       assign(_InputIterator __first, _InputIterator __last)
  354.       {
  355.     __glibcxx_check_valid_range(__first, __last);
  356.     _Base::assign(__first, __last);
  357.     this->_M_invalidate_all();
  358.     return *this;
  359.       }
  360.  
  361.     basic_string&
  362.     insert(size_type __pos1, const basic_string& __str)
  363.     {
  364.       _Base::insert(__pos1, __str);
  365.       this->_M_invalidate_all();
  366.       return *this;
  367.     }
  368.  
  369.     basic_string&
  370.     insert(size_type __pos1, const basic_string& __str,
  371.        size_type __pos2, size_type __n)
  372.     {
  373.       _Base::insert(__pos1, __str, __pos2, __n);
  374.       this->_M_invalidate_all();
  375.       return *this;
  376.     }
  377.  
  378.     basic_string&
  379.     insert(size_type __pos, const _CharT* __s, size_type __n)
  380.     {
  381.       __glibcxx_check_string(__s);
  382.       _Base::insert(__pos, __s, __n);
  383.       this->_M_invalidate_all();
  384.       return *this;
  385.     }
  386.  
  387.     basic_string&
  388.     insert(size_type __pos, const _CharT* __s)
  389.     {
  390.       __glibcxx_check_string(__s);
  391.       _Base::insert(__pos, __s);
  392.       this->_M_invalidate_all();
  393.       return *this;
  394.     }
  395.  
  396.     basic_string&
  397.     insert(size_type __pos, size_type __n, _CharT __c)
  398.     {
  399.       _Base::insert(__pos, __n, __c);
  400.       this->_M_invalidate_all();
  401.       return *this;
  402.     }
  403.  
  404.     iterator
  405.     insert(iterator __p, _CharT __c)
  406.     {
  407.       __glibcxx_check_insert(__p);
  408.       typename _Base::iterator __res = _Base::insert(__p.base(), __c);
  409.       this->_M_invalidate_all();
  410.       return iterator(__res, this);
  411.     }
  412.  
  413.     void
  414.     insert(iterator __p, size_type __n, _CharT __c)
  415.     {
  416.       __glibcxx_check_insert(__p);
  417.       _Base::insert(__p.base(), __n, __c);
  418.       this->_M_invalidate_all();
  419.     }
  420.  
  421.     template<typename _InputIterator>
  422.       void
  423.       insert(iterator __p, _InputIterator __first, _InputIterator __last)
  424.       {
  425.     __glibcxx_check_insert_range(__p, __first, __last);
  426.     _Base::insert(__p.base(), __first, __last);
  427.     this->_M_invalidate_all();
  428.       }
  429.  
  430.     basic_string&
  431.     erase(size_type __pos = 0, size_type __n = _Base::npos)
  432.     {
  433.       _Base::erase(__pos, __n);
  434.       this->_M_invalidate_all();
  435.       return *this;
  436.     }
  437.  
  438.     iterator
  439.     erase(iterator __position)
  440.     {
  441.       __glibcxx_check_erase(__position);
  442.       typename _Base::iterator __res = _Base::erase(__position.base());
  443.       this->_M_invalidate_all();
  444.       return iterator(__res, this);
  445.     }
  446.  
  447.     iterator
  448.     erase(iterator __first, iterator __last)
  449.     {
  450.       // _GLIBCXX_RESOLVE_LIB_DEFECTS
  451.       // 151. can't currently clear() empty container
  452.       __glibcxx_check_erase_range(__first, __last);
  453.       typename _Base::iterator __res = _Base::erase(__first.base(),
  454.                                __last.base());
  455.       this->_M_invalidate_all();
  456.       return iterator(__res, this);
  457.     }
  458.  
  459.     basic_string&
  460.     replace(size_type __pos1, size_type __n1, const basic_string& __str)
  461.     {
  462.       _Base::replace(__pos1, __n1, __str);
  463.       this->_M_invalidate_all();
  464.       return *this;
  465.     }
  466.  
  467.     basic_string&
  468.     replace(size_type __pos1, size_type __n1, const basic_string& __str,
  469.         size_type __pos2, size_type __n2)
  470.     {
  471.       _Base::replace(__pos1, __n1, __str, __pos2, __n2);
  472.       this->_M_invalidate_all();
  473.       return *this;
  474.     }
  475.  
  476.     basic_string&
  477.     replace(size_type __pos, size_type __n1, const _CharT* __s,
  478.         size_type __n2)
  479.     {
  480.       __glibcxx_check_string_len(__s, __n2);
  481.       _Base::replace(__pos, __n1, __s, __n2);
  482.       this->_M_invalidate_all();
  483.       return *this;
  484.     }
  485.  
  486.     basic_string&
  487.     replace(size_type __pos, size_type __n1, const _CharT* __s)
  488.     {
  489.       __glibcxx_check_string(__s);
  490.       _Base::replace(__pos, __n1, __s);
  491.       this->_M_invalidate_all();
  492.       return *this;
  493.     }
  494.  
  495.     basic_string&
  496.     replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
  497.     {
  498.       _Base::replace(__pos, __n1, __n2, __c);
  499.       this->_M_invalidate_all();
  500.       return *this;
  501.     }
  502.  
  503.     basic_string&
  504.     replace(iterator __i1, iterator __i2, const basic_string& __str)
  505.     {
  506.       __glibcxx_check_erase_range(__i1, __i2);
  507.       _Base::replace(__i1.base(), __i2.base(), __str);
  508.       this->_M_invalidate_all();
  509.       return *this;
  510.     }
  511.  
  512.     basic_string&
  513.     replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
  514.     {
  515.       __glibcxx_check_erase_range(__i1, __i2);
  516.       __glibcxx_check_string_len(__s, __n);
  517.       _Base::replace(__i1.base(), __i2.base(), __s, __n);
  518.       this->_M_invalidate_all();
  519.       return *this;
  520.     }
  521.  
  522.     basic_string&
  523.     replace(iterator __i1, iterator __i2, const _CharT* __s)
  524.     {
  525.       __glibcxx_check_erase_range(__i1, __i2);
  526.       __glibcxx_check_string(__s);
  527.       _Base::replace(__i1.base(), __i2.base(), __s);
  528.       this->_M_invalidate_all();
  529.       return *this;
  530.     }
  531.  
  532.     basic_string&
  533.     replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
  534.     {
  535.       __glibcxx_check_erase_range(__i1, __i2);
  536.       _Base::replace(__i1.base(), __i2.base(), __n, __c);
  537.       this->_M_invalidate_all();
  538.       return *this;
  539.     }
  540.  
  541.     template<typename _InputIterator>
  542.       basic_string&
  543.       replace(iterator __i1, iterator __i2,
  544.           _InputIterator __j1, _InputIterator __j2)
  545.       {
  546.     __glibcxx_check_erase_range(__i1, __i2);
  547.     __glibcxx_check_valid_range(__j1, __j2);
  548.     _Base::replace(__i1.base(), __i2.base(), __j1, __j2);
  549.     this->_M_invalidate_all();
  550.     return *this;
  551.       }
  552.  
  553.     size_type
  554.     copy(_CharT* __s, size_type __n, size_type __pos = 0) const
  555.     {
  556.       __glibcxx_check_string_len(__s, __n);
  557.       return _Base::copy(__s, __n, __pos);
  558.     }
  559.  
  560.     void
  561.     swap(basic_string<_CharT,_Traits,_Allocator>& __x)
  562.     {
  563.       _Base::swap(__x);
  564.       this->_M_swap(__x);
  565.       this->_M_invalidate_all();
  566.       __x._M_invalidate_all();
  567.     }
  568.  
  569.     // 21.3.6 string operations:
  570.     const _CharT*
  571.     c_str() const
  572.     {
  573.       const _CharT* __res = _Base::c_str();
  574.       this->_M_invalidate_all();
  575.       return __res;
  576.     }
  577.  
  578.     const _CharT*
  579.     data() const
  580.     {
  581.       const _CharT* __res = _Base::data();
  582.       this->_M_invalidate_all();
  583.       return __res;
  584.     }
  585.  
  586.     using _Base::get_allocator;
  587.  
  588.     size_type
  589.     find(const basic_string& __str, size_type __pos = 0) const
  590.     { return _Base::find(__str, __pos); }
  591.  
  592.     size_type
  593.     find(const _CharT* __s, size_type __pos, size_type __n) const
  594.     {
  595.       __glibcxx_check_string(__s);
  596.       return _Base::find(__s, __pos, __n);
  597.     }
  598.  
  599.     size_type
  600.     find(const _CharT* __s, size_type __pos = 0) const
  601.     {
  602.       __glibcxx_check_string(__s);
  603.       return _Base::find(__s, __pos);
  604.     }
  605.  
  606.     size_type
  607.     find(_CharT __c, size_type __pos = 0) const
  608.     { return _Base::find(__c, __pos); }
  609.  
  610.     size_type
  611.     rfind(const basic_string& __str, size_type __pos = _Base::npos) const
  612.     { return _Base::rfind(__str, __pos); }
  613.  
  614.     size_type
  615.     rfind(const _CharT* __s, size_type __pos, size_type __n) const
  616.     {
  617.       __glibcxx_check_string_len(__s, __n);
  618.       return _Base::rfind(__s, __pos, __n);
  619.     }
  620.  
  621.     size_type
  622.     rfind(const _CharT* __s, size_type __pos = _Base::npos) const
  623.     {
  624.       __glibcxx_check_string(__s);
  625.       return _Base::rfind(__s, __pos);
  626.     }
  627.  
  628.     size_type
  629.     rfind(_CharT __c, size_type __pos = _Base::npos) const
  630.     { return _Base::rfind(__c, __pos); }
  631.  
  632.     size_type
  633.     find_first_of(const basic_string& __str, size_type __pos = 0) const
  634.     { return _Base::find_first_of(__str, __pos); }
  635.  
  636.     size_type
  637.     find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
  638.     {
  639.       __glibcxx_check_string(__s);
  640.       return _Base::find_first_of(__s, __pos, __n);
  641.     }
  642.  
  643.     size_type
  644.     find_first_of(const _CharT* __s, size_type __pos = 0) const
  645.     {
  646.       __glibcxx_check_string(__s);
  647.       return _Base::find_first_of(__s, __pos);
  648.     }
  649.  
  650.     size_type
  651.     find_first_of(_CharT __c, size_type __pos = 0) const
  652.     { return _Base::find_first_of(__c, __pos); }
  653.  
  654.     size_type
  655.     find_last_of(const basic_string& __str, size_type __pos = _Base::npos) const
  656.     { return _Base::find_last_of(__str, __pos); }
  657.  
  658.     size_type
  659.     find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
  660.     {
  661.       __glibcxx_check_string(__s);
  662.       return _Base::find_last_of(__s, __pos, __n);
  663.     }
  664.  
  665.     size_type
  666.     find_last_of(const _CharT* __s, size_type __pos = _Base::npos) const
  667.     {
  668.       __glibcxx_check_string(__s);
  669.       return _Base::find_last_of(__s, __pos);
  670.     }
  671.  
  672.     size_type
  673.     find_last_of(_CharT __c, size_type __pos = _Base::npos) const
  674.     { return _Base::find_last_of(__c, __pos); }
  675.  
  676.     size_type
  677.     find_first_not_of(const basic_string& __str, size_type __pos = 0) const
  678.     { return _Base::find_first_not_of(__str, __pos); }
  679.  
  680.     size_type
  681.     find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
  682.     {
  683.       __glibcxx_check_string_len(__s, __n);
  684.       return _Base::find_first_not_of(__s, __pos, __n);
  685.     }
  686.  
  687.     size_type
  688.     find_first_not_of(const _CharT* __s, size_type __pos = 0) const
  689.     {
  690.       __glibcxx_check_string(__s);
  691.       return _Base::find_first_not_of(__s, __pos);
  692.     }
  693.  
  694.     size_type
  695.     find_first_not_of(_CharT __c, size_type __pos = 0) const
  696.     { return _Base::find_first_not_of(__c, __pos); }
  697.  
  698.     size_type
  699.     find_last_not_of(const basic_string& __str,
  700.                   size_type __pos = _Base::npos) const
  701.     { return _Base::find_last_not_of(__str, __pos); }
  702.  
  703.     size_type
  704.     find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
  705.     {
  706.       __glibcxx_check_string(__s);
  707.       return _Base::find_last_not_of(__s, __pos, __n);
  708.     }
  709.  
  710.     size_type
  711.     find_last_not_of(const _CharT* __s, size_type __pos = _Base::npos) const
  712.     {
  713.       __glibcxx_check_string(__s);
  714.       return _Base::find_last_not_of(__s, __pos);
  715.     }
  716.  
  717.     size_type
  718.     find_last_not_of(_CharT __c, size_type __pos = _Base::npos) const
  719.     { return _Base::find_last_not_of(__c, __pos); }
  720.  
  721.     basic_string
  722.     substr(size_type __pos = 0, size_type __n = _Base::npos) const
  723.     { return basic_string(_Base::substr(__pos, __n)); }
  724.  
  725.     int
  726.     compare(const basic_string& __str) const
  727.     { return _Base::compare(__str); }
  728.  
  729.     int
  730.     compare(size_type __pos1, size_type __n1,
  731.           const basic_string& __str) const
  732.     { return _Base::compare(__pos1, __n1, __str); }
  733.  
  734.     int
  735.     compare(size_type __pos1, size_type __n1, const basic_string& __str,
  736.           size_type __pos2, size_type __n2) const
  737.     { return _Base::compare(__pos1, __n1, __str, __pos2, __n2); }
  738.  
  739.     int
  740.     compare(const _CharT* __s) const
  741.     {
  742.       __glibcxx_check_string(__s);
  743.       return _Base::compare(__s);
  744.     }
  745.  
  746.     //  _GLIBCXX_RESOLVE_LIB_DEFECTS
  747.     //  5. string::compare specification questionable
  748.     int
  749.     compare(size_type __pos1, size_type __n1, const _CharT* __s) const
  750.     {
  751.       __glibcxx_check_string(__s);
  752.       return _Base::compare(__pos1, __n1, __s);
  753.     }
  754.  
  755.     //  _GLIBCXX_RESOLVE_LIB_DEFECTS
  756.     //  5. string::compare specification questionable
  757.     int
  758.     compare(size_type __pos1, size_type __n1,const _CharT* __s,
  759.           size_type __n2) const
  760.     {
  761.       __glibcxx_check_string_len(__s, __n2);
  762.       return _Base::compare(__pos1, __n1, __s, __n2);
  763.     }
  764.  
  765.     _Base&
  766.     _M_base() { return *this; }
  767.  
  768.     const _Base&
  769.     _M_base() const { return *this; }
  770.  
  771.     using _Safe_base::_M_invalidate_all;
  772.   };
  773.  
  774.   template<typename _CharT, typename _Traits, typename _Allocator>
  775.     inline basic_string<_CharT,_Traits,_Allocator>
  776.     operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  777.           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  778.     { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
  779.  
  780.   template<typename _CharT, typename _Traits, typename _Allocator>
  781.     inline basic_string<_CharT,_Traits,_Allocator>
  782.     operator+(const _CharT* __lhs,
  783.           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  784.     {
  785.       __glibcxx_check_string(__lhs);
  786.       return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
  787.     }
  788.  
  789.   template<typename _CharT, typename _Traits, typename _Allocator>
  790.     inline basic_string<_CharT,_Traits,_Allocator>
  791.     operator+(_CharT __lhs,
  792.           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  793.     { return basic_string<_CharT,_Traits,_Allocator>(1, __lhs) += __rhs; }
  794.  
  795.   template<typename _CharT, typename _Traits, typename _Allocator>
  796.     inline basic_string<_CharT,_Traits,_Allocator>
  797.     operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  798.           const _CharT* __rhs)
  799.     {
  800.       __glibcxx_check_string(__rhs);
  801.       return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
  802.     }
  803.  
  804.   template<typename _CharT, typename _Traits, typename _Allocator>
  805.     inline basic_string<_CharT,_Traits,_Allocator>
  806.     operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  807.           _CharT __rhs)
  808.     { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
  809.  
  810.   template<typename _CharT, typename _Traits, typename _Allocator>
  811.     inline bool
  812.     operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  813.            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  814.     { return __lhs._M_base() == __rhs._M_base(); }
  815.  
  816.   template<typename _CharT, typename _Traits, typename _Allocator>
  817.     inline bool
  818.     operator==(const _CharT* __lhs,
  819.            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  820.     {
  821.       __glibcxx_check_string(__lhs);
  822.       return __lhs == __rhs._M_base();
  823.     }
  824.  
  825.   template<typename _CharT, typename _Traits, typename _Allocator>
  826.     inline bool
  827.     operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  828.            const _CharT* __rhs)
  829.     {
  830.       __glibcxx_check_string(__rhs);
  831.       return __lhs._M_base() == __rhs;
  832.     }
  833.  
  834.   template<typename _CharT, typename _Traits, typename _Allocator>
  835.     inline bool
  836.     operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  837.            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  838.     { return __lhs._M_base() != __rhs._M_base(); }
  839.  
  840.   template<typename _CharT, typename _Traits, typename _Allocator>
  841.     inline bool
  842.     operator!=(const _CharT* __lhs,
  843.            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  844.     {
  845.       __glibcxx_check_string(__lhs);
  846.       return __lhs != __rhs._M_base();
  847.     }
  848.  
  849.   template<typename _CharT, typename _Traits, typename _Allocator>
  850.     inline bool
  851.     operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  852.            const _CharT* __rhs)
  853.     {
  854.       __glibcxx_check_string(__rhs);
  855.       return __lhs._M_base() != __rhs;
  856.     }
  857.  
  858.   template<typename _CharT, typename _Traits, typename _Allocator>
  859.     inline bool
  860.     operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  861.           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  862.     { return __lhs._M_base() < __rhs._M_base(); }
  863.  
  864.   template<typename _CharT, typename _Traits, typename _Allocator>
  865.     inline bool
  866.     operator<(const _CharT* __lhs,
  867.           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  868.     {
  869.       __glibcxx_check_string(__lhs);
  870.       return __lhs < __rhs._M_base();
  871.     }
  872.  
  873.   template<typename _CharT, typename _Traits, typename _Allocator>
  874.     inline bool
  875.     operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  876.           const _CharT* __rhs)
  877.     {
  878.       __glibcxx_check_string(__rhs);
  879.       return __lhs._M_base() < __rhs;
  880.     }
  881.  
  882.   template<typename _CharT, typename _Traits, typename _Allocator>
  883.     inline bool
  884.     operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  885.            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  886.     { return __lhs._M_base() <= __rhs._M_base(); }
  887.  
  888.   template<typename _CharT, typename _Traits, typename _Allocator>
  889.     inline bool
  890.     operator<=(const _CharT* __lhs,
  891.            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  892.     {
  893.       __glibcxx_check_string(__lhs);
  894.       return __lhs <= __rhs._M_base();
  895.     }
  896.  
  897.   template<typename _CharT, typename _Traits, typename _Allocator>
  898.     inline bool
  899.     operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  900.            const _CharT* __rhs)
  901.     {
  902.       __glibcxx_check_string(__rhs);
  903.       return __lhs._M_base() <= __rhs;
  904.     }
  905.  
  906.   template<typename _CharT, typename _Traits, typename _Allocator>
  907.     inline bool
  908.     operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  909.            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  910.     { return __lhs._M_base() >= __rhs._M_base(); }
  911.  
  912.   template<typename _CharT, typename _Traits, typename _Allocator>
  913.     inline bool
  914.     operator>=(const _CharT* __lhs,
  915.            const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  916.     {
  917.       __glibcxx_check_string(__lhs);
  918.       return __lhs >= __rhs._M_base();
  919.     }
  920.  
  921.   template<typename _CharT, typename _Traits, typename _Allocator>
  922.     inline bool
  923.     operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  924.            const _CharT* __rhs)
  925.     {
  926.       __glibcxx_check_string(__rhs);
  927.       return __lhs._M_base() >= __rhs;
  928.     }
  929.  
  930.   template<typename _CharT, typename _Traits, typename _Allocator>
  931.     inline bool
  932.     operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  933.           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  934.     { return __lhs._M_base() > __rhs._M_base(); }
  935.  
  936.   template<typename _CharT, typename _Traits, typename _Allocator>
  937.     inline bool
  938.     operator>(const _CharT* __lhs,
  939.           const basic_string<_CharT,_Traits,_Allocator>& __rhs)
  940.     {
  941.       __glibcxx_check_string(__lhs);
  942.       return __lhs > __rhs._M_base();
  943.     }
  944.  
  945.   template<typename _CharT, typename _Traits, typename _Allocator>
  946.     inline bool
  947.     operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
  948.           const _CharT* __rhs)
  949.     {
  950.       __glibcxx_check_string(__rhs);
  951.       return __lhs._M_base() > __rhs;
  952.     }
  953.  
  954.   // 21.3.7.8:
  955.   template<typename _CharT, typename _Traits, typename _Allocator>
  956.     inline void
  957.     swap(basic_string<_CharT,_Traits,_Allocator>& __lhs,
  958.      basic_string<_CharT,_Traits,_Allocator>& __rhs)
  959.     { __lhs.swap(__rhs); }
  960.  
  961.   template<typename _CharT, typename _Traits, typename _Allocator>
  962.     std::basic_ostream<_CharT, _Traits>&
  963.     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  964.            const basic_string<_CharT, _Traits, _Allocator>& __str)
  965.     { return __os << __str._M_base(); }
  966.  
  967.   template<typename _CharT, typename _Traits, typename _Allocator>
  968.     std::basic_istream<_CharT,_Traits>&
  969.     operator>>(std::basic_istream<_CharT,_Traits>& __is,
  970.            basic_string<_CharT,_Traits,_Allocator>& __str)
  971.     {
  972.       std::basic_istream<_CharT,_Traits>& __res = __is >> __str._M_base();
  973.       __str._M_invalidate_all();
  974.       return __res;
  975.     }
  976.  
  977.   template<typename _CharT, typename _Traits, typename _Allocator>
  978.     std::basic_istream<_CharT,_Traits>&
  979.     getline(std::basic_istream<_CharT,_Traits>& __is,
  980.         basic_string<_CharT,_Traits,_Allocator>& __str, _CharT __delim)
  981.     {
  982.       std::basic_istream<_CharT,_Traits>& __res = getline(__is,
  983.                               __str._M_base(),
  984.                             __delim);
  985.       __str._M_invalidate_all();
  986.       return __res;
  987.     }
  988.  
  989.   template<typename _CharT, typename _Traits, typename _Allocator>
  990.     std::basic_istream<_CharT,_Traits>&
  991.     getline(std::basic_istream<_CharT,_Traits>& __is,
  992.         basic_string<_CharT,_Traits,_Allocator>& __str)
  993.     {
  994.       std::basic_istream<_CharT,_Traits>& __res = getline(__is,
  995.                               __str._M_base());
  996.       __str._M_invalidate_all();
  997.       return __res;
  998.     }
  999. } // namespace __gnu_debug
  1000.  
  1001. #endif
  1002.