string

symbian上STL模板库的实现

            assign(const _CharT* __s)
            {
                __glibcxx_check_string(__s);
                _Base::assign(__s);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            assign(size_type __n, _CharT __c)
            {
                _Base::assign(__n, __c);
                this->_M_invalidate_all();
                return *this;
            }

        template<typename _InputIterator>
            basic_string&
            assign(_InputIterator __first, _InputIterator __last)
            {
                __glibcxx_check_valid_range(__first, __last);
                _Base::assign(__first, __last);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            insert(size_type __pos1, const basic_string& __str)
            {
                _Base::insert(__pos1, __str);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            insert(size_type __pos1, const basic_string& __str,
                    size_type __pos2, size_type __n)
            {
                _Base::insert(__pos1, __str, __pos2, __n);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            insert(size_type __pos, const _CharT* __s, size_type __n)
            {
                __glibcxx_check_string(__s);
                _Base::insert(__pos, __s, __n);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            insert(size_type __pos, const _CharT* __s)
            {
                __glibcxx_check_string(__s);
                _Base::insert(__pos, __s);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            insert(size_type __pos, size_type __n, _CharT __c)
            {
                _Base::insert(__pos, __n, __c);
                this->_M_invalidate_all();
                return *this;
            }

        iterator
            insert(iterator __p, _CharT __c)
            {
                __glibcxx_check_insert(__p);
                typename _Base::iterator __res = _Base::insert(__p.base(), __c);
                this->_M_invalidate_all();
                return iterator(__res, this);
            }

        void
            insert(iterator __p, size_type __n, _CharT __c)
            {
                __glibcxx_check_insert(__p);
                _Base::insert(__p.base(), __n, __c);
                this->_M_invalidate_all();
            }

        template<typename _InputIterator>
            void
            insert(iterator __p, _InputIterator __first, _InputIterator __last)
            {
                __glibcxx_check_insert_range(__p, __first, __last);
                _Base::insert(__p.base(), __first, __last);
                this->_M_invalidate_all();
            }

        basic_string&
            erase(size_type __pos = 0, size_type __n = _Base::npos)
            {
                _Base::erase(__pos, __n);
                this->_M_invalidate_all();
                return *this;
            }

        iterator
            erase(iterator __position)
            {
                __glibcxx_check_erase(__position);
                typename _Base::iterator __res = _Base::erase(__position.base());
                this->_M_invalidate_all();
                return iterator(__res, this);
            }

        iterator
            erase(iterator __first, iterator __last)
            {
                // _GLIBCXX_RESOLVE_LIB_DEFECTS
                // 151. can't currently clear() empty container
                __glibcxx_check_erase_range(__first, __last);
                typename _Base::iterator __res = _Base::erase(__first.base(),
                        __last.base());
                this->_M_invalidate_all();
                return iterator(__res, this);
            }

        basic_string&
            replace(size_type __pos1, size_type __n1, const basic_string& __str)
            {
                _Base::replace(__pos1, __n1, __str);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            replace(size_type __pos1, size_type __n1, const basic_string& __str,
                    size_type __pos2, size_type __n2)
            {
                _Base::replace(__pos1, __n1, __str, __pos2, __n2);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            replace(size_type __pos, size_type __n1, const _CharT* __s,
                    size_type __n2)
            {
                __glibcxx_check_string_len(__s, __n2);
                _Base::replace(__pos, __n1, __s, __n2);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            replace(size_type __pos, size_type __n1, const _CharT* __s)
            {
                __glibcxx_check_string(__s);
                _Base::replace(__pos, __n1, __s);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
            {
                _Base::replace(__pos, __n1, __n2, __c);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            replace(iterator __i1, iterator __i2, const basic_string& __str)
            {
                __glibcxx_check_erase_range(__i1, __i2);
                _Base::replace(__i1.base(), __i2.base(), __str);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
            {
                __glibcxx_check_erase_range(__i1, __i2);
                __glibcxx_check_string_len(__s, __n);
                _Base::replace(__i1.base(), __i2.base(), __s, __n);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            replace(iterator __i1, iterator __i2, const _CharT* __s)
            {
                __glibcxx_check_erase_range(__i1, __i2);
                __glibcxx_check_string(__s);
                _Base::replace(__i1.base(), __i2.base(), __s);
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
            {
                __glibcxx_check_erase_range(__i1, __i2);
                _Base::replace(__i1.base(), __i2.base(), __n, __c);
                this->_M_invalidate_all();
                return *this;
            }

        template<typename _InputIterator>
            basic_string&
            replace(iterator __i1, iterator __i2,
                    _InputIterator __j1, _InputIterator __j2)
            {
                __glibcxx_check_erase_range(__i1, __i2);
                __glibcxx_check_valid_range(__j1, __j2);
                _Base::replace(__i1.base(), __i2.base(), __j1, __j2);
                this->_M_invalidate_all();
                return *this;
            }

        size_type
            copy(_CharT* __s, size_type __n, size_type __pos = 0) const
            {
                __glibcxx_check_string_len(__s, __n);
                return _Base::copy(__s, __n, __pos);
            }

        void
            swap(basic_string<_CharT,_Traits,_Allocator>& __x)
            {
                _Base::swap(__x);
                this->_M_swap(__x);
                this->_M_invalidate_all();
                __x._M_invalidate_all();
            }

        // 21.3.6 string operations:
        const _CharT*
            c_str() const
            {
                const _CharT* __res = _Base::c_str();
                this->_M_invalidate_all();
                return __res;
            }

        const _CharT*
            data() const
            {
                const _CharT* __res = _Base::data();
                this->_M_invalidate_all();
                return __res;
            }

        using _Base::get_allocator;

        size_type
            find(const basic_string& __str, size_type __pos = 0) const
            { return _Base::find(__str, __pos); }

        size_type
            find(const _CharT* __s, size_type __pos, size_type __n) const
            {
                __glibcxx_check_string(__s);
                return _Base::find(__s, __pos, __n);
            }

        size_type
            find(const _CharT* __s, size_type __pos = 0) const
            {
                __glibcxx_check_string(__s);
                return _Base::find(__s, __pos);
            }

        size_type
            find(_CharT __c, size_type __pos = 0) const
            { return _Base::find(__c, __pos); }

        size_type
            rfind(const basic_string& __str, size_type __pos = _Base::npos) const
            { return _Base::rfind(__str, __pos); }

        size_type
            rfind(const _CharT* __s, size_type __pos, size_type __n) const
            {
                __glibcxx_check_string_len(__s, __n);
                return _Base::rfind(__s, __pos, __n);
            }

        size_type
            rfind(const _CharT* __s, size_type __pos = _Base::npos) const
            {
                __glibcxx_check_string(__s);
                return _Base::rfind(__s, __pos);
            }

        size_type
            rfind(_CharT __c, size_type __pos = _Base::npos) const
            { return _Base::rfind(__c, __pos); }

        size_type
            find_first_of(const basic_string& __str, size_type __pos = 0) const
            { return _Base::find_first_of(__str, __pos); }

        size_type
            find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
            {
                __glibcxx_check_string(__s);
                return _Base::find_first_of(__s, __pos, __n);
            }

        size_type
            find_first_of(const _CharT* __s, size_type __pos = 0) const
            {
                __glibcxx_check_string(__s);
                return _Base::find_first_of(__s, __pos);
            }

        size_type
            find_first_of(_CharT __c, size_type __pos = 0) const
            { return _Base::find_first_of(__c, __pos); }

        size_type
            find_last_of(const basic_string& __str, size_type __pos = _Base::npos) const
            { return _Base::find_last_of(__str, __pos); }

        size_type
            find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
            {
                __glibcxx_check_string(__s);
                return _Base::find_last_of(__s, __pos, __n);
            }

        size_type
            find_last_of(const _CharT* __s, size_type __pos = _Base::npos) const
            {
                __glibcxx_check_string(__s);