STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Types | Public Member Functions | Private Types | List of all members
__gnu_debug::basic_string< _CharT, _Traits, _Allocator > Class Template Reference

Class std::basic_string with safety/checking/debug instrumentation. More...

Inheritance diagram for __gnu_debug::basic_string< _CharT, _Traits, _Allocator >:
__gnu_debug::_Safe_sequence< basic_string< _CharT, _Traits, _Allocator > > __gnu_debug::_Safe_sequence_base

Public Types

typedef _Traits traits_type
 
typedef _Traits::char_type value_type
 
typedef _Allocator allocator_type
 
typedef _Base::size_type size_type
 
typedef _Base::difference_type difference_type
 
typedef _Base::reference reference
 
typedef _Base::const_reference const_reference
 
typedef _Base::pointer pointer
 
typedef _Base::const_pointer const_pointer
 
typedef
__gnu_debug::_Safe_iterator
< typename _Base::iterator,
basic_string > 		iterator
 
typedef
__gnu_debug::_Safe_iterator
< typename
_Base::const_iterator,
basic_string > 		const_iterator
 
typedef std::reverse_iterator
< iterator > 		reverse_iterator
 
typedef std::reverse_iterator
< const_iterator > 		const_reverse_iterator
 

Public Member Functions

 basic_string (const _Allocator &__a=_Allocator())
 
 basic_string (const _Base &__base)
 
 basic_string (const basic_string &__str)
 
 basic_string (const basic_string &__str, size_type __pos, size_type __n=_Base::npos, const _Allocator &__a=_Allocator())
 
 basic_string (const _CharT *__s, size_type __n, const _Allocator &__a=_Allocator())
 
 basic_string (const _CharT *__s, const _Allocator &__a=_Allocator())
 
 basic_string (size_type __n, _CharT __c, const _Allocator &__a=_Allocator())
 
template<typename _InputIterator >
 basic_string (_InputIterator __begin, _InputIterator __end, const _Allocator &__a=_Allocator())
 
 ~basic_string () _GLIBCXX_NOEXCEPT
 
basic_string & operator= (const basic_string &__str)
 
basic_string & operator= (const _CharT *__s)
 
basic_string & operator= (_CharT __c)
 
iterator begin () _GLIBCXX_NOEXCEPT
 
const_iterator begin () const _GLIBCXX_NOEXCEPT
 
iterator end () _GLIBCXX_NOEXCEPT
 
const_iterator end () const _GLIBCXX_NOEXCEPT
 
reverse_iterator rbegin () _GLIBCXX_NOEXCEPT
 
const_reverse_iterator rbegin () const _GLIBCXX_NOEXCEPT
 
reverse_iterator rend () _GLIBCXX_NOEXCEPT
 
const_reverse_iterator rend () const _GLIBCXX_NOEXCEPT
 
void resize (size_type __n, _CharT __c)
 
void resize (size_type __n)
 
void clear () _GLIBCXX_NOEXCEPT
 
const_reference operator[] (size_type __pos) const
 
reference operator[] (size_type __pos)
 
basic_string & operator+= (const basic_string &__str)
 
basic_string & operator+= (const _CharT *__s)
 
basic_string & operator+= (_CharT __c)
 
basic_string & append (const basic_string &__str)
 
basic_string & append (const basic_string &__str, size_type __pos, size_type __n)
 
basic_string & append (const _CharT *__s, size_type __n)
 
basic_string & append (const _CharT *__s)
 
basic_string & append (size_type __n, _CharT __c)
 
template<typename _InputIterator >
basic_string & append (_InputIterator __first, _InputIterator __last)
 
void push_back (_CharT __c)
 
basic_string & assign (const basic_string &__x)
 
basic_string & assign (const basic_string &__str, size_type __pos, size_type __n)
 
basic_string & assign (const _CharT *__s, size_type __n)
 
basic_string & assign (const _CharT *__s)
 
basic_string & assign (size_type __n, _CharT __c)
 
template<typename _InputIterator >
basic_string & assign (_InputIterator __first, _InputIterator __last)
 
basic_string & insert (size_type __pos1, const basic_string &__str)
 
basic_string & insert (size_type __pos1, const basic_string &__str, size_type __pos2, size_type __n)
 
basic_string & insert (size_type __pos, const _CharT *__s, size_type __n)
 
basic_string & insert (size_type __pos, const _CharT *__s)
 
basic_string & insert (size_type __pos, size_type __n, _CharT __c)
 
iterator insert (iterator __p, _CharT __c)
 
void insert (iterator __p, size_type __n, _CharT __c)
 
template<typename _InputIterator >
void insert (iterator __p, _InputIterator __first, _InputIterator __last)
 
basic_string & erase (size_type __pos=0, size_type __n=_Base::npos)
 
iterator erase (iterator __position)
 
iterator erase (iterator __first, iterator __last)
 
basic_string & replace (size_type __pos1, size_type __n1, const basic_string &__str)
 
basic_string & replace (size_type __pos1, size_type __n1, const basic_string &__str, size_type __pos2, size_type __n2)
 
basic_string & replace (size_type __pos, size_type __n1, const _CharT *__s, size_type __n2)
 
