string

symbian上STL模板库的实现

// Debugging string implementation -*- C++ -*-

// Copyright (C) 2003
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

#ifndef _GLIBCXX_DEBUG_STRING
#define _GLIBCXX_DEBUG_STRING 1

#include <string>
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>

namespace __gnu_debug
{
    template<typename _CharT, typename _Traits, typename _Allocator>
        class basic_string
        : public std::basic_string<_CharT, _Traits, _Allocator>,
        public __gnu_debug::_Safe_sequence<basic_string<_CharT, _Traits,
        _Allocator> >
    {
        typedef std::basic_string<_CharT, _Traits, _Allocator> _Base;
        typedef __gnu_debug::_Safe_sequence<basic_string>     _Safe_base;

        public:
        // types:
        typedef _Traits				       traits_type;
        typedef typename _Traits::char_type		       value_type;
        typedef _Allocator				       allocator_type;
        typedef typename _Allocator::size_type             size_type;
        typedef typename _Allocator::difference_type       difference_type;
        typedef typename _Allocator::reference             reference;
        typedef typename _Allocator::const_reference       const_reference;
        typedef typename _Allocator::pointer               pointer;
        typedef typename _Allocator::const_pointer         const_pointer;

        typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, basic_string>
            iterator;
        typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
                basic_string> const_iterator;

        typedef std::reverse_iterator<iterator>            reverse_iterator;
        typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;

        using _Base::npos;

        // 21.3.1 construct/copy/destroy:
        explicit basic_string(const _Allocator& __a = _Allocator())
            : _Base(__a)
        { }

        // Provides conversion from a release-mode string to a debug-mode string
        basic_string(const _Base& __base) : _Base(__base), _Safe_base() { }

        // _GLIBCXX_RESOLVE_LIB_DEFECTS
        // 42. string ctors specify wrong default allocator
        basic_string(const basic_string& __str)
            : _Base(__str, 0, _Base::npos, __str.get_allocator()), _Safe_base()
        { }

        // _GLIBCXX_RESOLVE_LIB_DEFECTS
        // 42. string ctors specify wrong default allocator
        basic_string(const basic_string& __str, size_type __pos,
                size_type __n = _Base::npos,
                const _Allocator& __a = _Allocator())
            : _Base(__str, __pos, __n, __a)
        { }

        basic_string(const _CharT* __s, size_type __n,
                const _Allocator& __a = _Allocator())
            : _Base(__gnu_debug::__check_string(__s, __n), __n, __a)
        { }

        basic_string(const _CharT* __s, const _Allocator& __a = _Allocator())
            : _Base(__gnu_debug::__check_string(__s), __a)
        { this->assign(__s); }

        basic_string(size_type __n, _CharT __c,
                const _Allocator& __a = _Allocator())
            : _Base(__n, __c, __a)
        { }

        template<typename _InputIterator>
            basic_string(_InputIterator __begin, _InputIterator __end,
                    const _Allocator& __a = _Allocator())
            : _Base(__gnu_debug::__check_valid_range(__begin, __end), __end, __a)
            { }

        ~basic_string() { }

        basic_string&
            operator=(const basic_string& __str)
            {
                *static_cast<_Base*>(this) = __str;
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            operator=(const _CharT* __s)
            {
                __glibcxx_check_string(__s);
                *static_cast<_Base*>(this) = __s;
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            operator=(_CharT __c)
            {
                *static_cast<_Base*>(this) = __c;
                this->_M_invalidate_all();
                return *this;
            }

        // 21.3.2 iterators:
        iterator
            begin()
            { return iterator(_Base::begin(), this); }

        const_iterator
            begin() const
            { return const_iterator(_Base::begin(), this); }

        iterator
            end()
            { return iterator(_Base::end(), this); }

        const_iterator
            end() const
            { return const_iterator(_Base::end(), this); }

        reverse_iterator
            rbegin()
            { return reverse_iterator(end()); }

        const_reverse_iterator
            rbegin() const
            { return const_reverse_iterator(end()); }

        reverse_iterator
            rend()
            { return reverse_iterator(begin()); }

        const_reverse_iterator
            rend() const
            { return const_reverse_iterator(begin()); }

        // 21.3.3 capacity:
        using _Base::size;
        using _Base::length;
        using _Base::max_size;

        void
            resize(size_type __n, _CharT __c)
            {
                _Base::resize(__n, __c);
                this->_M_invalidate_all();
            }

        void
            resize(size_type __n)
            { this->resize(__n, _CharT()); }

        using _Base::capacity;
        using _Base::reserve;

        void
            clear()
            {
                _Base::clear();
                this->_M_invalidate_all();
            }

        using _Base::empty;

        // 21.3.4 element access:
        const_reference
            operator[](size_type __pos) const
            {
                _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
                        _M_message(::__gnu_debug::__msg_subscript_oob)
                        ._M_sequence(*this, "this")
                        ._M_integer(__pos, "__pos")
                        ._M_integer(this->size(), "size"));
                return _M_base()[__pos];
            }

        reference
            operator[](size_type __pos)
            {
                __glibcxx_check_subscript(__pos);
                return _M_base()[__pos];
            }

        using _Base::at;

        // 21.3.5 modifiers:
        basic_string&
            operator+=(const basic_string& __str)
            {
                _M_base() += __str;
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            operator+=(const _CharT* __s)
            {
                __glibcxx_check_string(__s);
                _M_base() += __s;
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            operator+=(_CharT __c)
            {
                _M_base() += __c;
                this->_M_invalidate_all();
                return *this;
            }

        basic_string&
            append(const basic_string& __str)
            {
                _Base::append(__str);
                this->_M_invalidate_all();
                return *this;
            }

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

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

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

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

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

        // _GLIBCXX_RESOLVE_LIB_DEFECTS
        // 7. string clause minor problems
        void
            push_back(_CharT __c)
            {
                _Base::push_back(__c);
                this->_M_invalidate_all();
            }

        basic_string&
            assign(const basic_string& __x)
            {
                _Base::assign(__x);
                this->_M_invalidate_all();
                return *this;
            }

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

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

        basic_string&