deque.tcc

来自「symbian上STL模板库的实现」· TCC 代码 · 共 719 行 · 第 1/2 页

// Deque implementation (out of line) -*- C++ -*-

// Copyright (C) 2001, 2002, 2003, 2004 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.

/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 * Copyright (c) 1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 */

/** @file deque.tcc
 *  This is an internal header file, included by other library headers.
 *  You should not attempt to use it directly.
 */

#ifndef _DEQUE_TCC
#define _DEQUE_TCC 1

namespace _GLIBCXX_STD
{
    template <typename _Tp, typename _Alloc>
        deque<_Tp,_Alloc>&
        deque<_Tp,_Alloc>::
        operator=(const deque& __x)
        {
            const size_type __len = size();
            if (&__x != this)
            {
                if (__len >= __x.size())
                    erase(std::copy(__x.begin(), __x.end(), this->_M_impl._M_start),
                            this->_M_impl._M_finish);
                else
                {
                    const_iterator __mid = __x.begin() + difference_type(__len);
                    std::copy(__x.begin(), __mid, this->_M_impl._M_start);
                    insert(this->_M_impl._M_finish, __mid, __x.end());
                }
            }
            return *this;
        }

    template <typename _Tp, typename _Alloc>
        typename deque<_Tp,_Alloc>::iterator
        deque<_Tp,_Alloc>::
        insert(iterator position, const value_type& __x)
        {
            if (position._M_cur == this->_M_impl._M_start._M_cur)
            {
                push_front(__x);
                return this->_M_impl._M_start;
            }
            else if (position._M_cur == this->_M_impl._M_finish._M_cur)
            {
                push_back(__x);
                iterator __tmp = this->_M_impl._M_finish;
                --__tmp;
                return __tmp;
            }
            else
                return _M_insert_aux(position, __x);
        }

    template <typename _Tp, typename _Alloc>
        typename deque<_Tp,_Alloc>::iterator
        deque<_Tp,_Alloc>::
        erase(iterator __position)
        {
            iterator __next = __position;
            ++__next;
            size_type __index = __position - this->_M_impl._M_start;
            if (__index < (size() >> 1))
            {
                std::copy_backward(this->_M_impl._M_start, __position, __next);
                pop_front();
            }
            else
            {
                std::copy(__next, this->_M_impl._M_finish, __position);
                pop_back();
            }
            return this->_M_impl._M_start + __index;
        }

    template <typename _Tp, typename _Alloc>
        typename deque<_Tp,_Alloc>::iterator
        deque<_Tp,_Alloc>::
        erase(iterator __first, iterator __last)
        {
            if (__first == this->_M_impl._M_start && __last == this->_M_impl._M_finish)
            {
                clear();
                return this->_M_impl._M_finish;
            }
            else
            {
                const difference_type __n = __last - __first;
                const difference_type __elems_before = __first - this->_M_impl._M_start;
                if (static_cast<size_type>(__elems_before) < (size() - __n) / 2)
                {
                    std::copy_backward(this->_M_impl._M_start, __first, __last);
                    iterator __new_start = this->_M_impl._M_start + __n;
                    std::_Destroy(this->_M_impl._M_start, __new_start);
                    _M_destroy_nodes(this->_M_impl._M_start._M_node, __new_start._M_node);
                    this->_M_impl._M_start = __new_start;
                }
                else
                {
                    std::copy(__last, this->_M_impl._M_finish, __first);
                    iterator __new_finish = this->_M_impl._M_finish - __n;
                    std::_Destroy(__new_finish, this->_M_impl._M_finish);
                    _M_destroy_nodes(__new_finish._M_node + 1,
                            this->_M_impl._M_finish._M_node + 1);
                    this->_M_impl._M_finish = __new_finish;
                }
                return this->_M_impl._M_start + __elems_before;
            }
        }

    template <typename _Tp, typename _Alloc>
        void
        deque<_Tp,_Alloc>::
        clear()
        {
            for (_Map_pointer __node = this->_M_impl._M_start._M_node + 1;
                    __node < this->_M_impl._M_finish._M_node;
                    ++__node)
            {
                std::_Destroy(*__node, *__node + _S_buffer_size());
                _M_deallocate_node(*__node);
            }

            if (this->_M_impl._M_start._M_node != this->_M_impl._M_finish._M_node)
            {
                std::_Destroy(this->_M_impl._M_start._M_cur, this->_M_impl._M_start._M_last);
                std::_Destroy(this->_M_impl._M_finish._M_first, this->_M_impl._M_finish._M_cur);
                _M_deallocate_node(this->_M_impl._M_finish._M_first);
            }
            else
                std::_Destroy(this->_M_impl._M_start._M_cur, this->_M_impl._M_finish._M_cur);

            this->_M_impl._M_finish = this->_M_impl._M_start;
        }