basic_string & replace (size_type __pos, size_type __n1, const _CharT *__s)
 
basic_string & replace (size_type __pos, size_type __n1, size_type __n2, _CharT __c)
 
basic_string & replace (iterator __i1, iterator __i2, const basic_string &__str)
 
basic_string & replace (iterator __i1, iterator __i2, const _CharT *__s, size_type __n)
 
basic_string & replace (iterator __i1, iterator __i2, const _CharT *__s)
 
basic_string & replace (iterator __i1, iterator __i2, size_type __n, _CharT __c)
 
template<typename _InputIterator >
basic_string & replace (iterator __i1, iterator __i2, _InputIterator __j1, _InputIterator __j2)
 
size_type copy (_CharT *__s, size_type __n, size_type __pos=0) const
 
void swap (basic_string< _CharT, _Traits, _Allocator > &__x)
 
const _CharT * c_str () const _GLIBCXX_NOEXCEPT
 
const _CharT * data () const _GLIBCXX_NOEXCEPT
 
size_type find (const basic_string &__str, size_type __pos=0) const _GLIBCXX_NOEXCEPT
 
size_type find (const _CharT *__s, size_type __pos, size_type __n) const
 
size_type find (const _CharT *__s, size_type __pos=0) const
 
size_type find (_CharT __c, size_type __pos=0) const _GLIBCXX_NOEXCEPT
 
size_type rfind (const basic_string &__str, size_type __pos=_Base::npos) const _GLIBCXX_NOEXCEPT
 
size_type rfind (const _CharT *__s, size_type __pos, size_type __n) const
 
size_type rfind (const _CharT *__s, size_type __pos=_Base::npos) const
 
size_type rfind (_CharT __c, size_type __pos=_Base::npos) const _GLIBCXX_NOEXCEPT
 
size_type find_first_of (const basic_string &__str, size_type __pos=0) const _GLIBCXX_NOEXCEPT
 
size_type find_first_of (const _CharT *__s, size_type __pos, size_type __n) const
 
size_type find_first_of (const _CharT *__s, size_type __pos=0) const
 
size_type find_first_of (_CharT __c, size_type __pos=0) const _GLIBCXX_NOEXCEPT
 
size_type find_last_of (const basic_string &__str, size_type __pos=_Base::npos) const _GLIBCXX_NOEXCEPT
 
size_type find_last_of (const _CharT *__s, size_type __pos, size_type __n) const
 
size_type find_last_of (const _CharT *__s, size_type __pos=_Base::npos) const
 
size_type find_last_of (_CharT __c, size_type __pos=_Base::npos) const _GLIBCXX_NOEXCEPT
 
size_type find_first_not_of (const basic_string &__str, size_type __pos=0) const _GLIBCXX_NOEXCEPT
 
size_type find_first_not_of (const _CharT *__s, size_type __pos, size_type __n) const
 
size_type find_first_not_of (const _CharT *__s, size_type __pos=0) const
 
size_type find_first_not_of (_CharT __c, size_type __pos=0) const _GLIBCXX_NOEXCEPT
 
size_type find_last_not_of (const basic_string &__str, size_type __pos=_Base::npos) const _GLIBCXX_NOEXCEPT
 
size_type find_last_not_of (const _CharT *__s, size_type __pos, size_type __n) const
 
size_type find_last_not_of (const _CharT *__s, size_type __pos=_Base::npos) const
 
size_type find_last_not_of (_CharT __c, size_type __pos=_Base::npos) const _GLIBCXX_NOEXCEPT
 
basic_string substr (size_type __pos=0, size_type __n=_Base::npos) const
 
int compare (const basic_string &__str) const
 
int compare (size_type __pos1, size_type __n1, const basic_string &__str) const
 
int compare (size_type __pos1, size_type __n1, const basic_string &__str, size_type __pos2, size_type __n2) const
 
int compare (const _CharT *__s) const
 
int compare (size_type __pos1, size_type __n1, const _CharT *__s) const
 
int compare (size_type __pos1, size_type __n1, const _CharT *__s, size_type __n2) const
 
_Base & _M_base () _GLIBCXX_NOEXCEPT
 
const _Base & _M_base () const _GLIBCXX_NOEXCEPT
 
- Public Member Functions inherited from __gnu_debug::_Safe_sequence< basic_string< _CharT, _Traits, _Allocator > >
void _M_invalidate_if (_Predicate __pred)
 
void _M_transfer_from_if (_Safe_sequence &__from, _Predicate __pred)
 
- Public Member Functions inherited from __gnu_debug::_Safe_sequence_base
void _M_invalidate_all () const
 
void _M_attach (_Safe_iterator_base *__it, bool __constant)
 
void _M_attach_single (_Safe_iterator_base *__it, bool __constant) throw ()
 
void _M_detach (_Safe_iterator_base *__it)
 
void _M_detach_single (_Safe_iterator_base *__it) throw ()
 

Private Types

typedef std::basic_string
< _CharT, _Traits, _Allocator > 		_Base
 
typedef
__gnu_debug::_Safe_sequence
< basic_string > 		_Safe_base
 

Additional Inherited Members

- Public Attributes inherited from __gnu_debug::_Safe_sequence_base
_Safe_iterator_base * _M_iterators
 The list of mutable iterators that reference this container. More...
 
_Safe_iterator_base * _M_const_iterators
 The list of constant iterators that reference this container. More...
 
unsigned int _M_version
 The container version number. This number may never be 0. More...
 
- Protected Member Functions inherited from __gnu_debug::_Safe_sequence_base
 _Safe_sequence_base ()
 
 ~_Safe_sequence_base ()
 
void _M_detach_all ()
 
void _M_detach_singular ()
 
void _M_revalidate_singular ()
 
void _M_swap (_Safe_sequence_base &__x)
 
__gnu_cxx::__mutex & _M_get_mutex () throw ()
 

Detailed Description

template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
class __gnu_debug::basic_string< _CharT, _Traits, _Allocator >

Class std::basic_string with safety/checking/debug instrumentation.

Member Typedef Documentation

template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef std::basic_string<_CharT, _Traits, _Allocator> __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::_Base
private
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef __gnu_debug::_Safe_sequence<basic_string> __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::_Safe_base
private
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef _Allocator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::allocator_type
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator, basic_string> __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::const_iterator
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef _Base::const_pointer __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::const_pointer
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef _Base::const_reference __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::const_reference
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef std::reverse_iterator<const_iterator> __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::const_reverse_iterator
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef _Base::difference_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::difference_type
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, basic_string> __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::iterator
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef _Base::pointer __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::pointer
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef _Base::reference __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::reference
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef std::reverse_iterator<iterator> __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::reverse_iterator
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef _Base::size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::size_type
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef _Traits __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::traits_type
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
typedef _Traits::char_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::value_type

Constructor & Destructor Documentation

template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
__gnu_debug::basic_string< _CharT, _Traits, _Allocator >::basic_string ( const _Allocator &  __a = _Allocator())
inlineexplicit
73  : _Base(__a)
74  { }
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
__gnu_debug::basic_string< _CharT, _Traits, _Allocator >::basic_string ( const _Base &  __base)
inline
77 : _Base(__base) { }
__gnu_debug::__base
_Siter_base< _Iterator >::iterator_type __base(_Iterator __it)
Definition: functions.h:446
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
__gnu_debug::basic_string< _CharT, _Traits, _Allocator >::basic_string ( const basic_string< _CharT, _Traits, _Allocator > &  __str)
inline
82  : _Base(__str, 0, _Base::npos, __str.get_allocator())
83  { }
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
__gnu_debug::basic_string< _CharT, _Traits, _Allocator >::basic_string ( const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos,
size_type  __n = _Base::npos,
const _Allocator &  __a = _Allocator() 
)
inline
90  : _Base(__str, __pos, __n, __a)
91  { }
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
__gnu_debug::basic_string< _CharT, _Traits, _Allocator >::basic_string ( const _CharT *  __s,
size_type  __n,
const _Allocator &  __a = _Allocator() 
)
inline
95  : _Base(__gnu_debug::__check_string(__s, __n), __n, __a)
96  { }
__gnu_debug::__check_string
const _CharT * __check_string(const _CharT *__s, const _Integer &__n __attribute__((__unused__)))
Definition: functions.h:168
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
__gnu_debug::basic_string< _CharT, _Traits, _Allocator >::basic_string ( const _CharT *  __s,
const _Allocator &  __a = _Allocator() 
)
inline
99  : _Base(__gnu_debug::__check_string(__s), __a)
100  { this->assign(__s); }
__gnu_debug::__check_string
const _CharT * __check_string(const _CharT *__s, const _Integer &__n __attribute__((__unused__)))
Definition: functions.h:168
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
__gnu_debug::basic_string::assign
basic_string & assign(const basic_string &__x)
Definition: string:402
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
__gnu_debug::basic_string< _CharT, _Traits, _Allocator >::basic_string ( size_type  __n,
_CharT  __c,
const _Allocator &  __a = _Allocator() 
)
inline
104  : _Base(__n, __c, __a)
105  { }
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
template<typename _InputIterator >
__gnu_debug::basic_string< _CharT, _Traits, _Allocator >::basic_string ( _InputIterator  __begin,
_InputIterator  __end,
const _Allocator &  __a = _Allocator() 
)
inline
110  : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__begin,
111  __end)),
112  __gnu_debug::__base(__end), __a)
113  { }
__gnu_debug::__base
_Siter_base< _Iterator >::iterator_type __base(_Iterator __it)
Definition: functions.h:446
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
__gnu_debug::__check_valid_range
_InputIterator __check_valid_range(const _InputIterator &__first, const _InputIterator &__last __attribute__((__unused__)))
Definition: functions.h:157
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
__gnu_debug::basic_string< _CharT, _Traits, _Allocator >::~basic_string ( )
inline
126 { }

Member Function Documentation

