8fbc5ae723
* cp-tree.h (lang_type_class): Remove is_partial_instantiation. (PARTIAL_INSTANTIATION_P): Remove. (IMPLICIT_TYPENAME_P): Likewise. (IMPLICIT_TYPENAME_TYPE_DECL_P): Likewise. (build_typename_type): Remove declaration. (parmlist_is_exprlist): Likewise. * decl.c (build_typename_type): Make it static, remove third parameter. (push_class_binding): Don't do implicit typename stuff. (make_typename_type): Likewise. (lookup_name_real): Likewise. (grokdeclarator): Don't try to convert declarations into initializations. Don't do implicit typename stuff. (parmlist_is_exprlist): Remove. (xref_basetypes): Simplify. * decl2.c (grokfield): Don't try to convert declarations into initializations. (build_anon_union_vars): Do this while processing templates, too. (finish_anon_union): Likewise. * error.c (dump_type): Remove implicit typename handling. * parser.c (cp_parser_diagnose_invalid_type_name): New method. (cp_parser_primary_expression): Correct handling of names not found by unqualified name lookup in templates. (cp_parser_nested_name_specifier_opt): Avoid checking dependency of types when possible. (cp_parser_simple_declaration): Complain intelligently about some invalid declarations. (cp_parser_member_declaration): Likewise. (cp_parser_constructor_declarator_p): Don't check when we're in a function scope. * pt.c (instantiate_class_template): Remove PARTIAL_INSTANTIATION_P gunk. * search.c (lookup_field_r): Don't build implicit typenames. (marked_pushdecls_p): Don't enter dependent base types. (unmarked_pushdecls_p): Likewise. * semantics.c (begin_class_definition): Remove implicit typename stuff. * config/locale/gnu/messages_members.h: Use this-> to refer to unqualified members of base clasess. * config/locale/ieee_1003.1-2001/codecvt_specializations.h: Likewise. * include/bits/codecvt.h: Likewise. * include/bits/deque.tcc: Likewise. * include/bits/fstream.tcc: Likewise. * include/bits/istream.tcc: Likewise. * include/bits/list.tcc: Likewise. * include/bits/locale_facets.h: Likewise. * include/bits/ostream.tcc: Likewise. * include/bits/sstream.tcc: Likewise. * include/bits/stl_bvector.h: Likewise. * include/bits/stl_deque.h: Likewise. * include/bits/stl_list.h: Likewise. * include/bits/stl_tree.h: Likewise. * include/bits/stl_vector.h: Likewise. * include/bits/vector.tcc: Likewise. * include/ext/ropeimpl.h: Likewise. * include/ext/stdio_filebuf.h: Likewise. * include/ext/stl_rope.h: Likewise. * include/std/std_fstream.h: Likewise. * include/std/std_sstream.h: Likewise. Co-Authored-By: Jeffrey Oldham <oldham@codesourcery.com> From-SVN: r61403
714 lines
23 KiB
C++
714 lines
23 KiB
C++
// Deque implementation (out of line) -*- C++ -*-
|
|
|
|
// Copyright (C) 2001, 2002, 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.
|
|
|
|
/*
|
|
*
|
|
* 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 __GLIBCPP_INTERNAL_DEQUE_TCC
|
|
#define __GLIBCPP_INTERNAL_DEQUE_TCC
|
|
|
|
namespace 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(copy(__x.begin(), __x.end(), this->_M_start), this->_M_finish);
|
|
else
|
|
{
|
|
const_iterator __mid = __x.begin() + difference_type(__len);
|
|
copy(__x.begin(), __mid, this->_M_start);
|
|
insert(this->_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_start._M_cur)
|
|
{
|
|
push_front(__x);
|
|
return this->_M_start;
|
|
}
|
|
else if (position._M_cur == this->_M_finish._M_cur)
|
|
{
|
|
push_back(__x);
|
|
iterator __tmp = this->_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_start;
|
|
if (__index < (size() >> 1))
|
|
{
|
|
copy_backward(this->_M_start, __position, __next);
|
|
pop_front();
|
|
}
|
|
else
|
|
{
|
|
copy(__next, this->_M_finish, __position);
|
|
pop_back();
|
|
}
|
|
return this->_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_start && __last == this->_M_finish)
|
|
{
|
|
clear();
|
|
return this->_M_finish;
|
|
}
|
|
else
|
|
{
|
|
difference_type __n = __last - __first;
|
|
difference_type __elems_before = __first - this->_M_start;
|
|
if (static_cast<size_type>(__elems_before) < (size() - __n) / 2)
|
|
{
|
|
copy_backward(this->_M_start, __first, __last);
|
|
iterator __new_start = this->_M_start + __n;
|
|
_Destroy(this->_M_start, __new_start);
|
|
_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
|
|
this->_M_start = __new_start;
|
|
}
|
|
else
|
|
{
|
|
copy(__last, this->_M_finish, __first);
|
|
iterator __new_finish = this->_M_finish - __n;
|
|
_Destroy(__new_finish, this->_M_finish);
|
|
_M_destroy_nodes(__new_finish._M_node + 1,
|
|
this->_M_finish._M_node + 1);
|
|
this->_M_finish = __new_finish;
|
|
}
|
|
return this->_M_start + __elems_before;
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp,_Alloc>::
|
|
clear()
|
|
{
|
|
for (_Map_pointer __node = this->_M_start._M_node + 1;
|
|
__node < this->_M_finish._M_node;
|
|
++__node)
|
|
{
|
|
_Destroy(*__node, *__node + _S_buffer_size());
|
|
_M_deallocate_node(*__node);
|
|
}
|
|
|
|
if (this->_M_start._M_node != this->_M_finish._M_node)
|
|
{
|
|
_Destroy(this->_M_start._M_cur, this->_M_start._M_last);
|
|
_Destroy(this->_M_finish._M_first, this->_M_finish._M_cur);
|
|
_M_deallocate_node(this->_M_finish._M_first);
|
|
}
|
|
else
|
|
_Destroy(this->_M_start._M_cur, this->_M_finish._M_cur);
|
|
|
|
this->_M_finish = this->_M_start;
|
|
}
|
|
|
|
template <typename _Tp, class _Alloc>
|
|
template <typename _InputIter>
|
|
void
|
|
deque<_Tp,_Alloc>
|
|
::_M_assign_aux(_InputIter __first, _InputIter __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_start._M_cur)
|
|
{
|
|
iterator __new_start = _M_reserve_elements_at_front(__n);
|
|
try
|
|
{
|
|
uninitialized_fill(__new_start, this->_M_start, __x);
|
|
this->_M_start = __new_start;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node);
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
else if (__pos._M_cur == this->_M_finish._M_cur)
|
|
{
|
|
iterator __new_finish = _M_reserve_elements_at_back(__n);
|
|
try
|
|
{
|
|
uninitialized_fill(this->_M_finish, __new_finish, __x);
|
|
this->_M_finish = __new_finish;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(this->_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_start._M_node;
|
|
__cur < this->_M_finish._M_node;
|
|
++__cur)
|
|
uninitialized_fill(*__cur, *__cur + _S_buffer_size(), __value);
|
|
uninitialized_fill(this->_M_finish._M_first,
|
|
this->_M_finish._M_cur,
|
|
__value);
|
|
}
|
|
catch(...)
|
|
{
|
|
_Destroy(this->_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)
|
|
{
|
|
_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)
|
|
{
|
|
size_type __n = std::distance(__first, __last);
|
|
_M_initialize_map(__n);
|
|
|
|
_Map_pointer __cur_node;
|
|
try
|
|
{
|
|
for (__cur_node = this->_M_start._M_node;
|
|
__cur_node < this->_M_finish._M_node;
|
|
++__cur_node)
|
|
{
|
|
_ForwardIterator __mid = __first;
|
|
advance(__mid, _S_buffer_size());
|
|
uninitialized_copy(__first, __mid, *__cur_node);
|
|
__first = __mid;
|
|
}
|
|
uninitialized_copy(__first, __last, this->_M_finish._M_first);
|
|
}
|
|
catch(...)
|
|
{
|
|
_Destroy(this->_M_start, iterator(*__cur_node, __cur_node));
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
|
|
// Called only if _M_finish._M_cur == _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_finish._M_node + 1) = _M_allocate_node();
|
|
try
|
|
{
|
|
_Construct(this->_M_finish._M_cur, __t_copy);
|
|
this->_M_finish._M_set_node(this->_M_finish._M_node + 1);
|
|
this->_M_finish._M_cur = this->_M_finish._M_first;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_deallocate_node(*(this->_M_finish._M_node + 1));
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
|
|
// Called only if _M_start._M_cur == _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_start._M_node - 1) = _M_allocate_node();
|
|
try
|
|
{
|
|
this->_M_start._M_set_node(this->_M_start._M_node - 1);
|
|
this->_M_start._M_cur = this->_M_start._M_last - 1;
|
|
_Construct(this->_M_start._M_cur, __t_copy);
|
|
}
|
|
catch(...)
|
|
{
|
|
++this->_M_start;
|
|
_M_deallocate_node(*(this->_M_start._M_node - 1));
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
|
|
// Called only if _M_finish._M_cur == _M_finish._M_first.
|
|
template <typename _Tp, typename _Alloc>
|
|
void deque<_Tp,_Alloc>::
|
|
_M_pop_back_aux()
|
|
{
|
|
_M_deallocate_node(this->_M_finish._M_first);
|
|
this->_M_finish._M_set_node(this->_M_finish._M_node - 1);
|
|
this->_M_finish._M_cur = this->_M_finish._M_last - 1;
|
|
_Destroy(this->_M_finish._M_cur);
|
|
}
|
|
|
|
// Called only if _M_start._M_cur == _M_start._M_last - 1. Note that
|
|
// if the deque has at least one element (a precondition for this member
|
|
// function), and if _M_start._M_cur == _M_start._M_last, then the deque
|
|
// must have at least two nodes.
|
|
template <typename _Tp, typename _Alloc>
|
|
void deque<_Tp,_Alloc>::
|
|
_M_pop_front_aux()
|
|
{
|
|
_Destroy(this->_M_start._M_cur);
|
|
_M_deallocate_node(this->_M_start._M_first);
|
|
this->_M_start._M_set_node(this->_M_start._M_node + 1);
|
|
this->_M_start._M_cur = this->_M_start._M_first;
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
template <typename _InputIterator>
|
|
void
|
|
deque<_Tp,_Alloc>::
|
|
_M_range_insert_aux(iterator __pos,
|
|
_InputIterator __first, _InputIterator __last,
|
|
input_iterator_tag)
|
|
{
|
|
copy(__first, __last, inserter(*this, __pos));
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
template <typename _ForwardIterator>
|
|
void
|
|
deque<_Tp,_Alloc>::
|
|
_M_range_insert_aux(iterator __pos,
|
|
_ForwardIterator __first, _ForwardIterator __last,
|
|
forward_iterator_tag)
|
|
{
|
|
size_type __n = std::distance(__first, __last);
|
|
if (__pos._M_cur == this->_M_start._M_cur)
|
|
{
|
|
iterator __new_start = _M_reserve_elements_at_front(__n);
|
|
try
|
|
{
|
|
uninitialized_copy(__first, __last, __new_start);
|
|
this->_M_start = __new_start;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node);
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
else if (__pos._M_cur == this->_M_finish._M_cur)
|
|
{
|
|
iterator __new_finish = _M_reserve_elements_at_back(__n);
|
|
try
|
|
{
|
|
uninitialized_copy(__first, __last, this->_M_finish);
|
|
this->_M_finish = __new_finish;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(this->_M_finish._M_node + 1,
|
|
__new_finish._M_node + 1);
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
else
|
|
_M_insert_aux(__pos, __first, __last, __n);
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
typename deque<_Tp, _Alloc>::iterator
|
|
deque<_Tp,_Alloc>::
|
|
_M_insert_aux(iterator __pos, const value_type& __x)
|
|
{
|
|
difference_type __index = __pos - this->_M_start;
|
|
value_type __x_copy = __x; // XXX copy
|
|
if (static_cast<size_type>(__index) < size() / 2)
|
|
{
|
|
push_front(front());
|
|
iterator __front1 = this->_M_start;
|
|
++__front1;
|
|
iterator __front2 = __front1;
|
|
++__front2;
|
|
__pos = this->_M_start + __index;
|
|
iterator __pos1 = __pos;
|
|
++__pos1;
|
|
copy(__front2, __pos1, __front1);
|
|
}
|
|
else
|
|
{
|
|
push_back(back());
|
|
iterator __back1 = this->_M_finish;
|
|
--__back1;
|
|
iterator __back2 = __back1;
|
|
--__back2;
|
|
__pos = this->_M_start + __index;
|
|
copy_backward(__pos, __back2, __back1);
|
|
}
|
|
*__pos = __x_copy;
|
|
return __pos;
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp,_Alloc>::
|
|
_M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
|
|
{
|
|
const difference_type __elems_before = __pos - this->_M_start;
|
|
size_type __length = this->size();
|
|
value_type __x_copy = __x;
|
|
if (__elems_before < difference_type(__length / 2))
|
|
{
|
|
iterator __new_start = _M_reserve_elements_at_front(__n);
|
|
iterator __old_start = this->_M_start;
|
|
__pos = this->_M_start + __elems_before;
|
|
try
|
|
{
|
|
if (__elems_before >= difference_type(__n))
|
|
{
|
|
iterator __start_n = this->_M_start + difference_type(__n);
|
|
uninitialized_copy(this->_M_start, __start_n, __new_start);
|
|
this->_M_start = __new_start;
|
|
copy(__start_n, __pos, __old_start);
|
|
fill(__pos - difference_type(__n), __pos, __x_copy);
|
|
}
|
|
else
|
|
{
|
|
__uninitialized_copy_fill(this->_M_start, __pos, __new_start,
|
|
this->_M_start, __x_copy);
|
|
this->_M_start = __new_start;
|
|
fill(__old_start, __pos, __x_copy);
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node);
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iterator __new_finish = _M_reserve_elements_at_back(__n);
|
|
iterator __old_finish = this->_M_finish;
|
|
const difference_type __elems_after =
|
|
difference_type(__length) - __elems_before;
|
|
__pos = this->_M_finish - __elems_after;
|
|
try
|
|
{
|
|
if (__elems_after > difference_type(__n))
|
|
{
|
|
iterator __finish_n = this->_M_finish - difference_type(__n);
|
|
uninitialized_copy(__finish_n, this->_M_finish, this->_M_finish);
|
|
this->_M_finish = __new_finish;
|
|
copy_backward(__pos, __finish_n, __old_finish);
|
|
fill(__pos, __pos + difference_type(__n), __x_copy);
|
|
}
|
|
else
|
|
{
|
|
__uninitialized_fill_copy(this->_M_finish,
|
|
__pos + difference_type(__n),
|
|
__x_copy, __pos, this->_M_finish);
|
|
this->_M_finish = __new_finish;
|
|
fill(__pos, __old_finish, __x_copy);
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(this->_M_finish._M_node + 1,
|
|
__new_finish._M_node + 1);
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
template <typename _ForwardIterator>
|
|
void
|
|
deque<_Tp,_Alloc>::
|
|
_M_insert_aux(iterator __pos,
|
|
_ForwardIterator __first, _ForwardIterator __last,
|
|
size_type __n)
|
|
{
|
|
const difference_type __elemsbefore = __pos - this->_M_start;
|
|
size_type __length = size();
|
|
if (static_cast<size_type>(__elemsbefore) < __length / 2)
|
|
{
|
|
iterator __new_start = _M_reserve_elements_at_front(__n);
|
|
iterator __old_start = this->_M_start;
|
|
__pos = this->_M_start + __elemsbefore;
|
|
try
|
|
{
|
|
if (__elemsbefore >= difference_type(__n))
|
|
{
|
|
iterator __start_n = this->_M_start + difference_type(__n);
|
|
uninitialized_copy(this->_M_start, __start_n, __new_start);
|
|
this->_M_start = __new_start;
|
|
copy(__start_n, __pos, __old_start);
|
|
copy(__first, __last, __pos - difference_type(__n));
|
|
}
|
|
else
|
|
{
|
|
_ForwardIterator __mid = __first;
|
|
advance(__mid, difference_type(__n) - __elemsbefore);
|
|
__uninitialized_copy_copy(this->_M_start, __pos,
|
|
__first, __mid, __new_start);
|
|
this->_M_start = __new_start;
|
|
copy(__mid, __last, __old_start);
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node);
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iterator __new_finish = _M_reserve_elements_at_back(__n);
|
|
iterator __old_finish = this->_M_finish;
|
|
const difference_type __elemsafter =
|
|
difference_type(__length) - __elemsbefore;
|
|
__pos = this->_M_finish - __elemsafter;
|
|
try
|
|
{
|
|
if (__elemsafter > difference_type(__n))
|
|
{
|
|
iterator __finish_n = this->_M_finish - difference_type(__n);
|
|
uninitialized_copy(__finish_n,
|
|
this->_M_finish,
|
|
this->_M_finish);
|
|
this->_M_finish = __new_finish;
|
|
copy_backward(__pos, __finish_n, __old_finish);
|
|
copy(__first, __last, __pos);
|
|
}
|
|
else
|
|
{
|
|
_ForwardIterator __mid = __first;
|
|
advance(__mid, __elemsafter);
|
|
__uninitialized_copy_copy(__mid, __last, __pos,
|
|
this->_M_finish, this->_M_finish);
|
|
this->_M_finish = __new_finish;
|
|
copy(__first, __mid, __pos);
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(this->_M_finish._M_node + 1,
|
|
__new_finish._M_node + 1);
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp,_Alloc>::
|
|
_M_new_elements_at_front(size_type __new_elems)
|
|
{
|
|
size_type __new_nodes
|
|
= (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
|
|
_M_reserve_map_at_front(__new_nodes);
|
|
size_type __i;
|
|
try
|
|
{
|
|
for (__i = 1; __i <= __new_nodes; ++__i)
|
|
*(this->_M_start._M_node - __i) = _M_allocate_node();
|
|
}
|
|
catch(...)
|
|
{
|
|
for (size_type __j = 1; __j < __i; ++__j)
|
|
_M_deallocate_node(*(this->_M_start._M_node - __j));
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp,_Alloc>::
|
|
_M_new_elements_at_back(size_type __new_elems)
|
|
{
|
|
size_type __new_nodes
|
|
= (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
|
|
_M_reserve_map_at_back(__new_nodes);
|
|
size_type __i;
|
|
try
|
|
{
|
|
for (__i = 1; __i <= __new_nodes; ++__i)
|
|
*(this->_M_finish._M_node + __i) = _M_allocate_node();
|
|
}
|
|
catch(...)
|
|
{
|
|
for (size_type __j = 1; __j < __i; ++__j)
|
|
_M_deallocate_node(*(this->_M_finish._M_node + __j));
|
|
__throw_exception_again;
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp,_Alloc>::
|
|
_M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
|
|
{
|
|
size_type __old_num_nodes
|
|
= this->_M_finish._M_node - this->_M_start._M_node + 1;
|
|
size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
|
|
|
|
_Map_pointer __new_nstart;
|
|
if (this->_M_map_size > 2 * __new_num_nodes)
|
|
{
|
|
__new_nstart
|
|
= this->_M_map + (this->_M_map_size - __new_num_nodes) / 2
|
|
+ (__add_at_front ? __nodes_to_add : 0);
|
|
if (__new_nstart < this->_M_start._M_node)
|
|
copy(this->_M_start._M_node,
|
|
this->_M_finish._M_node + 1,
|
|
__new_nstart);
|
|
else
|
|
copy_backward(this->_M_start._M_node,
|
|
this->_M_finish._M_node + 1,
|
|
__new_nstart + __old_num_nodes);
|
|
}
|
|
else
|
|
{
|
|
size_type __new_map_size =
|
|
this->_M_map_size + std::max(this->_M_map_size, __nodes_to_add) + 2;
|
|
|
|
_Map_pointer __new_map = _M_allocate_map(__new_map_size);
|
|
__new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
|
|
+ (__add_at_front ? __nodes_to_add : 0);
|
|
copy(this->_M_start._M_node,
|
|
this->_M_finish._M_node + 1,
|
|
__new_nstart);
|
|
_M_deallocate_map(this->_M_map, this->_M_map_size);
|
|
|
|
this->_M_map = __new_map;
|
|
this->_M_map_size = __new_map_size;
|
|
}
|
|
|
|
this->_M_start._M_set_node(__new_nstart);
|
|
this->_M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
|
|
}
|
|
} // namespace std
|
|
|
|
#endif /* __GLIBCPP_INTERNAL_DEQUE_TCC */
|
|
|