include/c++/stlport/stl/debug/_string.h

   1 /*
   2  * Copyright (c) 1997-1999
   3  * Silicon Graphics Computer Systems, Inc.
   4  *
   5  * Copyright (c) 1999
   6  * Boris Fomitchev
   7  *
   8  * This material is provided "as is", with absolutely no warranty expressed
   9  * or implied. Any use is at your own risk.
  10  *
  11  * Permission to use or copy this software for any purpose is hereby granted
  12  * without fee, provided the above notices are retained on all copies.
  13  * Permission to modify the code and to distribute modified code is granted,
  14  * provided the above notices are retained, and a notice that the code was
  15  * modified is included with the above copyright notice.
  16  */
  17
  18 #ifndef _STLP_DBG_STRING_H
  19 #define _STLP_DBG_STRING_H
  20
  21 #ifndef _STLP_DBG_ITERATOR_H
  22 #  include <stl/debug/_iterator.h>
  23 #endif
  24
  25 _STLP_BEGIN_NAMESPACE
  26
  27 #define _STLP_NON_DBG_STRING_NAME _STLP_NON_DBG_NAME(str)
  28 #define _STLP_NON_DBG_STRING _STLP_PRIV _STLP_NON_DBG_STRING_NAME <_CharT, _Traits, _Alloc>
  29
  30 #if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
  31 template <class _CharT,class _Traits, class _Alloc>
  32 inline _CharT*
  33 value_type(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_STRING >&)
  34 { return (_CharT*)0; }
  35 template <class _CharT, class _Traits, class _Alloc>
  36 inline random_access_iterator_tag
  37 iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_STRING >&)
  38 { return random_access_iterator_tag(); }
  39 #endif
  40
  41 template <class _CharT, class _Traits, class _Alloc>
  42 class basic_string :
  43 #if !defined (__DMC__)
  44                      private
  45 #else
  46                      public
  47 #endif
  48                              _STLP_PRIV __construct_checker<_STLP_NON_DBG_STRING >
  49 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (basic_string)
  50                    , public __stlport_class<basic_string<_CharT, _Traits, _Alloc> >
  51 #endif
  52 {
  53 protected:
  54   typedef _STLP_NON_DBG_STRING _Base;
  55   typedef basic_string<_CharT, _Traits, _Alloc> _Self;
  56   typedef _STLP_PRIV __construct_checker<_STLP_NON_DBG_STRING > _ConstructCheck;
  57   typedef typename _IsPOD<_CharT>::_Type _Char_Is_POD;
  58
  59 public:
  60   __IMPORT_CONTAINER_TYPEDEFS(_Base)
  61   typedef typename _Base::traits_type traits_type;
  62   typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Nonconst_traits<value_type> > > iterator;
  63   typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Const_traits<value_type> > > const_iterator;
  64   _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
  65
  66 public:                         // Constructor, destructor, assignment.
  67   typedef typename _Base::_Reserve_t _Reserve_t;
  68
  69 private:
  70   _Base _M_non_dbg_impl;
  71   _STLP_PRIV __owned_list _M_iter_list;
  72
  73   void _Invalidate_all()
  74   { _M_iter_list._Invalidate_all(); }
  75   void _Compare_Capacity (size_type __old_capacity) {
  76     if (this->capacity() > __old_capacity) {
  77       _Invalidate_all();
  78     }
  79   }
  80   void _Invalidate_iterator(const iterator& __it)
  81   { _STLP_PRIV __invalidate_iterator(&_M_iter_list, __it); }
  82   void _Invalidate_iterators(const iterator& __f, const iterator& __l)
  83   { _STLP_PRIV __invalidate_range(&_M_iter_list, __f, __l); }
  84
  85 public:
  86 #include <stl/_string_npos.h>
  87
  88   allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
  89
  90   explicit basic_string(const allocator_type& __a = allocator_type())
  91     : _M_non_dbg_impl(__a), _M_iter_list(&_M_non_dbg_impl) {}
  92
  93   basic_string(_Reserve_t __r, size_t __n,
  94                const allocator_type& __a = allocator_type())
  95     : _M_non_dbg_impl(__r, __n, __a), _M_iter_list(&_M_non_dbg_impl) {}
  96
  97   basic_string(const _Self& __s)
  98     : _ConstructCheck(__s),
  99       _M_non_dbg_impl(__s._M_non_dbg_impl), _M_iter_list(&_M_non_dbg_impl) {}
 100
 101   basic_string(const _Self& __s, size_type __pos, size_type __n = npos,
 102                const allocator_type& __a = allocator_type())
 103     : _M_non_dbg_impl(__s._M_non_dbg_impl, __pos, __n, __a),
 104       _M_iter_list(&_M_non_dbg_impl) {}
 105
 106   basic_string(const _CharT* __s, size_type __n,
 107                const allocator_type& __a = allocator_type())
 108     : _ConstructCheck(__s), _M_non_dbg_impl(__s, __n, __a),
 109       _M_iter_list(&_M_non_dbg_impl) {}
 110
 111   basic_string(const _CharT* __s,
 112                const allocator_type& __a = allocator_type())
 113     : _ConstructCheck(__s),
 114       _M_non_dbg_impl(__s, __a), _M_iter_list(&_M_non_dbg_impl) {}
 115
 116   basic_string(size_type __n, _CharT __c,
 117                const allocator_type& __a = allocator_type())
 118     : _M_non_dbg_impl(__n, __c, __a), _M_iter_list(&_M_non_dbg_impl) {}
 119
 120 #if !defined (_STLP_NO_MOVE_SEMANTIC)
 121   basic_string(__move_source<_Self> src)
 122     : _M_non_dbg_impl(__move_source<_Base >(src.get()._M_non_dbg_impl)),
 123       _M_iter_list(&_M_non_dbg_impl) {
 124 #  if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
 125     src.get()._M_iter_list._Invalidate_all();
 126 #  else
 127     src.get()._M_iter_list._Set_owner(_M_iter_list);
 128 #  endif
 129   }
 130 #endif
 131
 132 #if !defined (_STLP_MEMBER_TEMPLATES)
 133   basic_string(const _CharT* __f, const _CharT* __l,
 134                const allocator_type& __a = allocator_type())
 135     : _ConstructCheck(__f, __l),
 136       _M_non_dbg_impl(__f, __l, __a), _M_iter_list(&_M_non_dbg_impl) {
 137   }
 138   basic_string(const_iterator __f, const_iterator __l,
 139                const allocator_type & __a = allocator_type())
 140     : _ConstructCheck(__f, __l),
 141       _M_non_dbg_impl(__f._M_iterator, __l._M_iterator, __a), _M_iter_list(&_M_non_dbg_impl) {
 142   }
 143 #else
 144   template <class _InputIterator>
 145   basic_string(_InputIterator __f, _InputIterator __l,
 146                const allocator_type & __a _STLP_ALLOCATOR_TYPE_DFL)
 147     : _ConstructCheck(__f, __l),
 148       _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__f), _STLP_PRIV _Non_Dbg_iter(__l), __a),
 149       _M_iter_list(&_M_non_dbg_impl) {}
 150 #  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
 151   template <class _InputIterator>
 152   basic_string(_InputIterator __f, _InputIterator __l)
 153     : _ConstructCheck(__f, __l),
 154       _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__f), _STLP_PRIV _Non_Dbg_iter(__l)),
 155       _M_iter_list(&_M_non_dbg_impl) {}
 156 #  endif
 157 #endif
 158
 159 private:
 160   // constructor from non-debug version for substr
 161   basic_string (const _Base& __x)
 162     : _M_non_dbg_impl(__x), _M_iter_list(&_M_non_dbg_impl) {}
 163
 164 public:
 165   _Self& operator=(const _Self& __s) {
 166     if (this != &__s) {
 167       assign(__s);
 168     }
 169     return *this;
 170   }
 171
 172   _Self& operator=(const _CharT* __s) {
 173     _STLP_FIX_LITERAL_BUG(__s)
 174     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 175     return assign(__s);
 176   }
 177
 178   _Self& operator=(_CharT __c) {
 179     return assign(1, __c);
 180   }
 181
 182   // Iterators.
 183   iterator begin() { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
 184   const_iterator begin() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
 185   iterator end() { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
 186   const_iterator end() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
 187
 188   reverse_iterator rbegin()             { return reverse_iterator(end()); }
 189   const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
 190   reverse_iterator rend()               { return reverse_iterator(begin()); }
 191   const_reverse_iterator rend() const   { return const_reverse_iterator(begin()); }
 192
 193   // Size, capacity, etc.
 194   size_type size() const { return _M_non_dbg_impl.size(); }
 195   size_type length() const { return _M_non_dbg_impl.length(); }
 196   size_t max_size() const { return _M_non_dbg_impl.max_size(); }
 197
 198   void resize(size_type __n, _CharT __c) {
 199     if (__n > capacity())
 200       _Invalidate_all();
 201     else if (__n < size())
 202       _Invalidate_iterators(begin() + __n, end());
 203     _M_non_dbg_impl.resize(__n, __c);
 204   }
 205   void resize(size_type __n) { resize(__n, _STLP_DEFAULT_CONSTRUCTED(_CharT)); }
 206   size_type capacity() const { return _M_non_dbg_impl.capacity(); }
 207
 208   void reserve(size_type __s = 0) {
 209     if (__s > capacity()) _Invalidate_all();
 210     _M_non_dbg_impl.reserve(__s);
 211   }
 212
 213   void clear() {
 214     _Invalidate_all();
 215     _M_non_dbg_impl.clear();
 216   }
 217
 218   bool empty() const { return _M_non_dbg_impl.empty(); }
 219
 220   const_reference operator[](size_type __n) const {
 221     _STLP_VERBOSE_ASSERT(__n <= this->size(), _StlMsg_OUT_OF_BOUNDS);
 222     return _M_non_dbg_impl[__n];
 223   }
 224
 225   reference operator[](size_type __n) {
 226     _STLP_VERBOSE_ASSERT(__n < this->size(), _StlMsg_OUT_OF_BOUNDS)
 227     return _M_non_dbg_impl[__n];
 228   }
 229
 230   const_reference at(size_type __n) const { return _M_non_dbg_impl.at(__n); }
 231   reference at(size_type __n) { return _M_non_dbg_impl.at(__n); }
 232
 233   // Append, operator+=, push_back.
 234   _Self& operator+=(const _Self& __s) { return append(__s); }
 235   _Self& operator+=(const _CharT* __s) {
 236     _STLP_FIX_LITERAL_BUG(__s)
 237     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 238     return append(__s);
 239   }
 240   _Self& operator+=(_CharT __c) { return append(1, __c); }
 241
 242 #if defined (_STLP_MEMBER_TEMPLATES)
 243   template <class _InputIter>
 244   _Self& append(_InputIter __first, _InputIter __last) {
 245     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 246     size_type __old_capacity = capacity();
 247     _M_non_dbg_impl.append(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
 248     _Compare_Capacity(__old_capacity);
 249     return *this;
 250   }
 251 #endif
 252
 253 #if !defined (_STLP_MEMBER_TEMPLATES) || \
 254     !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
 255   _Self& append(const _CharT* __f, const _CharT* __l) {
 256     _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
 257     _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f, __l))
 258     size_type __old_capacity = capacity();
 259     _M_non_dbg_impl.append(__f, __l);
 260     _Compare_Capacity(__old_capacity);
 261     return *this;
 262   }
 263
 264   _Self& append(const_iterator __f, const_iterator __l) {
 265     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
 266     size_type __old_capacity = capacity();
 267     _M_non_dbg_impl.append(__f._M_iterator, __l._M_iterator);
 268     _Compare_Capacity(__old_capacity);
 269     return *this;
 270   }
 271 #endif
 272
 273   _Self& append(const _Self& __s) {
 274     size_type __old_capacity = capacity();
 275     _M_non_dbg_impl.append(__s._M_non_dbg_impl);
 276     _Compare_Capacity(__old_capacity);
 277     return *this;
 278   }
 279
 280   _Self& append(const _Self& __s, size_type __pos, size_type __n) {
 281     size_type __old_capacity = capacity();
 282     _M_non_dbg_impl.append(__s._M_non_dbg_impl, __pos, __n);
 283     _Compare_Capacity(__old_capacity);
 284     return *this;
 285   }
 286
 287   _Self& append(const _CharT* __s, size_type __n) {
 288     _STLP_FIX_LITERAL_BUG(__s)
 289     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 290     size_type __old_capacity = capacity();
 291     _M_non_dbg_impl.append(__s, __n);
 292     _Compare_Capacity(__old_capacity);
 293     return *this;
 294   }
 295
 296   _Self& append(const _CharT* __s) {
 297     _STLP_FIX_LITERAL_BUG(__s)
 298     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 299     size_type __old_capacity = capacity();
 300     _M_non_dbg_impl.append(__s);
 301     _Compare_Capacity(__old_capacity);
 302     return *this;
 303   }
 304
 305   _Self& append(size_type __n, _CharT __c) {
 306     size_type __old_capacity = this->capacity();
 307     _M_non_dbg_impl.append(__n, __c);
 308     _Compare_Capacity(__old_capacity);
 309     return *this;
 310   }
 311
 312   void push_back(_CharT __c) {
 313     size_type __old_capacity = this->capacity();
 314     _M_non_dbg_impl.push_back(__c);
 315     _Compare_Capacity(__old_capacity);
 316   }
 317
 318   void pop_back() {
 319     _Invalidate_iterator(this->end());
 320     _M_non_dbg_impl.pop_back();
 321   }
 322
 323   // Assign
 324   _Self& assign(const _Self& __s) {
 325     _Invalidate_all();
 326     _M_non_dbg_impl.assign(__s._M_non_dbg_impl);
 327     return *this;
 328   }
 329
 330   _Self& assign(const _Self& __s, size_type __pos, size_type __n) {
 331     if (__pos < __s.size()) {
 332       _Invalidate_all();
 333     }
 334     _M_non_dbg_impl.assign(__s._M_non_dbg_impl, __pos, __n);
 335     return *this;
 336   }
 337
 338   _Self& assign(const _CharT* __s, size_type __n) {
 339     _STLP_FIX_LITERAL_BUG(__s)
 340     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 341     _Invalidate_all();
 342     _M_non_dbg_impl.assign(__s, __s + __n);
 343     return *this;
 344   }
 345
 346   _Self& assign(const _CharT* __s) {
 347     _STLP_FIX_LITERAL_BUG(__s)
 348     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 349     _Invalidate_all();
 350     _M_non_dbg_impl.assign(__s);
 351     return *this;
 352   }
 353
 354   _Self& assign(size_type __n, _CharT __c) {
 355     _Invalidate_all();
 356     _M_non_dbg_impl.assign(__n, __c);
 357     return *this;
 358   }
 359
 360 #if defined(_STLP_MEMBER_TEMPLATES)
 361   template <class _InputIter>
 362   inline _Self& assign(_InputIter __first, _InputIter __last) {
 363     _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
 364     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
 365     _Invalidate_all();
 366     _M_non_dbg_impl.assign(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
 367     return *this;
 368   }
 369 #endif
 370
 371 #if !defined (_STLP_MEMBER_TEMPLATES) || \
 372     !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
 373   _Self& assign(const _CharT* __f, const _CharT* __l) {
 374     _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
 375     _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f, __l))
 376     _Invalidate_all();
 377     _M_non_dbg_impl.assign(__f, __l);
 378     return *this;
 379   }
 380   _Self& assign(const_iterator __f, const_iterator __l) {
 381     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
 382     _Invalidate_all();
 383     _M_non_dbg_impl.assign(__f._M_iterator, __l._M_iterator);
 384     return *this;
 385   }
 386 #endif
 387
 388   // Insert
 389   _Self& insert(size_type __pos, const _Self& __s) {
 390     size_type __old_capacity = capacity();
 391     _M_non_dbg_impl.insert(__pos, __s._M_non_dbg_impl);
 392     _Compare_Capacity(__old_capacity);
 393     return *this;
 394   }
 395
 396   _Self& insert(size_type __pos, const _Self& __s,
 397                 size_type __beg, size_type __n) {
 398     size_type __old_capacity = capacity();
 399     _M_non_dbg_impl.insert(__pos, __s._M_non_dbg_impl, __beg, __n);
 400     _Compare_Capacity(__old_capacity);
 401     return *this;
 402   }
 403
 404   _Self& insert(size_type __pos, const _CharT* __s, size_type __n) {
 405     _STLP_FIX_LITERAL_BUG(__s)
 406     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 407     size_type __old_capacity = capacity();
 408     _M_non_dbg_impl.insert(__pos, __s, __n);
 409     _Compare_Capacity(__old_capacity);
 410     return *this;
 411   }
 412
 413   _Self& insert(size_type __pos, const _CharT* __s) {
 414     _STLP_FIX_LITERAL_BUG(__s)
 415     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 416     return insert(__pos, __s, _Traits::length(__s));
 417   }
 418
 419   _Self& insert(size_type __pos, size_type __n, _CharT __c) {
 420     size_type __old_capacity = capacity();
 421     _M_non_dbg_impl.insert(__pos, __n, __c);
 422     _Compare_Capacity(__old_capacity);
 423     return *this;
 424   }
 425
 426   iterator insert(iterator __p, _CharT __c) {
 427     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
 428     size_type __old_capacity = capacity();
 429     typename _Base::iterator __ret = _M_non_dbg_impl.insert(__p._M_iterator, __c);
 430     _Compare_Capacity(__old_capacity);
 431     return iterator(&_M_iter_list, __ret);
 432   }
 433
 434   void insert(iterator __p, size_t __n, _CharT __c) {
 435     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
 436     size_type __old_capacity = capacity();
 437     _M_non_dbg_impl.insert(__p._M_iterator, __n, __c);
 438     _Compare_Capacity(__old_capacity);
 439   }
 440
 441 #if defined (_STLP_MEMBER_TEMPLATES)
 442   template <class _InputIter>
 443   void insert(iterator __p, _InputIter __first, _InputIter __last) {
 444     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
 445     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first,__last))
 446
 447     size_type __old_capacity = this->capacity();
 448     _M_non_dbg_impl.insert(__p._M_iterator,
 449                            _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
 450     _Compare_Capacity(__old_capacity);
 451   }
 452 #endif
 453
 454 #if !defined (_STLP_MEMBER_TEMPLATES)
 455   void insert(iterator __p, const _CharT* __f, const _CharT* __l) {
 456     _STLP_FIX_LITERAL_BUG(__f)_STLP_FIX_LITERAL_BUG(__l)
 457     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
 458     _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f,__l))
 459     size_type __old_capacity = capacity();
 460     _M_non_dbg_impl.insert(__p._M_iterator, __f, __l);
 461     _Compare_Capacity(__old_capacity);
 462   }
 463 #endif
 464
 465 #if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
 466   // Those overloads are necessary to check self referencing correctly in non debug
 467   // basic_string implementation
 468   void insert(iterator __p, const_iterator __f, const_iterator __l) {
 469     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
 470     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f,__l))
 471 #  if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
 472     _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __f))
 473 #  endif
 474     size_type __old_capacity = capacity();
 475     _M_non_dbg_impl.insert(__p._M_iterator, __f._M_iterator, __l._M_iterator);
 476     _Compare_Capacity(__old_capacity);
 477   }
 478   void insert(iterator __p, iterator __f, iterator __l) {
 479     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
 480     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f,__l))
 481 #  if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
 482     _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __f))
 483 #  endif
 484     size_type __old_capacity = capacity();
 485     _M_non_dbg_impl.insert(__p._M_iterator, __f._M_iterator, __l._M_iterator);
 486     _Compare_Capacity(__old_capacity);
 487   }
 488 #endif
 489
 490   // Erase.
 491   _Self& erase(size_type __pos = 0, size_type __n = npos) {
 492     if (__pos < size()) {
 493       _Invalidate_iterators(begin() + __pos, end());
 494     }
 495     _M_non_dbg_impl.erase(__pos, __n);
 496     return *this;
 497   }
 498   iterator erase(iterator __pos) {
 499     _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
 500     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
 501     _Invalidate_iterators(__pos, end());
 502     return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__pos._M_iterator));
 503   }
 504   iterator erase(iterator __f, iterator __l) {
 505     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
 506     _Invalidate_iterators(__f, end());
 507     return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__f._M_iterator, __l._M_iterator));
 508   }
 509
 510   // Substring.
 511   _Self substr(size_type __pos = 0, size_type __n = npos) const
 512   { return _M_non_dbg_impl.substr(__pos, __n); }
 513
 514   // Replace.  (Conceptually equivalent to erase followed by insert.)
 515   _Self& replace(size_type __pos, size_type __n, const _Self& __s) {
 516     size_type __old_capacity = capacity();
 517     _M_non_dbg_impl.replace(__pos, __n, __s._M_non_dbg_impl);
 518     _Compare_Capacity(__old_capacity);
 519     return *this;
 520   }
 521
 522   _Self& replace(size_type __pos1, size_type __n1, const _Self& __s,
 523                  size_type __pos2, size_type __n2) {
 524     size_type __old_capacity = capacity();
 525     _M_non_dbg_impl.replace(__pos1, __n1, __s._M_non_dbg_impl, __pos2, __n2);
 526     _Compare_Capacity(__old_capacity);
 527     return *this;
 528   }
 529
 530   _Self& replace(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) {
 531     _STLP_FIX_LITERAL_BUG(__s)
 532     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 533     size_type __old_capacity = capacity();
 534     _M_non_dbg_impl.replace(__pos, __n1, __s, __n2);
 535     _Compare_Capacity(__old_capacity);
 536     return *this;
 537   }
 538
 539   _Self& replace(size_type __pos, size_type __n1, const _CharT* __s) {
 540     _STLP_FIX_LITERAL_BUG(__s)
 541     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 542     size_type __old_capacity = capacity();
 543     _M_non_dbg_impl.replace(__pos, __n1, __s);
 544     _Compare_Capacity(__old_capacity);
 545     return *this;
 546   }
 547
 548   _Self& replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) {
 549     size_type __old_capacity = capacity();
 550     _M_non_dbg_impl.replace(__pos, __n1, __n2, __c);
 551     _Compare_Capacity(__old_capacity);
 552     return *this;
 553   }
 554
 555   _Self& replace(iterator __f, iterator __l, const _Self& __s) {
 556     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
 557     size_type __old_capacity = capacity();
 558     _M_non_dbg_impl.replace(__f._M_iterator, __l._M_iterator, __s._M_non_dbg_impl);
 559     _Compare_Capacity(__old_capacity);
 560     return *this;
 561   }
 562
 563   _Self& replace(iterator __f, iterator __l, const _CharT* __s, size_type __n) {
 564     _STLP_FIX_LITERAL_BUG(__s)
 565     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
 566     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 567     size_type __old_capacity = capacity();
 568     _M_non_dbg_impl.replace(__f._M_iterator, __l._M_iterator, __s, __n);
 569     _Compare_Capacity(__old_capacity);
 570     return *this;
 571   }
 572
 573   _Self& replace(iterator __f, iterator __l, const _CharT* __s) {
 574     _STLP_FIX_LITERAL_BUG(__s)
 575     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
 576     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 577     size_type __old_capacity = capacity();
 578     _M_non_dbg_impl.replace(__f._M_iterator, __l._M_iterator, __s);
 579     _Compare_Capacity(__old_capacity);
 580     return *this;
 581   }
 582
 583   _Self& replace(iterator __f, iterator __l, size_type __n, _CharT __c) {
 584     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
 585     size_type __old_capacity = capacity();
 586     _M_non_dbg_impl.replace(__f._M_iterator, __l._M_iterator, __n, __c);
 587     _Compare_Capacity(__old_capacity);
 588     return *this;
 589   }
 590
 591 #if defined (_STLP_MEMBER_TEMPLATES)
 592   template <class _InputIter>
 593   _Self& replace(iterator __first, iterator __last,
 594                  _InputIter __f, _InputIter __l) {
 595     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
 596     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
 597
 598     size_type __old_capacity = capacity();
 599     _M_non_dbg_impl.replace(__first._M_iterator, __last._M_iterator,
 600                             _STLP_PRIV _Non_Dbg_iter(__f), _STLP_PRIV _Non_Dbg_iter(__l));
 601     _Compare_Capacity(__old_capacity);
 602     return *this;
 603   }
 604 #endif
 605
 606 #if !defined (_STLP_MEMBER_TEMPLATES)
 607   _Self& replace(iterator __first, iterator __last,
 608                  const _CharT* __f, const _CharT* __l) {
 609     _STLP_FIX_LITERAL_BUG(__f)_STLP_FIX_LITERAL_BUG(__l)
 610     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
 611     _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f, __l))
 612     size_type __old_capacity = capacity();
 613     _M_non_dbg_impl.replace(__first._M_iterator, __last._M_iterator, __f, __l);
 614     _Compare_Capacity(__old_capacity);
 615     return *this;
 616   }
 617 #endif
 618
 619 #if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
 620   _Self& replace(iterator __first, iterator __last,
 621                  const_iterator __f, const_iterator __l) {
 622     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
 623     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
 624     size_type __old_capacity = capacity();
 625     _M_non_dbg_impl.replace(__first._M_iterator, __last._M_iterator,
 626                             __f._M_iterator, __l._M_iterator);
 627     _Compare_Capacity(__old_capacity);
 628     return *this;
 629   }
 630   _Self& replace(iterator __first, iterator __last,
 631                  iterator __f, iterator __l) {
 632     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
 633     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
 634     size_type __old_capacity = capacity();
 635     _M_non_dbg_impl.replace(__first._M_iterator, __last._M_iterator,
 636                             __f._M_iterator, __l._M_iterator);
 637     _Compare_Capacity(__old_capacity);
 638     return *this;
 639   }
 640 #endif
 641
 642   // Other modifier member functions.
 643   void swap(_Self& __s) {
 644     _M_iter_list._Swap_owners(__s._M_iter_list);
 645     _M_non_dbg_impl.swap(__s._M_non_dbg_impl);
 646   }
 647 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
 648   void _M_swap_workaround(_Self& __x) { swap(__x); }
 649 #endif
 650
 651   int compare(const _Self& __s) const
 652   { return _M_non_dbg_impl.compare(__s._M_non_dbg_impl); }
 653   int compare(size_type __pos, size_type __n, const _Self& __s) const
 654   { return _M_non_dbg_impl.compare(__pos, __n, __s._M_non_dbg_impl); }
 655   int compare(size_type __pos1, size_type __n1, const _Self& __s,
 656               size_type __pos2, size_type __n2) const
 657   { return _M_non_dbg_impl.compare(__pos1, __n1, __s._M_non_dbg_impl, __pos2, __n2); }
 658   int compare(const _CharT* __s) const {
 659     _STLP_FIX_LITERAL_BUG(__s)
 660     return _M_non_dbg_impl.compare(__s);
 661   }
 662   int compare(size_type __pos, size_type __n, const _CharT* __s) const {
 663     _STLP_FIX_LITERAL_BUG(__s)
 664     return _M_non_dbg_impl.compare(__pos, __n, __s);
 665   }
 666   int compare(size_type __pos1, size_type __n1, const _CharT* __s,
 667               size_type __n2) const {
 668     _STLP_FIX_LITERAL_BUG(__s)
 669     return _M_non_dbg_impl.compare(__pos1, __n1, __s, __n2);
 670   }
 671
 672   // Helper functions for compare.
 673   static int _STLP_CALL _M_compare(const _CharT* __f1, const _CharT* __l1,
 674                                    const _CharT* __f2, const _CharT* __l2)
 675   { return _Base::_M_compare(__f1, __l1, __f2, __l2); }
 676   static int _STLP_CALL _M_compare(const_iterator __f1, const_iterator __l1,
 677                                    const _CharT* __f2, const _CharT* __l2)
 678   { return _Base::_M_compare(__f1._M_iterator, __l1._M_iterator, __f2, __l2); }
 679   static int _STLP_CALL _M_compare(const _CharT* __f1, const _CharT* __l1,
 680                                    const_iterator __f2, const_iterator __l2)
 681   { return _Base::_M_compare(__f1, __l1, __f2._M_iterator, __l2._M_iterator); }
 682   static int _STLP_CALL _M_compare(const_iterator __f1, const_iterator __l1,
 683                                    const_iterator __f2, const_iterator __l2)
 684   { return _Base::_M_compare(__f1._M_iterator, __l1._M_iterator, __f2._M_iterator, __l2._M_iterator); }
 685
 686   const _CharT* c_str() const { return _M_non_dbg_impl.c_str(); }
 687   const _CharT* data()  const { return _M_non_dbg_impl.data(); }
 688
 689   size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
 690   { return _M_non_dbg_impl.copy(__s, __n, __pos); }
 691
 692   // find.
 693   size_type find(const _Self& __s, size_type __pos = 0) const
 694   { return _M_non_dbg_impl.find(__s._M_non_dbg_impl, __pos); }
 695   size_type find(const _CharT* __s, size_type __pos = 0) const {
 696     _STLP_FIX_LITERAL_BUG(__s)
 697     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 698     return _M_non_dbg_impl.find(__s, __pos);
 699   }
 700   size_type find(const _CharT* __s, size_type __pos, size_type __n) const {
 701     _STLP_FIX_LITERAL_BUG(__s)
 702     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 703     return _M_non_dbg_impl.find(__s, __pos, __n);
 704   }
 705   // WIE: Versant schema compiler 5.2.2 ICE workaround
 706   size_type find(_CharT __c) const { return find(__c, 0); }
 707   size_type find(_CharT __c, size_type __pos /* = 0 */) const
 708   { return _M_non_dbg_impl.find(__c, __pos); }
 709
 710   // rfind.
 711   size_type rfind(const _Self& __s, size_type __pos = npos) const
 712   { return _M_non_dbg_impl.rfind(__s._M_non_dbg_impl, __pos); }
 713   size_type rfind(const _CharT* __s, size_type __pos = npos) const {
 714     _STLP_FIX_LITERAL_BUG(__s)
 715     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 716     return _M_non_dbg_impl.rfind(__s, __pos);
 717   }
 718   size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const {
 719     _STLP_FIX_LITERAL_BUG(__s)
 720     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 721     return _M_non_dbg_impl.rfind(__s, __pos, __n);
 722   }
 723   size_type rfind(_CharT __c, size_type __pos = npos) const
 724   { return _M_non_dbg_impl.rfind(__c, __pos); }
 725
 726   // find_first_of
 727   size_type find_first_of(const _Self& __s, size_type __pos = 0) const
 728   { return _M_non_dbg_impl.find_first_of(__s._M_non_dbg_impl, __pos); }
 729   size_type find_first_of(const _CharT* __s, size_type __pos = 0) const {
 730     _STLP_FIX_LITERAL_BUG(__s)
 731     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 732     return _M_non_dbg_impl.find_first_of(__s, __pos);
 733   }
 734   size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const {
 735     _STLP_FIX_LITERAL_BUG(__s)
 736     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 737     return _M_non_dbg_impl.find_first_of(__s, __pos, __n);
 738   }
 739   size_type find_first_of(_CharT __c, size_type __pos = 0) const
 740   { return _M_non_dbg_impl.find_first_of(__c, __pos); }
 741
 742   // find_last_of
 743   size_type find_last_of(const _Self& __s, size_type __pos = npos) const
 744   { return _M_non_dbg_impl.find_last_of(__s._M_non_dbg_impl, __pos); }
 745   size_type find_last_of(const _CharT* __s, size_type __pos = npos) const {
 746     _STLP_FIX_LITERAL_BUG(__s)
 747     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 748     return _M_non_dbg_impl.find_last_of(__s, __pos);
 749   }
 750   size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const {
 751     _STLP_FIX_LITERAL_BUG(__s)
 752     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 753     return _M_non_dbg_impl.find_last_of(__s, __pos, __n);
 754   }
 755   size_type find_last_of(_CharT __c, size_type __pos = npos) const
 756   { return _M_non_dbg_impl.rfind(__c, __pos); }
 757
 758   // find_first_not_of
 759   size_type find_first_not_of(const _Self& __s, size_type __pos = 0) const
 760   { return _M_non_dbg_impl.find_first_not_of(__s._M_non_dbg_impl, __pos); }
 761   size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const {
 762     _STLP_FIX_LITERAL_BUG(__s)
 763     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 764     return _M_non_dbg_impl.find_first_not_of(__s, __pos);
 765   }
 766   size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const {
 767     _STLP_FIX_LITERAL_BUG(__s)
 768     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 769     return _M_non_dbg_impl.find_first_not_of(__s, __pos, __n);
 770   }
 771   size_type find_first_not_of(_CharT __c, size_type __pos = 0) const
 772   { return _M_non_dbg_impl.find_first_not_of(__c, __pos); }
 773
 774   // find_last_not_of
 775   size_type find_last_not_of(const _Self& __s, size_type __pos = npos) const
 776   { return _M_non_dbg_impl.find_last_not_of(__s._M_non_dbg_impl, __pos); }
 777   size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const {
 778     _STLP_FIX_LITERAL_BUG(__s)
 779     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 780     return _M_non_dbg_impl.find_last_not_of(__s, __pos);
 781   }
 782   size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const {
 783     _STLP_FIX_LITERAL_BUG(__s)
 784     _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
 785     return _M_non_dbg_impl.find_last_not_of(__s, __pos, __n);
 786   }
 787   size_type find_last_not_of(_CharT __c, size_type __pos = npos) const
 788   { return _M_non_dbg_impl.find_last_not_of(__c, __pos); }
 789
 790 #if defined (_STLP_USE_TEMPLATE_EXPRESSION)
 791 #  include <stl/debug/_string_sum_methods.h>
 792 #endif
 793 };
 794
 795 // This is a hook to instantiate STLport exports in a designated DLL
 796 #if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
 797 _STLP_MOVE_TO_PRIV_NAMESPACE
 798 _STLP_EXPORT_TEMPLATE_CLASS __construct_checker<_STLP_NON_DBG_STRING_NAME <char, char_traits<char>, allocator<char> > >;
 799 _STLP_MOVE_TO_STD_NAMESPACE
 800 _STLP_EXPORT_TEMPLATE_CLASS basic_string<char, char_traits<char>, allocator<char> >;
 801 #  if defined (_STLP_HAS_WCHAR_T)
 802 _STLP_MOVE_TO_PRIV_NAMESPACE
 803 _STLP_EXPORT_TEMPLATE_CLASS __construct_checker<_STLP_NON_DBG_STRING_NAME <wchar_t, char_traits<wchar_t>, allocator<wchar_t> > >;
 804 _STLP_MOVE_TO_STD_NAMESPACE
 805 _STLP_EXPORT_TEMPLATE_CLASS basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
 806 #  endif
 807 #endif
 808
 809 #undef _STLP_NON_DBG_STRING
 810 #undef _STLP_NON_DBG_STRING_NAME
 811
 812 #if defined (__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 96)
 813 template <class _CharT, class _Traits, class _Alloc>
 814 const size_t basic_string<_CharT, _Traits, _Alloc>::npos = ~(size_t) 0;
 815 #endif
 816
 817 #if defined (basic_string)
 818 _STLP_MOVE_TO_STD_NAMESPACE
 819 #undef basic_string
 820 #endif
 821
 822 _STLP_END_NAMESPACE
 823
 824 #endif /* _STLP_DBG_STRING */
 825
 826 // Local Variables:
 827 // mode:C++
 828 // End: