| /* |
| * Copyright (c) 1997-1999 |
| * Silicon Graphics Computer Systems, Inc. |
| * |
| * Copyright (c) 1999 |
| * Boris Fomitchev |
| * |
| * This material is provided "as is", with absolutely no warranty expressed |
| * or implied. Any use is at your own risk. |
| * |
| * Permission to use or copy this software for any purpose is hereby granted |
| * without fee, provided the above notices are retained on all copies. |
| * Permission to modify the code and to distribute modified code is granted, |
| * provided the above notices are retained, and a notice that the code was |
| * modified is included with the above copyright notice. |
| * |
| */ |
| |
| #ifndef _STLP_INTERNAL_STRING_H |
| #define _STLP_INTERNAL_STRING_H |
| |
| #ifndef _STLP_INTERNAL_ALLOC_H |
| # include <stl/_alloc.h> |
| #endif |
| |
| #ifndef _STLP_STRING_FWD_H |
| # include <stl/_string_fwd.h> |
| #endif |
| |
| #ifndef _STLP_INTERNAL_FUNCTION_BASE_H |
| # include <stl/_function_base.h> |
| #endif |
| |
| #ifndef _STLP_INTERNAL_ALGOBASE_H |
| # include <stl/_algobase.h> |
| #endif |
| |
| #ifndef _STLP_INTERNAL_ITERATOR_H |
| # include <stl/_iterator.h> |
| #endif |
| |
| #ifndef _STLP_INTERNAL_UNINITIALIZED_H |
| # include <stl/_uninitialized.h> |
| #endif |
| |
| #if defined (_STLP_USE_TEMPLATE_EXPRESSION) |
| # include <stl/_string_sum.h> |
| #endif /* _STLP_USE_TEMPLATE_EXPRESSION */ |
| |
| #if defined (__MWERKS__) && ! defined (_STLP_USE_OWN_NAMESPACE) |
| |
| // MSL implementation classes expect to see the definition of streampos |
| // when this header is included. We expect this to be fixed in later MSL |
| // implementations |
| # if !defined( __MSL_CPP__ ) || __MSL_CPP__ < 0x4105 |
| # include <stl/msl_string.h> |
| # endif |
| #endif // __MWERKS__ |
| |
| /* |
| * Standard C++ string class. This class has performance |
| * characteristics very much like vector<>, meaning, for example, that |
| * it does not perform reference-count or copy-on-write, and that |
| * concatenation of two strings is an O(N) operation. |
| |
| * There are three reasons why basic_string is not identical to |
| * vector. |
| * First, basic_string always stores a null character at the end; |
| * this makes it possible for c_str to be a fast operation. |
| * Second, the C++ standard requires basic_string to copy elements |
| * using char_traits<>::assign, char_traits<>::copy, and |
| * char_traits<>::move. This means that all of vector<>'s low-level |
| * operations must be rewritten. Third, basic_string<> has a lot of |
| * extra functions in its interface that are convenient but, strictly |
| * speaking, redundant. |
| */ |
| |
| #include <stl/_string_base.h> |
| |
| _STLP_BEGIN_NAMESPACE |
| |
| // ------------------------------------------------------------ |
| // Class basic_string. |
| |
| // Class invariants: |
| // (1) [start, finish) is a valid range. |
| // (2) Each iterator in [start, finish) points to a valid object |
| // of type value_type. |
| // (3) *finish is a valid object of type value_type; when |
| // value_type is not a POD it is value_type(). |
| // (4) [finish + 1, end_of_storage) is a valid range. |
| // (5) Each iterator in [finish + 1, end_of_storage) points to |
| // unininitialized memory. |
| |
| // Note one important consequence: a string of length n must manage |
| // a block of memory whose size is at least n + 1. |
| |
| _STLP_MOVE_TO_PRIV_NAMESPACE |
| struct _String_reserve_t {}; |
| _STLP_MOVE_TO_STD_NAMESPACE |
| |
| #if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| # define basic_string _STLP_NO_MEM_T_NAME(str) |
| #elif defined (_STLP_DEBUG) |
| # define basic_string _STLP_NON_DBG_NAME(str) |
| #endif |
| |
| #if defined (basic_string) |
| _STLP_MOVE_TO_PRIV_NAMESPACE |
| #endif |
| |
| #if defined (__DMC__) |
| # define _STLP_PRIVATE public |
| #elif defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| # define _STLP_PRIVATE protected |
| #else |
| # define _STLP_PRIVATE private |
| #endif |
| |
| template <class _CharT, class _Traits, class _Alloc> |
| class basic_string : _STLP_PRIVATE _STLP_PRIV _String_base<_CharT,_Alloc> |
| #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (basic_string) |
| , public __stlport_class<basic_string<_CharT, _Traits, _Alloc> > |
| #endif |
| { |
| _STLP_PRIVATE: // Private members inherited from base. |
| typedef _STLP_PRIV _String_base<_CharT,_Alloc> _Base; |
| typedef basic_string<_CharT, _Traits, _Alloc> _Self; |
| |
| public: |
| typedef _CharT value_type; |
| typedef _Traits traits_type; |
| |
| typedef value_type* pointer; |
| typedef const value_type* const_pointer; |
| typedef value_type& reference; |
| typedef const value_type& const_reference; |
| typedef typename _Base::size_type size_type; |
| typedef ptrdiff_t difference_type; |
| typedef random_access_iterator_tag _Iterator_category; |
| |
| typedef const value_type* const_iterator; |
| typedef value_type* iterator; |
| |
| _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS; |
| |
| #include <stl/_string_npos.h> |
| |
| typedef _STLP_PRIV _String_reserve_t _Reserve_t; |
| |
| public: // Constructor, destructor, assignment. |
| typedef typename _Base::allocator_type allocator_type; |
| |
| allocator_type get_allocator() const |
| { return _STLP_CONVERT_ALLOCATOR((const allocator_type&)this->_M_start_of_storage, _CharT); } |
| |
| #if !defined (_STLP_DONT_SUP_DFLT_PARAM) |
| explicit basic_string(const allocator_type& __a = allocator_type()) |
| #else |
| basic_string() |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), _Base::_DEFAULT_SIZE) |
| { _M_terminate_string(); } |
| explicit basic_string(const allocator_type& __a) |
| #endif |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, _Base::_DEFAULT_SIZE) |
| { _M_terminate_string(); } |
| |
| #if !defined (_STLP_DONT_SUP_DFLT_PARAM) |
| basic_string(_Reserve_t, size_t __n, |
| const allocator_type& __a = allocator_type()) |
| #else |
| basic_string(_Reserve_t, size_t __n) |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), __n + 1) |
| { _M_terminate_string(); } |
| basic_string(_Reserve_t, size_t __n, const allocator_type& __a) |
| #endif |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, __n + 1) |
| { _M_terminate_string(); } |
| |
| basic_string(const _Self&); |
| |
| #if !defined (_STLP_DONT_SUP_DFLT_PARAM) |
| basic_string(const _Self& __s, size_type __pos, size_type __n = npos, |
| const allocator_type& __a = allocator_type()) |
| #else |
| basic_string(const _Self& __s, size_type __pos) |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) { |
| if (__pos > __s.size()) |
| this->_M_throw_out_of_range(); |
| else |
| _M_range_initialize(__s._M_Start() + __pos, __s._M_Finish()); |
| } |
| basic_string(const _Self& __s, size_type __pos, size_type __n) |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) { |
| if (__pos > __s.size()) |
| this->_M_throw_out_of_range(); |
| else |
| _M_range_initialize(__s._M_Start() + __pos, |
| __s._M_Start() + __pos + (min) (__n, __s.size() - __pos)); |
| } |
| basic_string(const _Self& __s, size_type __pos, size_type __n, |
| const allocator_type& __a) |
| #endif |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) { |
| if (__pos > __s.size()) |
| this->_M_throw_out_of_range(); |
| else |
| _M_range_initialize(__s._M_Start() + __pos, |
| __s._M_Start() + __pos + (min) (__n, __s.size() - __pos)); |
| } |
| |
| #if !defined (_STLP_DONT_SUP_DFLT_PARAM) |
| basic_string(const _CharT* __s, size_type __n, |
| const allocator_type& __a = allocator_type()) |
| #else |
| basic_string(const _CharT* __s, size_type __n) |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) { |
| _STLP_FIX_LITERAL_BUG(__s) |
| _M_range_initialize(__s, __s + __n); |
| } |
| basic_string(const _CharT* __s, size_type __n, const allocator_type& __a) |
| #endif |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) { |
| _STLP_FIX_LITERAL_BUG(__s) |
| _M_range_initialize(__s, __s + __n); |
| } |
| |
| #if !defined (_STLP_DONT_SUP_DFLT_PARAM) |
| basic_string(const _CharT* __s, |
| const allocator_type& __a = allocator_type()); |
| #else |
| basic_string(const _CharT* __s); |
| basic_string(const _CharT* __s, const allocator_type& __a); |
| #endif |
| |
| #if !defined (_STLP_DONT_SUP_DFLT_PARAM) |
| basic_string(size_type __n, _CharT __c, |
| const allocator_type& __a = allocator_type()) |
| #else |
| basic_string(size_type __n, _CharT __c) |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), __n + 1) { |
| this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c); |
| _M_terminate_string(); |
| } |
| basic_string(size_type __n, _CharT __c, const allocator_type& __a) |
| #endif |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, __n + 1) { |
| this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c); |
| _M_terminate_string(); |
| } |
| |
| #if !defined (_STLP_NO_MOVE_SEMANTIC) |
| basic_string(__move_source<_Self> src) |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(__move_source<_Base>(src.get())) {} |
| #endif |
| |
| // Check to see if _InputIterator is an integer type. If so, then |
| // it can't be an iterator. |
| #if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| template <class _InputIterator> |
| basic_string(_InputIterator __f, _InputIterator __l, |
| const allocator_type & __a _STLP_ALLOCATOR_TYPE_DFL) |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) { |
| typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; |
| _M_initialize_dispatch(__f, __l, _Integral()); |
| } |
| # if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) |
| template <class _InputIterator> |
| basic_string(_InputIterator __f, _InputIterator __l) |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) { |
| typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; |
| _M_initialize_dispatch(__f, __l, _Integral()); |
| } |
| # endif |
| #else |
| # if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| basic_string(const _CharT* __f, const _CharT* __l, |
| const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL) |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) { |
| _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) |
| _M_range_initialize(__f, __l); |
| } |
| # if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) |
| basic_string(const _CharT* __f, const _CharT* __l) |
| : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) { |
| _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) |
| _M_range_initialize(__f, __l); |
| } |
| # endif |
| # endif |
| # if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| /* We need an additionnal constructor to build an empty string without |
| * any allocation or termination char*/ |
| protected: |
| struct _CalledFromWorkaround_t {}; |
| basic_string(_CalledFromWorkaround_t, const allocator_type &__a) |
| : _String_base<_CharT,_Alloc>(__a) {} |
| # endif |
| #endif |
| |
| _STLP_PRIVATE: |
| size_type _M_compute_next_size(size_type __n) { |
| const size_type __size = size(); |
| if (__n > max_size() - __size) |
| this->_M_throw_length_error(); |
| size_type __len = __size + (max)(__n, __size) + 1; |
| if (__len > max_size() || __len < __size) |
| __len = max_size(); // overflow |
| return __len; |
| } |
| |
| template <class _InputIter> |
| void _M_range_initialize(_InputIter __f, _InputIter __l, |
| const input_iterator_tag &__tag) { |
| this->_M_allocate_block(); |
| _M_construct_null(this->_M_Finish()); |
| _M_appendT(__f, __l, __tag); |
| } |
| |
| template <class _ForwardIter> |
| void _M_range_initialize(_ForwardIter __f, _ForwardIter __l, |
| const forward_iterator_tag &) { |
| difference_type __n = _STLP_STD::distance(__f, __l); |
| this->_M_allocate_block(__n + 1); |
| this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start()); |
| this->_M_terminate_string(); |
| } |
| |
| template <class _InputIter> |
| void _M_range_initializeT(_InputIter __f, _InputIter __l) { |
| _M_range_initialize(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); |
| } |
| |
| template <class _Integer> |
| void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/) { |
| this->_M_allocate_block(__n + 1); |
| this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __x); |
| this->_M_terminate_string(); |
| } |
| |
| template <class _InputIter> |
| void _M_initialize_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) { |
| _M_range_initializeT(__f, __l); |
| } |
| |
| public: |
| _Self& operator=(const _Self& __s) { |
| if (&__s != this) |
| _M_assign(__s._M_Start(), __s._M_Finish()); |
| return *this; |
| } |
| |
| _Self& operator=(const _CharT* __s) { |
| _STLP_FIX_LITERAL_BUG(__s) |
| return _M_assign(__s, __s + traits_type::length(__s)); |
| } |
| |
| _Self& operator=(_CharT __c) |
| { return assign(__STATIC_CAST(size_type,1), __c); } |
| |
| private: |
| static _CharT _STLP_CALL _M_null() |
| { return _STLP_DEFAULT_CONSTRUCTED(_CharT); } |
| |
| _STLP_PRIVATE: // Helper functions used by constructors |
| // and elsewhere. |
| void _M_construct_null(_CharT* __p) const |
| { _STLP_STD::_Construct(__p); } |
| void _M_terminate_string() |
| { _M_construct_null(this->_M_Finish()); } |
| bool _M_inside(const _CharT* __s) const { |
| _STLP_FIX_LITERAL_BUG(__s) |
| return (__s >= this->_M_Start()) && (__s < this->_M_Finish()); |
| } |
| |
| void _M_range_initialize(const _CharT* __f, const _CharT* __l) { |
| _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) |
| ptrdiff_t __n = __l - __f; |
| this->_M_allocate_block(__n + 1); |
| this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start()); |
| _M_terminate_string(); |
| } |
| |
| public: // Iterators. |
| iterator begin() { return this->_M_Start(); } |
| iterator end() { return this->_M_Finish(); } |
| const_iterator begin() const { return this->_M_Start(); } |
| const_iterator end() const { return this->_M_Finish(); } |
| |
| reverse_iterator rbegin() |
| { return reverse_iterator(this->_M_Finish()); } |
| reverse_iterator rend() |
| { return reverse_iterator(this->_M_Start()); } |
| const_reverse_iterator rbegin() const |
| { return const_reverse_iterator(this->_M_Finish()); } |
| const_reverse_iterator rend() const |
| { return const_reverse_iterator(this->_M_Start()); } |
| |
| public: // Size, capacity, etc. |
| size_type size() const { return this->_M_Finish() - this->_M_Start(); } |
| size_type length() const { return size(); } |
| size_type max_size() const { return _Base::max_size(); } |
| |
| void resize(size_type __n, _CharT __c) { |
| if (__n <= size()) |
| erase(begin() + __n, end()); |
| else |
| append(__n - size(), __c); |
| } |
| |
| void resize(size_type __n) { resize(__n, _M_null()); } |
| |
| private: |
| void _M_reserve(size_type); |
| public: |
| void reserve(size_type = 0); |
| |
| size_type capacity() const |
| { return this->_M_capacity() - 1; } |
| |
| void clear() { |
| if (!empty()) { |
| _Traits::assign(*(this->_M_Start()), _M_null()); |
| this->_M_finish = this->_M_Start(); |
| } |
| } |
| |
| bool empty() const { return this->_M_Start() == this->_M_Finish(); } |
| |
| public: // Element access. |
| |
| const_reference operator[](size_type __n) const |
| { return *(this->_M_Start() + __n); } |
| reference operator[](size_type __n) |
| { return *(this->_M_Start() + __n); } |
| |
| const_reference at(size_type __n) const { |
| if (__n >= size()) |
| this->_M_throw_out_of_range(); |
| return *(this->_M_Start() + __n); |
| } |
| |
| reference at(size_type __n) { |
| if (__n >= size()) |
| this->_M_throw_out_of_range(); |
| return *(this->_M_Start() + __n); |
| } |
| |
| public: // Append, operator+=, push_back. |
| |
| _Self& operator+=(const _Self& __s) { return append(__s); } |
| _Self& operator+=(const _CharT* __s) { _STLP_FIX_LITERAL_BUG(__s) return append(__s); } |
| _Self& operator+=(_CharT __c) { push_back(__c); return *this; } |
| |
| private: |
| _Self& _M_append(const _CharT* __first, const _CharT* __last); |
| |
| #if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| template <class _InputIter> |
| _Self& _M_appendT(_InputIter __first, _InputIter __last, |
| const input_iterator_tag &) { |
| for ( ; __first != __last ; ++__first) |
| push_back(*__first); |
| return *this; |
| } |
| |
| template <class _ForwardIter> |
| _Self& _M_appendT(_ForwardIter __first, _ForwardIter __last, |
| const forward_iterator_tag &) { |
| if (__first != __last) { |
| size_type __n = __STATIC_CAST(size_type, _STLP_STD::distance(__first, __last)); |
| if (__n >= this->_M_rest()) { |
| size_type __len = _M_compute_next_size(__n); |
| pointer __new_start = this->_M_start_of_storage.allocate(__len, __len); |
| pointer __new_finish = uninitialized_copy(this->_M_Start(), this->_M_Finish(), __new_start); |
| __new_finish = uninitialized_copy(__first, __last, __new_finish); |
| _M_construct_null(__new_finish); |
| this->_M_deallocate_block(); |
| this->_M_reset(__new_start, __new_finish, __new_start + __len); |
| } |
| else { |
| _Traits::assign(*this->_M_finish, *__first++); |
| uninitialized_copy(__first, __last, this->_M_Finish() + 1); |
| _M_construct_null(this->_M_Finish() + __n); |
| this->_M_finish += __n; |
| } |
| } |
| return *this; |
| } |
| |
| template <class _Integer> |
| _Self& _M_append_dispatch(_Integer __n, _Integer __x, const __true_type& /*Integral*/) |
| { return append((size_type) __n, (_CharT) __x); } |
| |
| template <class _InputIter> |
| _Self& _M_append_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*Integral*/) |
| { return _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); } |
| |
| public: |
| // Check to see if _InputIterator is an integer type. If so, then |
| // it can't be an iterator. |
| template <class _InputIter> |
| _Self& append(_InputIter __first, _InputIter __last) { |
| typedef typename _IsIntegral<_InputIter>::_Ret _Integral; |
| return _M_append_dispatch(__first, __last, _Integral()); |
| } |
| #else |
| public: |
| _Self& append(const _CharT* __first, const _CharT* __last) { |
| _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) |
| return _M_append(__first, __last); |
| } |
| #endif |
| |
| public: |
| _Self& append(const _Self& __s) |
| { return _M_append(__s._M_Start(), __s._M_Finish()); } |
| |
| _Self& append(const _Self& __s, |
| size_type __pos, size_type __n) { |
| if (__pos > __s.size()) |
| this->_M_throw_out_of_range(); |
| return _M_append(__s._M_Start() + __pos, |
| __s._M_Start() + __pos + (min) (__n, __s.size() - __pos)); |
| } |
| |
| _Self& append(const _CharT* __s, size_type __n) |
| { _STLP_FIX_LITERAL_BUG(__s) return _M_append(__s, __s+__n); } |
| _Self& append(const _CharT* __s) |
| { _STLP_FIX_LITERAL_BUG(__s) return _M_append(__s, __s + traits_type::length(__s)); } |
| _Self& append(size_type __n, _CharT __c); |
| |
| public: |
| void push_back(_CharT __c) { |
| if (this->_M_rest() == 1 ) |
| _M_reserve(_M_compute_next_size(1)); |
| _M_construct_null(this->_M_Finish() + 1); |
| _Traits::assign(*(this->_M_Finish()), __c); |
| ++this->_M_finish; |
| } |
| |
| void pop_back() { |
| _Traits::assign(*(this->_M_Finish() - 1), _M_null()); |
| --this->_M_finish; |
| } |
| |
| public: // Assign |
| _Self& assign(const _Self& __s) |
| { return _M_assign(__s._M_Start(), __s._M_Finish()); } |
| |
| _Self& assign(const _Self& __s, |
| size_type __pos, size_type __n) { |
| if (__pos > __s.size()) |
| this->_M_throw_out_of_range(); |
| return _M_assign(__s._M_Start() + __pos, |
| __s._M_Start() + __pos + (min) (__n, __s.size() - __pos)); |
| } |
| |
| _Self& assign(const _CharT* __s, size_type __n) |
| { _STLP_FIX_LITERAL_BUG(__s) return _M_assign(__s, __s + __n); } |
| |
| _Self& assign(const _CharT* __s) |
| { _STLP_FIX_LITERAL_BUG(__s) return _M_assign(__s, __s + _Traits::length(__s)); } |
| |
| _Self& assign(size_type __n, _CharT __c); |
| |
| private: |
| _Self& _M_assign(const _CharT* __f, const _CharT* __l); |
| |
| #if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| // Helper functions for assign. |
| template <class _Integer> |
| _Self& _M_assign_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/) |
| { return assign((size_type) __n, (_CharT) __x); } |
| |
| template <class _InputIter> |
| _Self& _M_assign_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) { |
| pointer __cur = this->_M_Start(); |
| while (__f != __l && __cur != this->_M_Finish()) { |
| _Traits::assign(*__cur, *__f); |
| ++__f; |
| ++__cur; |
| } |
| if (__f == __l) |
| erase(__cur, this->end()); |
| else |
| _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); |
| return *this; |
| } |
| |
| public: |
| // Check to see if _InputIterator is an integer type. If so, then |
| // it can't be an iterator. |
| template <class _InputIter> |
| _Self& assign(_InputIter __first, _InputIter __last) { |
| typedef typename _IsIntegral<_InputIter>::_Ret _Integral; |
| return _M_assign_dispatch(__first, __last, _Integral()); |
| } |
| #else |
| public: |
| _Self& assign(const _CharT* __f, const _CharT* __l) { |
| _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) |
| return _M_assign(__f, __l); |
| } |
| #endif |
| |
| public: // Insert |
| _Self& insert(size_type __pos, const _Self& __s) { |
| if (__pos > size()) |
| this->_M_throw_out_of_range(); |
| if (__s.size() > max_size() - size()) |
| this->_M_throw_length_error(); |
| _M_insert(begin() + __pos, __s._M_Start(), __s._M_Finish(), &__s == this); |
| return *this; |
| } |
| |
| _Self& insert(size_type __pos, const _Self& __s, |
| size_type __beg, size_type __n) { |
| if (__pos > size() || __beg > __s.size()) |
| this->_M_throw_out_of_range(); |
| size_type __len = (min) (__n, __s.size() - __beg); |
| if (__len > max_size() - size()) |
| this->_M_throw_length_error(); |
| _M_insert(begin() + __pos, |
| __s._M_Start() + __beg, __s._M_Start() + __beg + __len, &__s == this); |
| return *this; |
| } |
| _Self& insert(size_type __pos, const _CharT* __s, size_type __n) { |
| _STLP_FIX_LITERAL_BUG(__s) |
| if (__pos > size()) |
| this->_M_throw_out_of_range(); |
| if (__n > max_size() - size()) |
| this->_M_throw_length_error(); |
| _M_insert(begin() + __pos, __s, __s + __n, _M_inside(__s)); |
| return *this; |
| } |
| |
| _Self& insert(size_type __pos, const _CharT* __s) { |
| _STLP_FIX_LITERAL_BUG(__s) |
| if (__pos > size()) |
| this->_M_throw_out_of_range(); |
| size_type __len = _Traits::length(__s); |
| if (__len > max_size() - size()) |
| this->_M_throw_length_error(); |
| _M_insert(this->_M_Start() + __pos, __s, __s + __len, _M_inside(__s)); |
| return *this; |
| } |
| |
| _Self& insert(size_type __pos, size_type __n, _CharT __c) { |
| if (__pos > size()) |
| this->_M_throw_out_of_range(); |
| if (__n > max_size() - size()) |
| this->_M_throw_length_error(); |
| insert(begin() + __pos, __n, __c); |
| return *this; |
| } |
| |
| iterator insert(iterator __p, _CharT __c) { |
| _STLP_FIX_LITERAL_BUG(__p) |
| if (__p == end()) { |
| push_back(__c); |
| return this->_M_Finish() - 1; |
| } |
| else |
| return _M_insert_aux(__p, __c); |
| } |
| |
| void insert(iterator __p, size_t __n, _CharT __c); |
| |
| _STLP_PRIVATE: // Helper functions for insert. |
| void _M_insert(iterator __p, const _CharT* __first, const _CharT* __last, bool __self_ref); |
| |
| pointer _M_insert_aux(pointer, _CharT); |
| |
| void _M_copy(const _CharT* __f, const _CharT* __l, _CharT* __res) { |
| _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) |
| _STLP_FIX_LITERAL_BUG(__res) |
| _Traits::copy(__res, __f, __l - __f); |
| } |
| |
| void _M_move(const _CharT* __f, const _CharT* __l, _CharT* __res) { |
| _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) |
| _Traits::move(__res, __f, __l - __f); |
| } |
| |
| #if defined (_STLP_MEMBER_TEMPLATES) |
| # if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| template <class _ForwardIter> |
| void _M_insert_overflow(iterator __pos, _ForwardIter __first, _ForwardIter __last, |
| size_type __n) { |
| size_type __len = _M_compute_next_size(__n); |
| pointer __new_start = this->_M_start_of_storage.allocate(__len, __len); |
| pointer __new_finish = uninitialized_copy(this->_M_Start(), __pos, __new_start); |
| __new_finish = uninitialized_copy(__first, __last, __new_finish); |
| __new_finish = uninitialized_copy(__pos, this->_M_Finish(), __new_finish); |
| _M_construct_null(__new_finish); |
| this->_M_deallocate_block(); |
| this->_M_reset(__new_start, __new_finish, __new_start + __len); |
| } |
| |
| template <class _InputIter> |
| void _M_insertT(iterator __p, _InputIter __first, _InputIter __last, |
| const input_iterator_tag &) { |
| for ( ; __first != __last; ++__first) { |
| __p = insert(__p, *__first); |
| ++__p; |
| } |
| } |
| |
| template <class _ForwardIter> |
| void _M_insertT(iterator __pos, _ForwardIter __first, _ForwardIter __last, |
| const forward_iterator_tag &) { |
| if (__first != __last) { |
| size_type __n = _STLP_STD::distance(__first, __last); |
| if (__n < this->_M_rest()) { |
| const size_type __elems_after = this->_M_finish - __pos; |
| if (__elems_after >= __n) { |
| uninitialized_copy((this->_M_Finish() - __n) + 1, this->_M_Finish() + 1, this->_M_Finish() + 1); |
| this->_M_finish += __n; |
| _Traits::move(__pos + __n, __pos, (__elems_after - __n) + 1); |
| _M_copyT(__first, __last, __pos); |
| } |
| else { |
| pointer __old_finish = this->_M_Finish(); |
| _ForwardIter __mid = __first; |
| _STLP_STD::advance(__mid, __elems_after + 1); |
| _STLP_STD::uninitialized_copy(__mid, __last, this->_M_Finish() + 1); |
| this->_M_finish += __n - __elems_after; |
| uninitialized_copy(__pos, __old_finish + 1, this->_M_Finish()); |
| this->_M_finish += __elems_after; |
| _M_copyT(__first, __mid, __pos); |
| } |
| } |
| else { |
| _M_insert_overflow(__pos, __first, __last, __n); |
| } |
| } |
| } |
| |
| template <class _Integer> |
| void _M_insert_dispatch(iterator __p, _Integer __n, _Integer __x, |
| const __true_type& /*Integral*/) |
| { insert(__p, (size_type) __n, (_CharT) __x); } |
| |
| template <class _InputIter> |
| void _M_insert_dispatch(iterator __p, _InputIter __first, _InputIter __last, |
| const __false_type& /*Integral*/) { |
| _STLP_FIX_LITERAL_BUG(__p) |
| /* We are forced to do a temporary string to avoid the self referencing issue. */ |
| const _Self __self(__first, __last, get_allocator()); |
| _M_insertT(__p, __self.begin(), __self.end(), forward_iterator_tag()); |
| } |
| |
| template <class _InputIterator> |
| void _M_copyT(_InputIterator __first, _InputIterator __last, pointer __result) { |
| _STLP_FIX_LITERAL_BUG(__result) |
| for ( ; __first != __last; ++__first, ++__result) |
| _Traits::assign(*__result, *__first); |
| } |
| |
| # if !defined (_STLP_NO_METHOD_SPECIALIZATION) |
| void _M_copyT(const _CharT* __f, const _CharT* __l, _CharT* __res) { |
| _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) |
| _STLP_FIX_LITERAL_BUG(__res) |
| _Traits::copy(__res, __f, __l - __f); |
| } |
| # endif |
| public: |
| // Check to see if _InputIterator is an integer type. If so, then |
| // it can't be an iterator. |
| template <class _InputIter> |
| void insert(iterator __p, _InputIter __first, _InputIter __last) { |
| typedef typename _IsIntegral<_InputIter>::_Ret _Integral; |
| _M_insert_dispatch(__p, __first, __last, _Integral()); |
| } |
| # endif |
| #endif |
| |
| #if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION) |
| public: |
| void insert(iterator __p, const _CharT* __f, const _CharT* __l) { |
| _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) |
| _M_insert(__p, __f, __l, _M_inside(__f)); |
| } |
| #endif |
| |
| public: // Erase. |
| _Self& erase(size_type __pos = 0, size_type __n = npos) { |
| if (__pos > size()) |
| this->_M_throw_out_of_range(); |
| erase(begin() + __pos, begin() + __pos + (min) (__n, size() - __pos)); |
| return *this; |
| } |
| |
| iterator erase(iterator __pos) { |
| // The move includes the terminating _CharT(). |
| _Traits::move(__pos, __pos + 1, this->_M_Finish() - __pos); |
| --this->_M_finish; |
| return __pos; |
| } |
| |
| iterator erase(iterator __first, iterator __last) { |
| if (__first != __last) { |
| // The move includes the terminating _CharT(). |
| traits_type::move(__first, __last, (this->_M_Finish() - __last) + 1); |
| this->_M_finish = this->_M_Finish() - (__last - __first); |
| } |
| return __first; |
| } |
| |
| public: // Replace. (Conceptually equivalent |
| // to erase followed by insert.) |
| _Self& replace(size_type __pos, size_type __n, const _Self& __s) { |
| const size_type __size = size(); |
| if (__pos > __size) |
| this->_M_throw_out_of_range(); |
| const size_type __len = (min) (__n, __size - __pos); |
| if (__s.size() > max_size() - (__size - __len)) |
| this->_M_throw_length_error(); |
| return _M_replace(begin() + __pos, begin() + __pos + __len, |
| __s._M_Start(), __s._M_Finish(), &__s == this); |
| } |
| |
| _Self& replace(size_type __pos1, size_type __n1, const _Self& __s, |
| size_type __pos2, size_type __n2) { |
| const size_type __size1 = size(); |
| const size_type __size2 = __s.size(); |
| if (__pos1 > __size1 || __pos2 > __size2) |
| this->_M_throw_out_of_range(); |
| const size_type __len1 = (min) (__n1, __size1 - __pos1); |
| const size_type __len2 = (min) (__n2, __size2 - __pos2); |
| if (__len2 > max_size() - (__size1 - __len1)) |
| this->_M_throw_length_error(); |
| return _M_replace(begin() + __pos1, begin() + __pos1 + __len1, |
| __s._M_Start() + __pos2, __s._M_Start() + __pos2 + __len2, &__s == this); |
| } |
| |
| _Self& replace(size_type __pos, size_type __n1, |
| const _CharT* __s, size_type __n2) { |
| _STLP_FIX_LITERAL_BUG(__s) |
| const size_type __size = size(); |
| if (__pos > __size) |
| this->_M_throw_out_of_range(); |
| const size_type __len = (min) (__n1, __size - __pos); |
| if (__n2 > max_size() - (__size - __len)) |
| this->_M_throw_length_error(); |
| return _M_replace(begin() + __pos, begin() + __pos + __len, |
| __s, __s + __n2, _M_inside(__s)); |
| } |
| |
| _Self& replace(size_type __pos, size_type __n1, const _CharT* __s) { |
| _STLP_FIX_LITERAL_BUG(__s) |
| return replace(__pos, __n1, __s, _Traits::length(__s)); |
| } |
| |
| _Self& replace(size_type __pos, size_type __n1, |
| size_type __n2, _CharT __c) { |
| const size_type __size = size(); |
| if (__pos > __size) |
| this->_M_throw_out_of_range(); |
| const size_type __len = (min) (__n1, __size - __pos); |
| if (__n2 > max_size() - (__size - __len)) |
| this->_M_throw_length_error(); |
| return replace(begin() + __pos, begin() + __pos + __len, __n2, __c); |
| } |
| |
| _Self& replace(iterator __first, iterator __last, const _Self& __s) { |
| _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) |
| return _M_replace(__first, __last, __s._M_Start(), __s._M_Finish(), &__s == this); |
| } |
| |
| _Self& replace(iterator __first, iterator __last, |
| const _CharT* __s, size_type __n) { |
| _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) |
| _STLP_FIX_LITERAL_BUG(__s) |
| return _M_replace(__first, __last, __s, __s + __n, _M_inside(__s)); |
| } |
| |
| _Self& replace(iterator __first, iterator __last, |
| const _CharT* __s) { |
| _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) |
| _STLP_FIX_LITERAL_BUG(__s) |
| return _M_replace(__first, __last, __s, __s + _Traits::length(__s), _M_inside(__s)); |
| } |
| |
| _Self& replace(iterator __first, iterator __last, size_type __n, _CharT __c); |
| |
| _STLP_PRIVATE: // Helper functions for replace. |
| _Self& _M_replace(iterator __first, iterator __last, |
| const _CharT* __f, const _CharT* __l, bool __self_ref); |
| |
| #if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| template <class _Integer> |
| _Self& _M_replace_dispatch(iterator __first, iterator __last, |
| _Integer __n, _Integer __x, const __true_type& /*IsIntegral*/) { |
| _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last) |
| return replace(__first, __last, (size_type) __n, (_CharT) __x); |
| } |
| |
| template <class _InputIter> |
| _Self& _M_replace_dispatch(iterator __first, iterator __last, |
| _InputIter __f, _InputIter __l, const __false_type& /*IsIntegral*/) { |
| _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last) |
| /* We are forced to do a temporary string to avoid the self referencing issue. */ |
| const _Self __self(__f, __l, get_allocator()); |
| return _M_replace(__first, __last, __self._M_Start(), __self._M_Finish(), false); |
| } |
| |
| public: |
| // Check to see if _InputIter is an integer type. If so, then |
| // it can't be an iterator. |
| template <class _InputIter> |
| _Self& replace(iterator __first, iterator __last, |
| _InputIter __f, _InputIter __l) { |
| _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) |
| typedef typename _IsIntegral<_InputIter>::_Ret _Integral; |
| return _M_replace_dispatch(__first, __last, __f, __l, _Integral()); |
| } |
| #endif |
| |
| #if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION) |
| public: |
| _Self& replace(iterator __first, iterator __last, |
| const _CharT* __f, const _CharT* __l) { |
| _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) |
| _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) |
| return _M_replace(__first, __last, __f, __l, _M_inside(__f)); |
| } |
| #endif |
| |
| public: // Other modifier member functions. |
| |
| size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const { |
| _STLP_FIX_LITERAL_BUG(__s) |
| if (__pos > size()) |
| this->_M_throw_out_of_range(); |
| const size_type __len = (min) (__n, size() - __pos); |
| _Traits::copy(__s, this->_M_Start() + __pos, __len); |
| return __len; |
| } |
| |
| void swap(_Self& __s) { this->_M_swap(__s); } |
| #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) |
| void _M_swap_workaround(_Self& __x) { swap(__x); } |
| #endif |
| |
| public: // Conversion to C string. |
| |
| const _CharT* c_str() const { return this->_M_Start(); } |
| const _CharT* data() const { return this->_M_Start(); } |
| |
| public: // find. |
| size_type find(const _Self& __s, size_type __pos = 0) const |
| { return find(__s._M_Start(), __pos, __s.size()); } |
| |
| size_type find(const _CharT* __s, size_type __pos = 0) const |
| { _STLP_FIX_LITERAL_BUG(__s) return find(__s, __pos, _Traits::length(__s)); } |
| |
| size_type find(const _CharT* __s, size_type __pos, size_type __n) const; |
| |
| // WIE: Versant schema compiler 5.2.2 ICE workaround |
| size_type find(_CharT __c) const { return find(__c, 0); } |
| size_type find(_CharT __c, size_type __pos /* = 0 */) const; |
| |
| public: // rfind. |
| size_type rfind(const _Self& __s, size_type __pos = npos) const |
| { return rfind(__s._M_Start(), __pos, __s.size()); } |
| |
| size_type rfind(const _CharT* __s, size_type __pos = npos) const |
| { _STLP_FIX_LITERAL_BUG(__s) return rfind(__s, __pos, _Traits::length(__s)); } |
| |
| size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const; |
| size_type rfind(_CharT __c, size_type __pos = npos) const; |
| |
| public: // find_first_of |
| size_type find_first_of(const _Self& __s, size_type __pos = 0) const |
| { return find_first_of(__s._M_Start(), __pos, __s.size()); } |
| |
| size_type find_first_of(const _CharT* __s, size_type __pos = 0) const |
| { _STLP_FIX_LITERAL_BUG(__s) return find_first_of(__s, __pos, _Traits::length(__s)); } |
| |
| size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const; |
| |
| size_type find_first_of(_CharT __c, size_type __pos = 0) const |
| { return find(__c, __pos); } |
| |
| public: // find_last_of |
| size_type find_last_of(const _Self& __s, size_type __pos = npos) const |
| { return find_last_of(__s._M_Start(), __pos, __s.size()); } |
| |
| size_type find_last_of(const _CharT* __s, size_type __pos = npos) const |
| { _STLP_FIX_LITERAL_BUG(__s) return find_last_of(__s, __pos, _Traits::length(__s)); } |
| |
| size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const; |
| |
| size_type find_last_of(_CharT __c, size_type __pos = npos) const |
| { return rfind(__c, __pos); } |
| |
| public: // find_first_not_of |
| size_type find_first_not_of(const _Self& __s, size_type __pos = 0) const |
| { return find_first_not_of(__s._M_Start(), __pos, __s.size()); } |
| |
| size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const |
| { _STLP_FIX_LITERAL_BUG(__s) return find_first_not_of(__s, __pos, _Traits::length(__s)); } |
| |
| size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const; |
| |
| size_type find_first_not_of(_CharT __c, size_type __pos = 0) const; |
| |
| public: // find_last_not_of |
| size_type find_last_not_of(const _Self& __s, size_type __pos = npos) const |
| { return find_last_not_of(__s._M_Start(), __pos, __s.size()); } |
| |
| size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const |
| { _STLP_FIX_LITERAL_BUG(__s) return find_last_not_of(__s, __pos, _Traits::length(__s)); } |
| |
| size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const; |
| |
| size_type find_last_not_of(_CharT __c, size_type __pos = npos) const; |
| |
| public: // Substring. |
| _Self substr(size_type __pos = 0, size_type __n = npos) const |
| { return _Self(*this, __pos, __n, get_allocator()); } |
| |
| public: // Compare |
| int compare(const _Self& __s) const |
| { return _M_compare(this->_M_Start(), this->_M_Finish(), __s._M_Start(), __s._M_Finish()); } |
| |
| int compare(size_type __pos1, size_type __n1, const _Self& __s) const { |
| if (__pos1 > size()) |
| this->_M_throw_out_of_range(); |
| return _M_compare(this->_M_Start() + __pos1, |
| this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1), |
| __s._M_Start(), __s._M_Finish()); |
| } |
| |
| int compare(size_type __pos1, size_type __n1, const _Self& __s, |
| size_type __pos2, size_type __n2) const { |
| if (__pos1 > size() || __pos2 > __s.size()) |
| this->_M_throw_out_of_range(); |
| return _M_compare(this->_M_Start() + __pos1, |
| this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1), |
| __s._M_Start() + __pos2, |
| __s._M_Start() + __pos2 + (min) (__n2, __s.size() - __pos2)); |
| } |
| |
| int compare(const _CharT* __s) const { |
| _STLP_FIX_LITERAL_BUG(__s) |
| return _M_compare(this->_M_Start(), this->_M_Finish(), __s, __s + _Traits::length(__s)); |
| } |
| |
| int compare(size_type __pos1, size_type __n1, const _CharT* __s) const { |
| _STLP_FIX_LITERAL_BUG(__s) |
| if (__pos1 > size()) |
| this->_M_throw_out_of_range(); |
| return _M_compare(this->_M_Start() + __pos1, |
| this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1), |
| __s, __s + _Traits::length(__s)); |
| } |
| |
| int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const { |
| _STLP_FIX_LITERAL_BUG(__s) |
| if (__pos1 > size()) |
| this->_M_throw_out_of_range(); |
| return _M_compare(this->_M_Start() + __pos1, |
| this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1), |
| __s, __s + __n2); |
| } |
| |
| public: // Helper functions for compare. |
| static int _STLP_CALL _M_compare(const _CharT* __f1, const _CharT* __l1, |
| const _CharT* __f2, const _CharT* __l2) { |
| const ptrdiff_t __n1 = __l1 - __f1; |
| const ptrdiff_t __n2 = __l2 - __f2; |
| const int cmp = _Traits::compare(__f1, __f2, (min) (__n1, __n2)); |
| return cmp != 0 ? cmp : (__n1 < __n2 ? -1 : (__n1 > __n2 ? 1 : 0)); |
| } |
| #if defined (_STLP_USE_TEMPLATE_EXPRESSION) && !defined (_STLP_DEBUG) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| # define _STLP_STRING_SUM_BASE(__reserve, __size, __alloc) _STLP_PRIV _String_base<_CharT,_Alloc>(__alloc, __size + 1) |
| # include <stl/_string_sum_methods.h> |
| # undef _STLP_STRING_SUM_BASE |
| #endif |
| }; |
| |
| #undef _STLP_PRIVATE |
| |
| #if defined (__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 96) |
| template <class _CharT, class _Traits, class _Alloc> |
| const size_t basic_string<_CharT, _Traits, _Alloc>::npos = ~(size_t) 0; |
| #endif |
| |
| #if defined (_STLP_USE_TEMPLATE_EXPORT) |
| _STLP_EXPORT_TEMPLATE_CLASS basic_string<char, char_traits<char>, allocator<char> >; |
| # if defined (_STLP_HAS_WCHAR_T) |
| _STLP_EXPORT_TEMPLATE_CLASS basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >; |
| # endif |
| #endif /* _STLP_USE_TEMPLATE_EXPORT */ |
| |
| #if defined (basic_string) |
| _STLP_MOVE_TO_STD_NAMESPACE |
| # undef basic_string |
| #endif |
| |
| _STLP_END_NAMESPACE |
| |
| #if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) |
| # include <stl/_string_workaround.h> |
| #endif |
| |
| #if defined (_STLP_DEBUG) |
| # include <stl/debug/_string.h> |
| #endif |
| |
| _STLP_BEGIN_NAMESPACE |
| |
| // ------------------------------------------------------------ |
| // Non-member functions. |
| // Swap. |
| #if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) |
| template <class _CharT, class _Traits, class _Alloc> |
| inline void _STLP_CALL |
| swap(basic_string<_CharT,_Traits,_Alloc>& __x, |
| basic_string<_CharT,_Traits,_Alloc>& __y) |
| { __x.swap(__y); } |
| #else |
| inline void _STLP_CALL swap(string& __x, string& __y) |
| { __x.swap(__y); } |
| # if defined (_STLP_HAS_WCHAR_T) |
| inline void _STLP_CALL swap(wstring& __x, wstring& __y) |
| { __x.swap(__y); } |
| # endif |
| #endif |
| |
| #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC) |
| template <class _CharT, class _Traits, class _Alloc> |
| struct __move_traits<basic_string<_CharT, _Traits, _Alloc> > { |
| typedef __true_type implemented; |
| //Completness depends on the allocator: |
| typedef typename __move_traits<_Alloc>::complete complete; |
| }; |
| /*#else |
| * There is no need to specialize for string and wstring in this case |
| * as the default __move_traits will already tell that string is movable |
| * but not complete. We cannot define it as complete as nothing guaranty |
| * that the STLport user hasn't specialized std::allocator for char or |
| * wchar_t. |
| */ |
| #endif |
| |
| _STLP_MOVE_TO_PRIV_NAMESPACE |
| |
| template <class _CharT, class _Traits, class _Alloc> |
| void _STLP_CALL _S_string_copy(const basic_string<_CharT,_Traits,_Alloc>& __s, |
| _CharT* __buf, size_t __n); |
| |
| #if defined(_STLP_USE_WIDE_INTERFACE) |
| // A couple of functions to transfer between ASCII/Unicode |
| wstring __ASCIIToWide(const char *ascii); |
| string __WideToASCII(const wchar_t *wide); |
| #endif |
| |
| inline const char* _STLP_CALL |
| __get_c_string(const string& __str) { return __str.c_str(); } |
| |
| _STLP_MOVE_TO_STD_NAMESPACE |
| |
| _STLP_END_NAMESPACE |
| |
| #include <stl/_string_operators.h> |
| |
| #if defined(_STLP_USE_NO_IOSTREAMS) || \ |
| (defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)) |
| # include <stl/_string.c> |
| #endif |
| |
| #endif /* _STLP_INTERNAL_STRING_H */ |
| |
| /* |
| * Local Variables: |
| * mode:C++ |
| * End: |
| */ |