_string.h

来自「stl的源码」· C头文件 代码 · 共 829 行 · 第 1/3 页

  }

  _Self& append(const _Self& __s, size_type __pos, size_type __n) {
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.append(__s._M_non_dbg_impl, __pos, __n);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  _Self& append(const _CharT* __s, size_type __n) {
    _STLP_FIX_LITERAL_BUG(__s)
    _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.append(__s, __n);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  _Self& append(const _CharT* __s) {
    _STLP_FIX_LITERAL_BUG(__s)
    _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.append(__s);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  _Self& append(size_type __n, _CharT __c) {
    size_type __old_capacity = this->capacity();
    _M_non_dbg_impl.append(__n, __c);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  void push_back(_CharT __c) {
    size_type __old_capacity = this->capacity();
    _M_non_dbg_impl.push_back(__c);
    _Compare_Capacity(__old_capacity);
  }

  void pop_back() {
    _Invalidate_iterator(this->end());
    _M_non_dbg_impl.pop_back();
  }

  // Assign
  _Self& assign(const _Self& __s) {
    _Invalidate_all();
    _M_non_dbg_impl.assign(__s._M_non_dbg_impl);
    return *this;
  }

  _Self& assign(const _Self& __s, size_type __pos, size_type __n) {
    if (__pos < __s.size()) {
      _Invalidate_all();
    }
    _M_non_dbg_impl.assign(__s._M_non_dbg_impl, __pos, __n);
    return *this;
  }

  _Self& assign(const _CharT* __s, size_type __n) {
    _STLP_FIX_LITERAL_BUG(__s)
    _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
    _Invalidate_all();
    _M_non_dbg_impl.assign(__s, __s + __n);
    return *this;
  }

  _Self& assign(const _CharT* __s) {
    _STLP_FIX_LITERAL_BUG(__s)
    _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
    _Invalidate_all();
    _M_non_dbg_impl.assign(__s);
    return *this;
  }

  _Self& assign(size_type __n, _CharT __c) {
    _Invalidate_all();
    _M_non_dbg_impl.assign(__n, __c);
    return *this;
  }

#if defined(_STLP_MEMBER_TEMPLATES)
  template <class _InputIter>
  inline _Self& assign(_InputIter __first, _InputIter __last) {
    _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
    _Invalidate_all();
    _M_non_dbg_impl.assign(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
    return *this;
  }
#endif

#if !defined (_STLP_MEMBER_TEMPLATES) || \
    !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
  _Self& assign(const _CharT* __f, const _CharT* __l) {
    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f, __l))
    _Invalidate_all();
    _M_non_dbg_impl.assign(__f, __l);
    return *this;
  }
  _Self& assign(const_iterator __f, const_iterator __l) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
    _Invalidate_all();
    _M_non_dbg_impl.assign(__f._M_iterator, __l._M_iterator);
    return *this;
  }
#endif

  // Insert
  _Self& insert(size_type __pos, const _Self& __s) {
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__pos, __s._M_non_dbg_impl);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  _Self& insert(size_type __pos, const _Self& __s,
                size_type __beg, size_type __n) {
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__pos, __s._M_non_dbg_impl, __beg, __n);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  _Self& insert(size_type __pos, const _CharT* __s, size_type __n) {
    _STLP_FIX_LITERAL_BUG(__s)
    _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__pos, __s, __n);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  _Self& insert(size_type __pos, const _CharT* __s) {
    _STLP_FIX_LITERAL_BUG(__s)
    _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
    return insert(__pos, __s, _Traits::length(__s));
  }

  _Self& insert(size_type __pos, size_type __n, _CharT __c) {
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__pos, __n, __c);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  iterator insert(iterator __p, _CharT __c) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
    size_type __old_capacity = capacity();
    typename _Base::iterator __ret = _M_non_dbg_impl.insert(__p._M_iterator, __c);
    _Compare_Capacity(__old_capacity);
    return iterator(&_M_iter_list, __ret);
  }

  void insert(iterator __p, size_t __n, _CharT __c) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__p._M_iterator, __n, __c);
    _Compare_Capacity(__old_capacity);
  }

#if defined (_STLP_MEMBER_TEMPLATES)
  template <class _InputIter>
  void insert(iterator __p, _InputIter __first, _InputIter __last) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first,__last))

    size_type __old_capacity = this->capacity();
    _M_non_dbg_impl.insert(__p._M_iterator,
                           _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
    _Compare_Capacity(__old_capacity);
  }
#endif

#if !defined (_STLP_MEMBER_TEMPLATES)
  void insert(iterator __p, const _CharT* __f, const _CharT* __l) {
    _STLP_FIX_LITERAL_BUG(__f)_STLP_FIX_LITERAL_BUG(__l)
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f,__l))
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__p._M_iterator, __f, __l);
    _Compare_Capacity(__old_capacity);
  }
#endif

#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
  // Those overloads are necessary to check self referencing correctly in non debug
  // basic_string implementation
  void insert(iterator __p, const_iterator __f, const_iterator __l) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f,__l))
#  if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
    _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __f))
#  endif
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__p._M_iterator, __f._M_iterator, __l._M_iterator);
    _Compare_Capacity(__old_capacity);
  }
  void insert(iterator __p, iterator __f, iterator __l) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f,__l))
#  if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
    _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __f))
#  endif
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.insert(__p._M_iterator, __f._M_iterator, __l._M_iterator);
    _Compare_Capacity(__old_capacity);
  }
#endif

  // Erase.
  _Self& erase(size_type __pos = 0, size_type __n = npos) {
    if (__pos < size()) {
      _Invalidate_iterators(begin() + __pos, end());
    }
    _M_non_dbg_impl.erase(__pos, __n);
    return *this;
  }
  iterator erase(iterator __pos) {
    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
    _Invalidate_iterators(__pos, end());
    return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__pos._M_iterator));
  }
  iterator erase(iterator __f, iterator __l) {
    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
    _Invalidate_iterators(__f, end());
    return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__f._M_iterator, __l._M_iterator));
  }

  // Substring.
  _Self substr(size_type __pos = 0, size_type __n = npos) const
  { return _M_non_dbg_impl.substr(__pos, __n); }

  // Replace.  (Conceptually equivalent to erase followed by insert.)
  _Self& replace(size_type __pos, size_type __n, const _Self& __s) {
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.replace(__pos, __n, __s._M_non_dbg_impl);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  _Self& replace(size_type __pos1, size_type __n1, const _Self& __s,
                 size_type __pos2, size_type __n2) {
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.replace(__pos1, __n1, __s._M_non_dbg_impl, __pos2, __n2);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  _Self& replace(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) {
    _STLP_FIX_LITERAL_BUG(__s)
    _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.replace(__pos, __n1, __s, __n2);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  _Self& replace(size_type __pos, size_type __n1, const _CharT* __s) {
    _STLP_FIX_LITERAL_BUG(__s)
    _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.replace(__pos, __n1, __s);
    _Compare_Capacity(__old_capacity);
    return *this;
  }

  _Self& replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) {
    size_type __old_capacity = capacity();
    _M_non_dbg_impl.replace(__pos, __n1, __n2, __c);
    _Compare_Capacity(__old_capacity);
    return *this;
  }