    template <typename _Tp, class _Alloc>
        template <typename _InputIterator>
        void
        deque<_Tp,_Alloc>
        ::_M_assign_aux(_InputIterator __first, _InputIterator __last,
                input_iterator_tag)
        {
            iterator __cur = begin();
            for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
                *__cur = *__first;
            if (__first == __last)
                erase(__cur, end());
            else
                insert(end(), __first, __last);
        }

    template <typename _Tp, typename _Alloc>
        void
        deque<_Tp,_Alloc>::
        _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
        {
            if (__pos._M_cur == this->_M_impl._M_start._M_cur)
            {
                iterator __new_start = _M_reserve_elements_at_front(__n);
                try
                {
                    std::uninitialized_fill(__new_start, this->_M_impl._M_start, __x);
                    this->_M_impl._M_start = __new_start;
                }
                catch(...)
                {
                    _M_destroy_nodes(__new_start._M_node, this->_M_impl._M_start._M_node);
                    __throw_exception_again;
                }
            }
            else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
            {
                iterator __new_finish = _M_reserve_elements_at_back(__n);
                try
                {
                    std::uninitialized_fill(this->_M_impl._M_finish, __new_finish, __x);
                    this->_M_impl._M_finish = __new_finish;
                }
                catch(...)
                {
                    _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
                            __new_finish._M_node + 1);
                    __throw_exception_again;
                }
            }
            else
                _M_insert_aux(__pos, __n, __x);
        }

    template <typename _Tp, typename _Alloc>
        void
        deque<_Tp,_Alloc>::
        _M_fill_initialize(const value_type& __value)
        {
            _Map_pointer __cur;
            try
            {
                for (__cur = this->_M_impl._M_start._M_node;
                        __cur < this->_M_impl._M_finish._M_node;
                        ++__cur)
                    std::uninitialized_fill(*__cur, *__cur + _S_buffer_size(), __value);
                std::uninitialized_fill(this->_M_impl._M_finish._M_first,
                        this->_M_impl._M_finish._M_cur,
                        __value);
            }
            catch(...)
            {
                std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur));
                __throw_exception_again;
            }
        }

    template <typename _Tp, typename _Alloc>
        template <typename _InputIterator>
        void
        deque<_Tp,_Alloc>::
        _M_range_initialize(_InputIterator __first, _InputIterator __last,
                input_iterator_tag)
        {
            this->_M_initialize_map(0);
            try
            {
                for ( ; __first != __last; ++__first)
                    push_back(*__first);
            }
            catch(...)
            {
                clear();
                __throw_exception_again;
            }
        }

    template <typename _Tp, typename _Alloc>
        template <typename _ForwardIterator>
        void
        deque<_Tp,_Alloc>::
        _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
                forward_iterator_tag)
        {
            const size_type __n = std::distance(__first, __last);
            this->_M_initialize_map(__n);

            _Map_pointer __cur_node;
            try
            {
                for (__cur_node = this->_M_impl._M_start._M_node;
                        __cur_node < this->_M_impl._M_finish._M_node;
                        ++__cur_node)
                {
                    _ForwardIterator __mid = __first;
                    std::advance(__mid, _S_buffer_size());
                    std::uninitialized_copy(__first, __mid, *__cur_node);
                    __first = __mid;
                }
                std::uninitialized_copy(__first, __last, this->_M_impl._M_finish._M_first);
            }
            catch(...)
            {
                std::_Destroy(this->_M_impl._M_start, iterator(*__cur_node, __cur_node));
                __throw_exception_again;
            }
        }

    // Called only if _M_impl._M_finish._M_cur == _M_impl._M_finish._M_last - 1.
    template <typename _Tp, typename _Alloc>
        void deque<_Tp,_Alloc>::
        _M_push_back_aux(const value_type& __t)
        {
            value_type __t_copy = __t;
            _M_reserve_map_at_back();
            *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
            try
            {
                std::_Construct(this->_M_impl._M_finish._M_cur, __t_copy);
                this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node + 1);
                this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
            }
            catch(...)
            {
                _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
                __throw_exception_again;
            }
        }

    // Called only if _M_impl._M_start._M_cur == _M_impl._M_start._M_first.
    template <typename _Tp, typename _Alloc>
        void
        deque<_Tp,_Alloc>::
        _M_push_front_aux(const value_type& __t)
        {
            value_type __t_copy = __t;
            _M_reserve_map_at_front();
            *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
            try
            {
                this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node - 1);
                this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
                std::_Construct(this->_M_impl._M_start._M_cur, __t_copy);
            }
            catch(...)
            {
                ++this->_M_impl._M_start;
                _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
                __throw_exception_again;
            }
        }