template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
_Base& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::_M_base ( )
inline
919 { return *this; }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
const _Base& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::_M_base ( ) const
inline
922 { return *this; }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::append ( const basic_string< _CharT, _Traits, _Allocator > &  __str)
inline
341  {
342  _Base::append(__str);
343  this->_M_invalidate_all();
344  return *this;
345  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::append ( const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos,
size_type  __n 
)
inline
349  {
350  _Base::append(__str, __pos, __n);
351  this->_M_invalidate_all();
352  return *this;
353  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::append ( const _CharT *  __s,
size_type  __n 
)
inline
357  {
358  __glibcxx_check_string_len(__s, __n);
359  _Base::append(__s, __n);
360  this->_M_invalidate_all();
361  return *this;
362  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_string_len
#define __glibcxx_check_string_len(_String, _Len)
Definition: macros.h:350
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::append ( const _CharT *  __s)
inline
366  {
367  __glibcxx_check_string(__s);
368  _Base::append(__s);
369  this->_M_invalidate_all();
370  return *this;
371  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::append ( size_type  __n,
_CharT  __c 
)
inline
375  {
376  _Base::append(__n, __c);
377  this->_M_invalidate_all();
378  return *this;
379  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
template<typename _InputIterator >
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::append ( _InputIterator  __first,
_InputIterator  __last 
)
inline
384  {
385  __glibcxx_check_valid_range(__first, __last);
386  _Base::append(__gnu_debug::__base(__first),
387  __gnu_debug::__base(__last));
388  this->_M_invalidate_all();
389  return *this;
390  }
__gnu_debug::__base
_Siter_base< _Iterator >::iterator_type __base(_Iterator __it)
Definition: functions.h:446
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_valid_range
#define __glibcxx_check_valid_range(_First, _Last)
Definition: macros.h:53
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::assign ( const basic_string< _CharT, _Traits, _Allocator > &  __x)
inline
403  {
404  _Base::assign(__x);
405  this->_M_invalidate_all();
406  return *this;
407  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::assign ( const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos,
size_type  __n 
)
inline
421  {
422  _Base::assign(__str, __pos, __n);
423  this->_M_invalidate_all();
424  return *this;
425  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::assign ( const _CharT *  __s,
size_type  __n 
)
inline
429  {
430  __glibcxx_check_string_len(__s, __n);
431  _Base::assign(__s, __n);
432  this->_M_invalidate_all();
433  return *this;
434  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_string_len
#define __glibcxx_check_string_len(_String, _Len)
Definition: macros.h:350
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::assign ( const _CharT *  __s)
inline
438  {
439  __glibcxx_check_string(__s);
440  _Base::assign(__s);
441  this->_M_invalidate_all();
442  return *this;
443  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::assign ( size_type  __n,
_CharT  __c 
)
inline
447  {
448  _Base::assign(__n, __c);
449  this->_M_invalidate_all();
450  return *this;
451  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
template<typename _InputIterator >
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::assign ( _InputIterator  __first,
_InputIterator  __last 
)
inline
456  {
457  __glibcxx_check_valid_range(__first, __last);
458  _Base::assign(__gnu_debug::__base(__first),
459  __gnu_debug::__base(__last));
460  this->_M_invalidate_all();
461  return *this;
462  }
__gnu_debug::__base
_Siter_base< _Iterator >::iterator_type __base(_Iterator __it)
Definition: functions.h:446
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_valid_range
#define __glibcxx_check_valid_range(_First, _Last)
Definition: macros.h:53
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::begin ( )
inline
175  { return iterator(_Base::begin(), this); }
__gnu_debug::basic_string::iterator
__gnu_debug::_Safe_iterator< typename _Base::iterator, basic_string > iterator
Definition: string:62
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
const_iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::begin ( ) const
inline
179  { return const_iterator(_Base::begin(), this); }
__gnu_debug::basic_string::const_iterator
__gnu_debug::_Safe_iterator< typename _Base::const_iterator, basic_string > const_iterator
Definition: string:64
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
const _CharT* __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::c_str ( ) const
inline
717  {
718  const _CharT* __res = _Base::c_str();
719  this->_M_invalidate_all();
720  return __res;
721  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
void __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::clear ( )
inline
261  {
262  _Base::clear();
263  this->_M_invalidate_all();
264  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
int __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::compare ( const basic_string< _CharT, _Traits, _Allocator > &  __str) const
inline
880  { return _Base::compare(__str); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
int __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::compare ( size_type  __pos1,
size_type  __n1,
const basic_string< _CharT, _Traits, _Allocator > &  __str 
) const
inline
885  { return _Base::compare(__pos1, __n1, __str); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
int __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::compare ( size_type  __pos1,
size_type  __n1,
const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos2,
size_type  __n2 
) const
inline
890  { return _Base::compare(__pos1, __n1, __str, __pos2, __n2); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
int __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::compare ( const _CharT *  __s) const
inline
894  {
895  __glibcxx_check_string(__s);
896  return _Base::compare(__s);
897  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
int __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::compare ( size_type  __pos1,
size_type  __n1,
const _CharT *  __s 
) const
inline
903  {
904  __glibcxx_check_string(__s);
905  return _Base::compare(__pos1, __n1, __s);
906  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
int __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::compare ( size_type  __pos1,
size_type  __n1,
const _CharT *  __s,
size_type  __n2 
) const
inline
913  {
914  __glibcxx_check_string_len(__s, __n2);
915  return _Base::compare(__pos1, __n1, __s, __n2);
916  }
__glibcxx_check_string_len
#define __glibcxx_check_string_len(_String, _Len)
Definition: macros.h:350
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::copy ( _CharT *  __s,
size_type  __n,
size_type  __pos = 0 
) const
inline
700  {
701  __glibcxx_check_string_len(__s, __n);
702  return _Base::copy(__s, __n, __pos);
703  }
__glibcxx_check_string_len
#define __glibcxx_check_string_len(_String, _Len)
Definition: macros.h:350
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
const _CharT* __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::data ( ) const
inline
725  {
726  const _CharT* __res = _Base::data();
727  this->_M_invalidate_all();
728  return __res;
729  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::end ( )
inline
183  { return iterator(_Base::end(), this); }
__gnu_debug::basic_string::iterator
__gnu_debug::_Safe_iterator< typename _Base::iterator, basic_string > iterator
Definition: string:62
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
const_iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::end ( ) const
inline
187  { return const_iterator(_Base::end(), this); }
__gnu_debug::basic_string::const_iterator
__gnu_debug::_Safe_iterator< typename _Base::const_iterator, basic_string > const_iterator
Definition: string:64
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::erase ( size_type  __pos = 0,
size_type  __n = _Base::npos 
)
inline
556  {
557  _Base::erase(__pos, __n);
558  this->_M_invalidate_all();
559  return *this;
560  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::erase ( iterator  __position)
inline
564  {
565  __glibcxx_check_erase(__position);
566  typename _Base::iterator __res = _Base::erase(__position.base());
567  this->_M_invalidate_all();
568  return iterator(__res, this);
569  }
__gnu_debug::basic_string::iterator
__gnu_debug::_Safe_iterator< typename _Base::iterator, basic_string > iterator
Definition: string:62
__glibcxx_check_erase
#define __glibcxx_check_erase(_Position)
Definition: macros.h:135
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::erase ( iterator  __first,
iterator  __last 
)
inline
573  {
574  // _GLIBCXX_RESOLVE_LIB_DEFECTS
575  // 151. can't currently clear() empty container
576  __glibcxx_check_erase_range(__first, __last);
577  typename _Base::iterator __res = _Base::erase(__first.base(),
578  __last.base());
579  this->_M_invalidate_all();
580  return iterator(__res, this);
581  }
__gnu_debug::basic_string::iterator
__gnu_debug::_Safe_iterator< typename _Base::iterator, basic_string > iterator
Definition: string:62
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_erase_range
#define __glibcxx_check_erase_range(_First, _Last)
Definition: macros.h:163
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find ( const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos = 0 
) const
inline
736  { return _Base::find(__str, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find ( const _CharT *  __s,
size_type  __pos,
size_type  __n 
) const
inline
740  {
741  __glibcxx_check_string(__s);
742  return _Base::find(__s, __pos, __n);
743  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find ( const _CharT *  __s,
size_type  __pos = 0 
) const
inline
747  {
748  __glibcxx_check_string(__s);
749  return _Base::find(__s, __pos);
750  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find ( _CharT  __c,
size_type  __pos = 0 
) const
inline
754  { return _Base::find(__c, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_first_not_of ( const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos = 0 
) const
inline
829  { return _Base::find_first_not_of(__str, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_first_not_of ( const _CharT *  __s,
size_type  __pos,
size_type  __n 
) const
inline
833  {
834  __glibcxx_check_string_len(__s, __n);
835  return _Base::find_first_not_of(__s, __pos, __n);
836  }
__glibcxx_check_string_len
#define __glibcxx_check_string_len(_String, _Len)
Definition: macros.h:350
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_first_not_of ( const _CharT *  __s,
size_type  __pos = 0 
) const
inline
840  {
841  __glibcxx_check_string(__s);
842  return _Base::find_first_not_of(__s, __pos);
843  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_first_not_of ( _CharT  __c,
size_type  __pos = 0 
) const
inline
847  { return _Base::find_first_not_of(__c, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_first_of ( const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos = 0 
) const
inline
782  { return _Base::find_first_of(__str, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_first_of ( const _CharT *  __s,
size_type  __pos,
size_type  __n 
) const
inline
786  {
787  __glibcxx_check_string(__s);
788  return _Base::find_first_of(__s, __pos, __n);
789  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_first_of ( const _CharT *  __s,
size_type  __pos = 0 
) const
inline
793  {
794  __glibcxx_check_string(__s);
795  return _Base::find_first_of(__s, __pos);
796  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_first_of ( _CharT  __c,
size_type  __pos = 0 
) const
inline
800  { return _Base::find_first_of(__c, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_last_not_of ( const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos = _Base::npos 
) const
inline
853  { return _Base::find_last_not_of(__str, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_last_not_of ( const _CharT *  __s,
size_type  __pos,
size_type  __n 
) const
inline
857  {
858  __glibcxx_check_string(__s);
859  return _Base::find_last_not_of(__s, __pos, __n);
860  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_last_not_of ( const _CharT *  __s,
size_type  __pos = _Base::npos 
) const
inline
864  {
865  __glibcxx_check_string(__s);
866  return _Base::find_last_not_of(__s, __pos);
867  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_last_not_of ( _CharT  __c,
size_type  __pos = _Base::npos 
) const
inline
872  { return _Base::find_last_not_of(__c, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_last_of ( const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos = _Base::npos 
) const
inline
805  { return _Base::find_last_of(__str, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_last_of ( const _CharT *  __s,
size_type  __pos,
size_type  __n 
) const
inline
809  {
810  __glibcxx_check_string(__s);
811  return _Base::find_last_of(__s, __pos, __n);
812  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_last_of ( const _CharT *  __s,
size_type  __pos = _Base::npos 
) const
inline
816  {
817  __glibcxx_check_string(__s);
818  return _Base::find_last_of(__s, __pos);
819  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::find_last_of ( _CharT  __c,
size_type  __pos = _Base::npos 
) const
inline
824  { return _Base::find_last_of(__c, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::insert ( size_type  __pos1,
const basic_string< _CharT, _Traits, _Allocator > &  __str 
)
inline
476  {
477  _Base::insert(__pos1, __str);
478  this->_M_invalidate_all();
479  return *this;
480  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::insert ( size_type  __pos1,
const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos2,
size_type  __n 
)
inline
485  {
486  _Base::insert(__pos1, __str, __pos2, __n);
487  this->_M_invalidate_all();
488  return *this;
489  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::insert ( size_type  __pos,
const _CharT *  __s,
size_type  __n 
)
inline
493  {
494  __glibcxx_check_string(__s);
495  _Base::insert(__pos, __s, __n);
496  this->_M_invalidate_all();
497  return *this;
498  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::insert ( size_type  __pos,
const _CharT *  __s 
)
inline
502  {
503  __glibcxx_check_string(__s);
504  _Base::insert(__pos, __s);
505  this->_M_invalidate_all();
506  return *this;
507  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::insert ( size_type  __pos,
size_type  __n,
_CharT  __c 
)
inline
511  {
512  _Base::insert(__pos, __n, __c);
513  this->_M_invalidate_all();
514  return *this;
515  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::insert ( iterator  __p,
_CharT  __c 
)
inline
519  {
520  __glibcxx_check_insert(__p);
521  typename _Base::iterator __res = _Base::insert(__p.base(), __c);
522  this->_M_invalidate_all();
523  return iterator(__res, this);
524  }
__gnu_debug::basic_string::iterator
__gnu_debug::_Safe_iterator< typename _Base::iterator, basic_string > iterator
Definition: string:62
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_insert
#define __glibcxx_check_insert(_Position)
Definition: macros.h:73
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
void __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::insert ( iterator  __p,
size_type  __n,
_CharT  __c 
)
inline
528  {
529  __glibcxx_check_insert(__p);
530  _Base::insert(__p.base(), __n, __c);
531  this->_M_invalidate_all();
532  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_insert
#define __glibcxx_check_insert(_Position)
Definition: macros.h:73
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
template<typename _InputIterator >
void __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::insert ( iterator  __p,
_InputIterator  __first,
_InputIterator  __last 
)
inline
537  {
538  __glibcxx_check_insert_range(__p, __first, __last);
539  _Base::insert(__p.base(), __gnu_debug::__base(__first),
540  __gnu_debug::__base(__last));
541  this->_M_invalidate_all();
542  }
__gnu_debug::__base
_Siter_base< _Iterator >::iterator_type __base(_Iterator __it)
Definition: functions.h:446
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_insert_range
#define __glibcxx_check_insert_range(_Position, _First, _Last)
Definition: macros.h:110
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::operator+= ( const basic_string< _CharT, _Traits, _Allocator > &  __str)
inline
306  {
307  _M_base() += __str;
308  this->_M_invalidate_all();
309  return *this;
310  }
__gnu_debug::basic_string::_M_base
_Base & _M_base() _GLIBCXX_NOEXCEPT
Definition: string:919
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::operator+= ( const _CharT *  __s)
inline
314  {
315  __glibcxx_check_string(__s);
316  _M_base() += __s;
317  this->_M_invalidate_all();
318  return *this;
319  }
__gnu_debug::basic_string::_M_base
_Base & _M_base() _GLIBCXX_NOEXCEPT
Definition: string:919
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::operator+= ( _CharT  __c)
inline
323  {
324  _M_base() += __c;
325  this->_M_invalidate_all();
326  return *this;
327  }
__gnu_debug::basic_string::_M_base
_Base & _M_base() _GLIBCXX_NOEXCEPT
Definition: string:919
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::operator= ( const basic_string< _CharT, _Traits, _Allocator > &  __str)
inline
130  {
131  *static_cast<_Base*>(this) = __str;
132  this->_M_invalidate_all();
133  return *this;
134  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::operator= ( const _CharT *  __s)
inline
138  {
139  __glibcxx_check_string(__s);
140  *static_cast<_Base*>(this) = __s;
141  this->_M_invalidate_all();
142  return *this;
143  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::operator= ( _CharT  __c)
inline
147  {
148  *static_cast<_Base*>(this) = __c;
149  this->_M_invalidate_all();
150  return *this;
151  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__gnu_debug::basic_string::_Base
std::basic_string< _CharT, _Traits, _Allocator > _Base
Definition: string:46
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
const_reference __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::operator[] ( size_type  __pos) const
inline
271  {
272  _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
273  _M_message(__gnu_debug::__msg_subscript_oob)
274  ._M_sequence(*this, "this")
275  ._M_integer(__pos, "__pos")
276  ._M_integer(this->size(), "size"));
277  return _M_base()[__pos];
278  }
__gnu_debug::basic_string::_M_base
_Base & _M_base() _GLIBCXX_NOEXCEPT
Definition: string:919
_GLIBCXX_DEBUG_VERIFY
#define _GLIBCXX_DEBUG_VERIFY(_Condition, _ErrorMessage)
Definition: macros.h:49
__gnu_debug::__msg_subscript_oob
Definition: formatter.h:62
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
reference __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::operator[] ( size_type  __pos)
inline
282  {
283 #ifdef _GLIBCXX_DEBUG_PEDANTIC
284  __glibcxx_check_subscript(__pos);
285 #else
286  // as an extension v3 allows s[s.size()] when s is non-const.
287  _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
288  _M_message(__gnu_debug::__msg_subscript_oob)
289  ._M_sequence(*this, "this")
290  ._M_integer(__pos, "__pos")
291  ._M_integer(this->size(), "size"));
292 #endif
293  return _M_base()[__pos];
294  }
__gnu_debug::basic_string::_M_base
_Base & _M_base() _GLIBCXX_NOEXCEPT
Definition: string:919
__glibcxx_check_subscript
#define __glibcxx_check_subscript(_N)
Definition: macros.h:202
_GLIBCXX_DEBUG_VERIFY
#define _GLIBCXX_DEBUG_VERIFY(_Condition, _ErrorMessage)
Definition: macros.h:49
__gnu_debug::__msg_subscript_oob
Definition: formatter.h:62
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
void __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::push_back ( _CharT  __c)
inline
396  {
397  _Base::push_back(__c);
398  this->_M_invalidate_all();
399  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
reverse_iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::rbegin ( )
inline
191  { return reverse_iterator(end()); }
__gnu_debug::basic_string::reverse_iterator
std::reverse_iterator< iterator > reverse_iterator
Definition: string:66
__gnu_debug::basic_string::end
iterator end() _GLIBCXX_NOEXCEPT
Definition: string:182
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
const_reverse_iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::rbegin ( ) const
inline
195  { return const_reverse_iterator(end()); }
__gnu_debug::basic_string::const_reverse_iterator
std::reverse_iterator< const_iterator > const_reverse_iterator
Definition: string:67
__gnu_debug::basic_string::end
iterator end() _GLIBCXX_NOEXCEPT
Definition: string:182
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
reverse_iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::rend ( )
inline
199  { return reverse_iterator(begin()); }
__gnu_debug::basic_string::reverse_iterator
std::reverse_iterator< iterator > reverse_iterator
Definition: string:66
__gnu_debug::basic_string::begin
iterator begin() _GLIBCXX_NOEXCEPT
Definition: string:174
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
const_reverse_iterator __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::rend ( ) const
inline
203  { return const_reverse_iterator(begin()); }
__gnu_debug::basic_string::const_reverse_iterator
std::reverse_iterator< const_iterator > const_reverse_iterator
Definition: string:67
__gnu_debug::basic_string::begin
iterator begin() _GLIBCXX_NOEXCEPT
Definition: string:174
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::replace ( size_type  __pos1,
size_type  __n1,
const basic_string< _CharT, _Traits, _Allocator > &  __str 
)
inline
595  {
596  _Base::replace(__pos1, __n1, __str);
597  this->_M_invalidate_all();
598  return *this;
599  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::replace ( size_type  __pos1,
size_type  __n1,
const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos2,
size_type  __n2 
)
inline
604  {
605  _Base::replace(__pos1, __n1, __str, __pos2, __n2);
606  this->_M_invalidate_all();
607  return *this;
608  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::replace ( size_type  __pos,
size_type  __n1,
const _CharT *  __s,
size_type  __n2 
)
inline
613  {
614  __glibcxx_check_string_len(__s, __n2);
615  _Base::replace(__pos, __n1, __s, __n2);
616  this->_M_invalidate_all();
617  return *this;
618  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_string_len
#define __glibcxx_check_string_len(_String, _Len)
Definition: macros.h:350
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::replace ( size_type  __pos,
size_type  __n1,
const _CharT *  __s 
)
inline
622  {
623  __glibcxx_check_string(__s);
624  _Base::replace(__pos, __n1, __s);
625  this->_M_invalidate_all();
626  return *this;
627  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::replace ( size_type  __pos,
size_type  __n1,
size_type  __n2,
_CharT  __c 
)
inline
631  {
632  _Base::replace(__pos, __n1, __n2, __c);
633  this->_M_invalidate_all();
634  return *this;
635  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::replace ( iterator  __i1,
iterator  __i2,
const basic_string< _CharT, _Traits, _Allocator > &  __str 
)
inline
639  {
640  __glibcxx_check_erase_range(__i1, __i2);
641  _Base::replace(__i1.base(), __i2.base(), __str);
642  this->_M_invalidate_all();
643  return *this;
644  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_erase_range
#define __glibcxx_check_erase_range(_First, _Last)
Definition: macros.h:163
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::replace ( iterator  __i1,
iterator  __i2,
const _CharT *  __s,
size_type  __n 
)
inline
648  {
649  __glibcxx_check_erase_range(__i1, __i2);
650  __glibcxx_check_string_len(__s, __n);
651  _Base::replace(__i1.base(), __i2.base(), __s, __n);
652  this->_M_invalidate_all();
653  return *this;
654  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_erase_range
#define __glibcxx_check_erase_range(_First, _Last)
Definition: macros.h:163
__glibcxx_check_string_len
#define __glibcxx_check_string_len(_String, _Len)
Definition: macros.h:350
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::replace ( iterator  __i1,
iterator  __i2,
const _CharT *  __s 
)
inline
658  {
659  __glibcxx_check_erase_range(__i1, __i2);
660  __glibcxx_check_string(__s);
661  _Base::replace(__i1.base(), __i2.base(), __s);
662  this->_M_invalidate_all();
663  return *this;
664  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_erase_range
#define __glibcxx_check_erase_range(_First, _Last)
Definition: macros.h:163
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::replace ( iterator  __i1,
iterator  __i2,
size_type  __n,
_CharT  __c 
)
inline
668  {
669  __glibcxx_check_erase_range(__i1, __i2);
670  _Base::replace(__i1.base(), __i2.base(), __n, __c);
671  this->_M_invalidate_all();
672  return *this;
673  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_erase_range
#define __glibcxx_check_erase_range(_First, _Last)
Definition: macros.h:163
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
template<typename _InputIterator >
basic_string& __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::replace ( iterator  __i1,
iterator  __i2,
_InputIterator  __j1,
_InputIterator  __j2 
)
inline
679  {
680  __glibcxx_check_erase_range(__i1, __i2);
681  __glibcxx_check_valid_range(__j1, __j2);
682  _Base::replace(__i1.base(), __i2.base(), __j1, __j2);
683  this->_M_invalidate_all();
684  return *this;
685  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
__glibcxx_check_valid_range
#define __glibcxx_check_valid_range(_First, _Last)
Definition: macros.h:53
__glibcxx_check_erase_range
#define __glibcxx_check_erase_range(_First, _Last)
Definition: macros.h:163
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
void __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::resize ( size_type  __n,
_CharT  __c 
)
inline
230  {
231  _Base::resize(__n, __c);
232  this->_M_invalidate_all();
233  }
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
void __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::resize ( size_type  __n)
inline
237  { this->resize(__n, _CharT()); }
__gnu_debug::basic_string::resize
void resize(size_type __n, _CharT __c)
Definition: string:229
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::rfind ( const basic_string< _CharT, _Traits, _Allocator > &  __str,
size_type  __pos = _Base::npos 
) const
inline
759  { return _Base::rfind(__str, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::rfind ( const _CharT *  __s,
size_type  __pos,
size_type  __n 
) const
inline
763  {
764  __glibcxx_check_string_len(__s, __n);
765  return _Base::rfind(__s, __pos, __n);
766  }
__glibcxx_check_string_len
#define __glibcxx_check_string_len(_String, _Len)
Definition: macros.h:350
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::rfind ( const _CharT *  __s,
size_type  __pos = _Base::npos 
) const
inline
770  {
771  __glibcxx_check_string(__s);
772  return _Base::rfind(__s, __pos);
773  }
__glibcxx_check_string
#define __glibcxx_check_string(_String)
Definition: macros.h:349
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
size_type __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::rfind ( _CharT  __c,
size_type  __pos = _Base::npos 
) const
inline
777  { return _Base::rfind(__c, __pos); }
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
basic_string __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::substr ( size_type  __pos = 0,
size_type  __n = _Base::npos 
) const
inline
876  { return basic_string(_Base::substr(__pos, __n)); }
__gnu_debug::basic_string::basic_string
basic_string(const _Allocator &__a=_Allocator())
Definition: string:72
template<typename _CharT, typename _Traits = std::char_traits<_CharT>, typename _Allocator = std::allocator<_CharT>>
void __gnu_debug::basic_string< _CharT, _Traits, _Allocator >::swap ( basic_string< _CharT, _Traits, _Allocator > &  __x)
inline
707  {
708  _Base::swap(__x);
709  this->_M_swap(__x);
710  this->_M_invalidate_all();
711  __x._M_invalidate_all();
712  }
__gnu_debug::_Safe_sequence_base::_M_swap
void _M_swap(_Safe_sequence_base &__x)
__gnu_debug::swap
void swap(basic_string< _CharT, _Traits, _Allocator > &__lhs, basic_string< _CharT, _Traits, _Allocator > &__rhs)
Definition: string:1110
__gnu_debug::_Safe_sequence_base::_M_invalidate_all
void _M_invalidate_all() const
Definition: safe_base.h:233
The documentation for this class was generated from the following file:
Generated on Sat Jul 22 2017 14:43:05 for STLdoc by   doxygen 1.8.6