/home/ntakagi/work/STLport-5.1.5/stlport/stl/_string.h Go to the documentation of this file. /* * 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 can always stores a null character * at the end (macro dependent); 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. * Additionally, the C++ standard imposes a major restriction: according * to the standard, the character type _CharT must be a POD type. This * implementation weakens that restriction, and allows _CharT to be a * a user-defined non-POD type. However, _CharT must still have a * default constructor. */ #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. struct _String_reserve_t {}; #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 template <class _CharT, class _Traits, class _Alloc> class basic_string : protected _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 { protected: // Protected members inherited from base. typedef _STLP_PRIV _String_base<_CharT,_Alloc> _Base; typedef basic_string<_CharT, _Traits, _Alloc> _Self; // fbp : used to optimize char/wchar_t cases, and to simplify // _STLP_DEF_CONST_PLCT_NEW_BUG problem workaround typedef typename _IsIntegral<_CharT>::_Ret _Char_Is_Integral; typedef typename _IsPOD<_CharT>::_Type _Char_Is_POD; typedef random_access_iterator_tag r_a_i_t; 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 _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_end_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) { # if defined (_STLP_USE_SHORT_STRING_OPTIM) if (this->_M_using_static_buf()) { _Traits::assign(this->_M_Start(), __n, __c); this->_M_finish = this->_M_Start() + __n; } else # endif 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) { #if defined (_STLP_USE_SHORT_STRING_OPTIM) if (this->_M_using_static_buf()) { _Traits::assign(this->_M_Start(), __n, __c); this->_M_finish = this->_M_Start() + __n; } else #endif this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c); _M_terminate_string(); } basic_string(__move_source<_Self> src) : _STLP_PRIV _String_base<_CharT,_Alloc>(__move_source<_Base>(src.get())) {} // Check to see if _InputIterator is an integer type. If so, then // it can't be an iterator. #if defined (_STLP_MEMBER_TEMPLATES) && !(defined (__MRC__) || (defined(__SC__) && !defined(__DMC__))) //*ty 04/30/2001 - mpw compilers choke on this ctor # if !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 /* 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) {} public: # endif /* _STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND */ #endif /* !__MRC__ || (__SC__ && !__DMC__) */ #if !(defined (_STLP_MEMBER_TEMPLATES) && !(defined (__MRC__) || (defined (__SC__) && !defined (__DMC__)))) || \ !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS) || \ 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 /* _STLP_MEMBER_TEMPLATES */ private: 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()); _STLP_TRY { _M_appendT(__f, __l, __tag); } _STLP_UNWIND(this->_M_destroy_range()) } template <class _ForwardIter> void _M_range_initialize(_ForwardIter __f, _ForwardIter __l, const forward_iterator_tag &) { difference_type __n = distance(__f, __l); this->_M_allocate_block(__n + 1); #if defined (_STLP_USE_SHORT_STRING_OPTIM) if (this->_M_using_static_buf()) { _M_copyT(__f, __l, this->_M_Start()); this->_M_finish = this->_M_Start() + __n; } else #endif /* _STLP_USE_SHORT_STRING_OPTIM */ 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); #if defined (_STLP_USE_SHORT_STRING_OPTIM) if (this->_M_using_static_buf()) { _Traits::assign(this->_M_Start(), __n, __x); this->_M_finish = this->_M_Start() + __n; } else #endif /* _STLP_USE_SHORT_STRING_OPTIM */ 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: ~basic_string() { this->_M_destroy_range(); } _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); } protected: static _CharT _STLP_CALL _M_null() { return _STLP_DEFAULT_CONSTRUCTED(_CharT); } protected: // Helper functions used by constructors // and elsewhere. // fbp : simplify integer types (char, wchar) void _M_construct_null_aux(_CharT* __p, const __false_type& /*_Is_Integral*/) const { #if defined (_STLP_USE_SHORT_STRING_OPTIM) if (this->_M_using_static_buf()) _Traits::assign(*__p, _M_null()); else #endif /*_STLP_USE_SHORT_STRING_OPTIM*/ _STLP_STD::_Construct(__p); } void _M_construct_null_aux(_CharT* __p, const __true_type& /*_Is_Integral*/) const { *__p = 0; } void _M_force_construct_null(_CharT*, const __true_type& /* _Is_POD */) const { /*Nothing to do*/ } void _M_force_construct_null(_CharT* __p, const __false_type& /* _Is_POD */) const { _M_construct_null_aux(__p, _Char_Is_Integral()); } void _M_construct_null(_CharT* __p) const { typedef __false_type _Answer; _M_force_construct_null(__p, _Answer()); } protected: // Helper functions used by constructors. It is a severe error for // any of them to be called anywhere except from within constructors. void _M_terminate_string_aux(const __false_type& __is_integral) { _STLP_TRY { _M_construct_null_aux(this->_M_Finish(), __is_integral); } _STLP_UNWIND(this->_M_destroy_range(0,0)) } void _M_terminate_string_aux(const __true_type& __is_integral) { _M_construct_null_aux(this->_M_Finish(), __is_integral); } void _M_force_terminate_string(const __true_type& /* _Is_POD */) { /*Nothing to do*/ } void _M_force_terminate_string(const __false_type& /* _Is_POD */) { _M_terminate_string_aux(_Char_Is_Integral()); } void _M_terminate_string() { typedef __false_type _Answer; _M_force_terminate_string(_Answer()); } 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); #if defined (_STLP_USE_SHORT_STRING_OPTIM) if (this->_M_using_static_buf()) { _M_copy(__f, __l, this->_M_Start()); this->_M_finish = this->_M_Start() + __n; } else #endif /* _STLP_USE_SHORT_STRING_OPTIM */ 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_t 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()); } void reserve(size_type = 0); size_type capacity() const { return (this->_M_end_of_storage._M_data - this->_M_Start()) - 1; } void clear() { if (!empty()) { _Traits::assign(*(this->_M_Start()), _M_null()); this->_M_destroy_range(1); 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; } #if defined (_STLP_MEMBER_TEMPLATES) # if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) private: // Helper functions for append. 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) { const size_type __old_size = this->size(); difference_type __n = distance(__first, __last); if (__STATIC_CAST(size_type,__n) > this->max_size() || __old_size > this->max_size() - __STATIC_CAST(size_type,__n)) this->_M_throw_length_error(); if (__old_size + __n > this->capacity()) { size_type __len = __old_size + (max)(__old_size, __STATIC_CAST(size_type,__n)) + 1; pointer __new_start = this->_M_end_of_storage.allocate(__len, __len); pointer __new_finish = __new_start; _STLP_TRY { __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); } _STLP_UNWIND((_STLP_STD::_Destroy_Range(__new_start,__new_finish), this->_M_end_of_storage.deallocate(__new_start, __len))) this->_M_destroy_range(); this->_M_deallocate_block(); this->_M_reset(__new_start, __new_finish, __new_start + __len); } else { _ForwardIter __f1 = __first; ++__f1; #if defined (_STLP_USE_SHORT_STRING_OPTIM) if (this->_M_using_static_buf()) _M_copyT(__f1, __last, this->_M_Finish() + 1); else #endif /* _STLP_USE_SHORT_STRING_OPTIM */ uninitialized_copy(__f1, __last, this->_M_Finish() + 1); _STLP_TRY { _M_construct_null(this->_M_Finish() + __n); } _STLP_UNWIND(this->_M_destroy_ptr_range(this->_M_Finish() + 1, this->_M_Finish() + __n)) _Traits::assign(*this->_M_finish, *__first); 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()); } # endif #endif protected: _Self& _M_append(const _CharT* __first, const _CharT* __last); public: #if !defined (_STLP_MEMBER_TEMPLATES) || \ !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS) # if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) _Self& append(const _CharT* __first, const _CharT* __last) { _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) return _M_append(__first, __last); } # endif #endif _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_Finish() + 1 == this->_M_end_of_storage._M_data) reserve(size() + (max)(size(), __STATIC_CAST(size_type,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_destroy_back(); --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); #if defined (_STLP_MEMBER_TEMPLATES) # if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) private: // 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()); } # endif #endif protected: _Self& _M_assign(const _CharT* __f, const _CharT* __l); public: #if !defined (_STLP_MEMBER_TEMPLATES) || \ !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS) # if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) _Self& assign(const _CharT* __f, const _CharT* __l) { _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) return _M_assign(__f, __l); } # endif #endif public: // Insert _Self& insert(size_type __pos, const _Self& __s) { if (__pos > size()) this->_M_throw_out_of_range(); if (size() > max_size() - __s.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 (size() > max_size() - __len) 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 (size() > max_size() - __n) 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 (size() > max_size() - __len) 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 (size() > max_size() - __n) 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); protected: // 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, difference_type __n) { const size_type __old_size = this->size(); size_type __len = __old_size + (max)(__old_size, __STATIC_CAST(size_type,__n)) + 1; pointer __new_start = this->_M_end_of_storage.allocate(__len, __len); pointer __new_finish = __new_start; _STLP_TRY { __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); } _STLP_UNWIND((_STLP_STD::_Destroy_Range(__new_start,__new_finish), this->_M_end_of_storage.deallocate(__new_start, __len))) this->_M_destroy_range(); 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) { difference_type __n = distance(__first, __last); if (this->_M_end_of_storage._M_data - this->_M_finish >= __n + 1) { const difference_type __elems_after = this->_M_finish - __pos; if (__elems_after >= __n) { # if defined (_STLP_USE_SHORT_STRING_OPTIM) if (this->_M_using_static_buf()) _M_copy((this->_M_Finish() - __n) + 1, this->_M_Finish() + 1, this->_M_Finish() + 1); else # endif /* _STLP_USE_SHORT_STRING_OPTIM */ 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; advance(__mid, __elems_after + 1); # if defined (_STLP_USE_SHORT_STRING_OPTIM) if (this->_M_using_static_buf()) _M_copyT(__mid, __last, this->_M_Finish() + 1); else # endif /* _STLP_USE_SHORT_STRING_OPTIM */ uninitialized_copy(__mid, __last, this->_M_Finish() + 1); this->_M_finish += __n - __elems_after; _STLP_TRY { # if defined (_STLP_USE_SHORT_STRING_OPTIM) if (this->_M_using_static_buf()) _M_copy(__pos, __old_finish + 1, this->_M_Finish()); else # endif /* _STLP_USE_SHORT_STRING_OPTIM */ uninitialized_copy(__pos, __old_finish + 1, this->_M_Finish()); this->_M_finish += __elems_after; } _STLP_UNWIND((this->_M_destroy_ptr_range(__old_finish + 1, this->_M_Finish()), this->_M_finish = __old_finish)) _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) /* * Within the basic_string implementation we are only going to check for * self referencing if iterators are string iterators or _CharT pointers. * A user could encapsulate those iterator within their own iterator interface * and in this case lead to a bad behavior, this is a known limitation. */ typedef typename _AreSameUnCVTypes<_InputIter, iterator>::_Ret _IsIterator; typedef typename _AreSameUnCVTypes<_InputIter, const_iterator>::_Ret _IsConstIterator; typedef typename _Lor2<_IsIterator, _IsConstIterator>::_Ret _CheckInside; _M_insert_aux(__p, __first, __last, _CheckInside()); } template <class _RandomIter> void _M_insert_aux (iterator __p, _RandomIter __first, _RandomIter __last, const __true_type& /*_CheckInside*/) { _STLP_FIX_LITERAL_BUG(__p) _M_insert(__p, &(*__first), &(*__last), _M_inside(&(*__first))); } template<class _InputIter> void _M_insert_aux (iterator __p, _InputIter __first, _InputIter __last, const __false_type& /*_CheckInside*/) { _STLP_FIX_LITERAL_BUG(__p) _M_insertT(__p, __first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIter)); } 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 public: #if !defined (_STLP_MEMBER_TEMPLATES) || \ !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS) 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_destroy_back(); --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); pointer __new_finish = this->_M_Finish() - (__last - __first); this->_M_destroy_ptr_range(__new_finish + 1, this->_M_Finish() + 1); this->_M_finish = __new_finish; } return __first; } public: // Replace. (Conceptually equivalent // to erase followed by insert.) _Self& replace(size_type __pos, size_type __n, const _Self& __s) { if (__pos > size()) this->_M_throw_out_of_range(); const size_type __len = (min) (__n, size() - __pos); if (size() - __len >= max_size() - __s.size()) 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) { if (__pos1 > size() || __pos2 > __s.size()) this->_M_throw_out_of_range(); const size_type __len1 = (min) (__n1, size() - __pos1); const size_type __len2 = (min) (__n2, __s.size() - __pos2); if (size() - __len1 >= max_size() - __len2) 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) if (__pos > size()) this->_M_throw_out_of_range(); const size_type __len = (min) (__n1, size() - __pos); if (__n2 > max_size() || size() - __len >= max_size() - __n2) 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) if (__pos > size()) this->_M_throw_out_of_range(); const size_type __len = (min) (__n1, size() - __pos); const size_type __n2 = _Traits::length(__s); if (__n2 > max_size() || size() - __len >= max_size() - __n2) this->_M_throw_length_error(); return _M_replace(begin() + __pos, begin() + __pos + __len, __s, __s + _Traits::length(__s), _M_inside(__s)); } _Self& replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) { if (__pos > size()) this->_M_throw_out_of_range(); const size_type __len = (min) (__n1, size() - __pos); if (__n2 > max_size() || size() - __len >= max_size() - __n2) 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); protected: // Helper functions for replace. _Self& _M_replace(iterator __first, iterator __last, const _CharT* __f, const _CharT* __l, bool __self_ref); public: #if defined (_STLP_MEMBER_TEMPLATES) # if !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) typedef typename _AreSameUnCVTypes<_InputIter, iterator>::_Ret _IsIterator; typedef typename _AreSameUnCVTypes<_InputIter, const_iterator>::_Ret _IsConstIterator; typedef typename _Lor2<_IsIterator, _IsConstIterator>::_Ret _CheckInside; return _M_replace_aux(__first, __last, __f, __l, _CheckInside()); } template <class _RandomIter> _Self& _M_replace_aux(iterator __first, iterator __last, _RandomIter __f, _RandomIter __l, __true_type const& /*_CheckInside*/) { _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last) return _M_replace(__first, __last, &(*__f), &(*__l), _M_inside(&(*__f))); } template <class _InputIter> _Self& _M_replace_aux(iterator __first, iterator __last, _InputIter __f, _InputIter __l, __false_type const& /*_CheckInside*/) { _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last) return _M_replaceT(__first, __last, __f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); } template <class _InputIter> _Self& _M_replaceT(iterator __first, iterator __last, _InputIter __f, _InputIter __l, const input_iterator_tag&__ite_tag) { _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last) for ( ; __first != __last && __f != __l; ++__first, ++__f) _Traits::assign(*__first, *__f); if (__f == __l) erase(__first, __last); else _M_insertT(__last, __f, __l, __ite_tag); return *this; } template <class _ForwardIter> _Self& _M_replaceT(iterator __first, iterator __last, _ForwardIter __f, _ForwardIter __l, const forward_iterator_tag &__ite_tag) { _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last) difference_type __n = distance(__f, __l); const difference_type __len = __last - __first; if (__len >= __n) { _M_copyT(__f, __l, __first); erase(__first + __n, __last); } else { _ForwardIter __m = __f; advance(__m, __len); _M_copyT(__f, __m, __first); _M_insertT(__last, __m, __l, __ite_tag); } return *this; } 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 #endif #if !defined (_STLP_MEMBER_TEMPLATES) || \ !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS) # if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) _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 #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); } 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 /* _STLP_USE_TEMPLATE_EXPRESSION */ }; #if !defined (_STLP_STATIC_CONST_INIT_BUG) # 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 #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); } #endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */ #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) template <class _CharT, class _Traits, class _Alloc> struct __move_traits<basic_string<_CharT, _Traits, _Alloc> > { typedef __stlp_movable 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: */

• ソフトウェア開発
• ホームページ制作
• Doxygen Source Document
• Tcl Source Document