LTP GCOV extension - code coverage report
Current view: directory - usr/include/c++/4.3/bits - stl_deque.h
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 189
Code covered: 78.3 % Executed lines: 148

       1                 : // Deque implementation -*- C++ -*-
       2                 : 
       3                 : // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
       4                 : // Free Software Foundation, Inc.
       5                 : //
       6                 : // This file is part of the GNU ISO C++ Library.  This library is free
       7                 : // software; you can redistribute it and/or modify it under the
       8                 : // terms of the GNU General Public License as published by the
       9                 : // Free Software Foundation; either version 2, or (at your option)
      10                 : // any later version.
      11                 : 
      12                 : // This library is distributed in the hope that it will be useful,
      13                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 : // GNU General Public License for more details.
      16                 : 
      17                 : // You should have received a copy of the GNU General Public License along
      18                 : // with this library; see the file COPYING.  If not, write to the Free
      19                 : // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
      20                 : // USA.
      21                 : 
      22                 : // As a special exception, you may use this file as part of a free software
      23                 : // library without restriction.  Specifically, if other files instantiate
      24                 : // templates or use macros or inline functions from this file, or you compile
      25                 : // this file and link it with other files to produce an executable, this
      26                 : // file does not by itself cause the resulting executable to be covered by
      27                 : // the GNU General Public License.  This exception does not however
      28                 : // invalidate any other reasons why the executable file might be covered by
      29                 : // the GNU General Public License.
      30                 : 
      31                 : /*
      32                 :  *
      33                 :  * Copyright (c) 1994
      34                 :  * Hewlett-Packard Company
      35                 :  *
      36                 :  * Permission to use, copy, modify, distribute and sell this software
      37                 :  * and its documentation for any purpose is hereby granted without fee,
      38                 :  * provided that the above copyright notice appear in all copies and
      39                 :  * that both that copyright notice and this permission notice appear
      40                 :  * in supporting documentation.  Hewlett-Packard Company makes no
      41                 :  * representations about the suitability of this software for any
      42                 :  * purpose.  It is provided "as is" without express or implied warranty.
      43                 :  *
      44                 :  *
      45                 :  * Copyright (c) 1997
      46                 :  * Silicon Graphics Computer Systems, Inc.
      47                 :  *
      48                 :  * Permission to use, copy, modify, distribute and sell this software
      49                 :  * and its documentation for any purpose is hereby granted without fee,
      50                 :  * provided that the above copyright notice appear in all copies and
      51                 :  * that both that copyright notice and this permission notice appear
      52                 :  * in supporting documentation.  Silicon Graphics makes no
      53                 :  * representations about the suitability of this software for any
      54                 :  * purpose.  It is provided "as is" without express or implied warranty.
      55                 :  */
      56                 : 
      57                 : /** @file stl_deque.h
      58                 :  *  This is an internal header file, included by other library headers.
      59                 :  *  You should not attempt to use it directly.
      60                 :  */
      61                 : 
      62                 : #ifndef _STL_DEQUE_H
      63                 : #define _STL_DEQUE_H 1
      64                 : 
      65                 : #include <bits/concept_check.h>
      66                 : #include <bits/stl_iterator_base_types.h>
      67                 : #include <bits/stl_iterator_base_funcs.h>
      68                 : 
      69                 : _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
      70                 : 
      71                 :   /**
      72                 :    *  @brief This function controls the size of memory nodes.
      73                 :    *  @param  size  The size of an element.
      74                 :    *  @return   The number (not byte size) of elements per node.
      75                 :    *
      76                 :    *  This function started off as a compiler kludge from SGI, but seems to
      77                 :    *  be a useful wrapper around a repeated constant expression.  The '512' is
      78                 :    *  tunable (and no other code needs to change), but no investigation has
      79                 :    *  been done since inheriting the SGI code.
      80                 :   */
      81                 :   inline size_t
      82            7753 :   __deque_buf_size(size_t __size)
      83            7753 :   { return __size < 512 ? size_t(512 / __size) : size_t(1); }
      84                 : 
      85                 : 
      86                 :   /**
      87                 :    *  @brief A deque::iterator.
      88                 :    *
      89                 :    *  Quite a bit of intelligence here.  Much of the functionality of
      90                 :    *  deque is actually passed off to this class.  A deque holds two
      91                 :    *  of these internally, marking its valid range.  Access to
      92                 :    *  elements is done as offsets of either of those two, relying on
      93                 :    *  operator overloading in this class.
      94                 :    *
      95                 :    *  All the functions are op overloads except for _M_set_node.
      96                 :   */
      97                 :   template<typename _Tp, typename _Ref, typename _Ptr>
      98                 :     struct _Deque_iterator
      99                 :     {
     100                 :       typedef _Deque_iterator<_Tp, _Tp&, _Tp*>             iterator;
     101                 :       typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
     102                 : 
     103            7595 :       static size_t _S_buffer_size()
     104            7595 :       { return __deque_buf_size(sizeof(_Tp)); }
     105                 : 
     106                 :       typedef std::random_access_iterator_tag iterator_category;
     107                 :       typedef _Tp                             value_type;
     108                 :       typedef _Ptr                            pointer;
     109                 :       typedef _Ref                            reference;
     110                 :       typedef size_t                          size_type;
     111                 :       typedef ptrdiff_t                       difference_type;
     112                 :       typedef _Tp**                           _Map_pointer;
     113                 :       typedef _Deque_iterator                 _Self;
     114                 : 
     115                 :       _Tp* _M_cur;
     116                 :       _Tp* _M_first;
     117                 :       _Tp* _M_last;
     118                 :       _Map_pointer _M_node;
     119                 : 
     120                 :       _Deque_iterator(_Tp* __x, _Map_pointer __y)
     121                 :       : _M_cur(__x), _M_first(*__y),
     122                 :         _M_last(*__y + _S_buffer_size()), _M_node(__y) { }
     123                 : 
     124              68 :       _Deque_iterator()
     125              68 :       : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { }
     126                 : 
     127           45179 :       _Deque_iterator(const iterator& __x)
     128                 :       : _M_cur(__x._M_cur), _M_first(__x._M_first),
     129           45179 :         _M_last(__x._M_last), _M_node(__x._M_node) { }
     130                 : 
     131                 :       reference
     132           24883 :       operator*() const
     133           24883 :       { return *_M_cur; }
     134                 : 
     135                 :       pointer
     136                 :       operator->() const
     137                 :       { return _M_cur; }
     138                 : 
     139                 :       _Self&
     140           24754 :       operator++()
     141                 :       {
     142           24754 :         ++_M_cur;
     143           24754 :         if (_M_cur == _M_last)
     144                 :           {
     145              29 :             _M_set_node(_M_node + 1);
     146              29 :             _M_cur = _M_first;
     147                 :           }
     148           24754 :         return *this;
     149                 :       }
     150                 : 
     151                 :       _Self
     152                 :       operator++(int)
     153                 :       {
     154                 :         _Self __tmp = *this;
     155                 :         ++*this;
     156                 :         return __tmp;
     157                 :       }
     158                 : 
     159                 :       _Self&
     160              39 :       operator--()
     161                 :       {
     162              39 :         if (_M_cur == _M_first)
     163                 :           {
     164               0 :             _M_set_node(_M_node - 1);
     165               0 :             _M_cur = _M_last;
     166                 :           }
     167              39 :         --_M_cur;
     168              39 :         return *this;
     169                 :       }
     170                 : 
     171                 :       _Self
     172                 :       operator--(int)
     173                 :       {
     174                 :         _Self __tmp = *this;
     175                 :         --*this;
     176                 :         return __tmp;
     177                 :       }
     178                 : 
     179                 :       _Self&
     180             180 :       operator+=(difference_type __n)
     181                 :       {
     182             180 :         const difference_type __offset = __n + (_M_cur - _M_first);
     183             180 :         if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
     184             178 :           _M_cur += __n;
     185                 :         else
     186                 :           {
     187                 :             const difference_type __node_offset =
     188                 :               __offset > 0 ? __offset / difference_type(_S_buffer_size())
     189                 :                            : -difference_type((-__offset - 1)
     190               2 :                                               / _S_buffer_size()) - 1;
     191               2 :             _M_set_node(_M_node + __node_offset);
     192               2 :             _M_cur = _M_first + (__offset - __node_offset
     193                 :                                  * difference_type(_S_buffer_size()));
     194                 :           }
     195             180 :         return *this;
     196                 :       }
     197                 : 
     198                 :       _Self
     199             180 :       operator+(difference_type __n) const
     200                 :       {
     201             180 :         _Self __tmp = *this;
     202             180 :         return __tmp += __n;
     203                 :       }
     204                 : 
     205                 :       _Self&
     206               0 :       operator-=(difference_type __n)
     207               0 :       { return *this += -__n; }
     208                 : 
     209                 :       _Self
     210               0 :       operator-(difference_type __n) const
     211                 :       {
     212               0 :         _Self __tmp = *this;
     213               0 :         return __tmp -= __n;
     214                 :       }
     215                 : 
     216                 :       reference
     217                 :       operator[](difference_type __n) const
     218                 :       { return *(*this + __n); }
     219                 : 
     220                 :       /** 
     221                 :        *  Prepares to traverse new_node.  Sets everything except
     222                 :        *  _M_cur, which should therefore be set by the caller
     223                 :        *  immediately afterwards, based on _M_first and _M_last.
     224                 :        */
     225                 :       void
     226             112 :       _M_set_node(_Map_pointer __new_node)
     227                 :       {
     228             112 :         _M_node = __new_node;
     229             112 :         _M_first = *__new_node;
     230             112 :         _M_last = _M_first + difference_type(_S_buffer_size());
     231             112 :       }
     232                 :     };
     233                 : 
     234                 :   // Note: we also provide overloads whose operands are of the same type in
     235                 :   // order to avoid ambiguous overload resolution when std::rel_ops operators
     236                 :   // are in scope (for additional details, see libstdc++/3628)
     237                 :   template<typename _Tp, typename _Ref, typename _Ptr>
     238                 :     inline bool
     239                 :     operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
     240           19443 :                const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
     241           19443 :     { return __x._M_cur == __y._M_cur; }
     242                 : 
     243                 :   template<typename _Tp, typename _RefL, typename _PtrL,
     244                 :            typename _RefR, typename _PtrR>
     245                 :     inline bool
     246                 :     operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
     247                 :                const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
     248                 :     { return __x._M_cur == __y._M_cur; }
     249                 : 
     250                 :   template<typename _Tp, typename _Ref, typename _Ptr>
     251                 :     inline bool
     252                 :     operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
     253           12091 :                const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
     254           12091 :     { return !(__x == __y); }
     255                 : 
     256                 :   template<typename _Tp, typename _RefL, typename _PtrL,
     257                 :            typename _RefR, typename _PtrR>
     258                 :     inline bool
     259                 :     operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
     260                 :                const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
     261                 :     { return !(__x == __y); }
     262                 : 
     263                 :   template<typename _Tp, typename _Ref, typename _Ptr>
     264                 :     inline bool
     265                 :     operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
     266                 :               const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
     267                 :     { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
     268                 :                                           : (__x._M_node < __y._M_node); }
     269                 : 
     270                 :   template<typename _Tp, typename _RefL, typename _PtrL,
     271                 :            typename _RefR, typename _PtrR>
     272                 :     inline bool
     273                 :     operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
     274                 :               const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
     275                 :     { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
     276                 :                                           : (__x._M_node < __y._M_node); }
     277                 : 
     278                 :   template<typename _Tp, typename _Ref, typename _Ptr>
     279                 :     inline bool
     280                 :     operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
     281                 :               const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
     282                 :     { return __y < __x; }
     283                 : 
     284                 :   template<typename _Tp, typename _RefL, typename _PtrL,
     285                 :            typename _RefR, typename _PtrR>
     286                 :     inline bool
     287                 :     operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
     288                 :               const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
     289                 :     { return __y < __x; }
     290                 : 
     291                 :   template<typename _Tp, typename _Ref, typename _Ptr>
     292                 :     inline bool
     293                 :     operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
     294                 :                const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
     295                 :     { return !(__y < __x); }
     296                 : 
     297                 :   template<typename _Tp, typename _RefL, typename _PtrL,
     298                 :            typename _RefR, typename _PtrR>
     299                 :     inline bool
     300                 :     operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
     301                 :                const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
     302                 :     { return !(__y < __x); }
     303                 : 
     304                 :   template<typename _Tp, typename _Ref, typename _Ptr>
     305                 :     inline bool
     306                 :     operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
     307                 :                const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
     308                 :     { return !(__x < __y); }
     309                 : 
     310                 :   template<typename _Tp, typename _RefL, typename _PtrL,
     311                 :            typename _RefR, typename _PtrR>
     312                 :     inline bool
     313                 :     operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
     314                 :                const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
     315                 :     { return !(__x < __y); }
     316                 : 
     317                 :   // _GLIBCXX_RESOLVE_LIB_DEFECTS
     318                 :   // According to the resolution of DR179 not only the various comparison
     319                 :   // operators but also operator- must accept mixed iterator/const_iterator
     320                 :   // parameters.
     321                 :   template<typename _Tp, typename _Ref, typename _Ptr>
     322                 :     inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
     323                 :     operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
     324            7299 :               const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
     325                 :     {
     326                 :       return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
     327                 :         (_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
     328                 :         * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
     329            7299 :         + (__y._M_last - __y._M_cur);
     330                 :     }
     331                 : 
     332                 :   template<typename _Tp, typename _RefL, typename _PtrL,
     333                 :            typename _RefR, typename _PtrR>
     334                 :     inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
     335                 :     operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
     336                 :               const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
     337                 :     {
     338                 :       return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
     339                 :         (_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
     340                 :         * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
     341                 :         + (__y._M_last - __y._M_cur);
     342                 :     }
     343                 : 
     344                 :   template<typename _Tp, typename _Ref, typename _Ptr>
     345                 :     inline _Deque_iterator<_Tp, _Ref, _Ptr>
     346                 :     operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
     347                 :     { return __x + __n; }
     348                 : 
     349                 :   template<typename _Tp>
     350                 :     void
     351                 :     fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
     352                 :          const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value);
     353                 : 
     354                 :   /**
     355                 :    *  Deque base class.  This class provides the unified face for %deque's
     356                 :    *  allocation.  This class's constructor and destructor allocate and
     357                 :    *  deallocate (but do not initialize) storage.  This makes %exception
     358                 :    *  safety easier.
     359                 :    *
     360                 :    *  Nothing in this class ever constructs or destroys an actual Tp element.
     361                 :    *  (Deque handles that itself.)  Only/All memory management is performed
     362                 :    *  here.
     363                 :   */
     364                 :   template<typename _Tp, typename _Alloc>
     365                 :     class _Deque_base
     366                 :     {
     367                 :     public:
     368                 :       typedef _Alloc                  allocator_type;
     369                 : 
     370                 :       allocator_type
     371                 :       get_allocator() const
     372                 :       { return allocator_type(_M_get_Tp_allocator()); }
     373                 : 
     374                 :       typedef _Deque_iterator<_Tp, _Tp&, _Tp*>             iterator;
     375                 :       typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
     376                 : 
     377              21 :       _Deque_base()
     378              21 :       : _M_impl()
     379              21 :       { _M_initialize_map(0); }
     380                 : 
     381              13 :       _Deque_base(const allocator_type& __a, size_t __num_elements)
     382              13 :       : _M_impl(__a)
     383              13 :       { _M_initialize_map(__num_elements); }
     384                 : 
     385                 :       _Deque_base(const allocator_type& __a)
     386                 :       : _M_impl(__a)
     387                 :       { }
     388                 : 
     389                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     390                 :       _Deque_base(_Deque_base&& __x)
     391                 :       : _M_impl(__x._M_get_Tp_allocator())
     392                 :       {
     393                 :         _M_initialize_map(0);
     394                 :         if (__x._M_impl._M_map)
     395                 :           {
     396                 :             std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
     397                 :             std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
     398                 :             std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
     399                 :             std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
     400                 :           }
     401                 :       }
     402                 : #endif
     403                 : 
     404                 :       ~_Deque_base();
     405                 : 
     406                 :     protected:
     407                 :       //This struct encapsulates the implementation of the std::deque
     408                 :       //standard container and at the same time makes use of the EBO
     409                 :       //for empty allocators.
     410                 :       typedef typename _Alloc::template rebind<_Tp*>::other _Map_alloc_type;
     411                 : 
     412                 :       typedef typename _Alloc::template rebind<_Tp>::other  _Tp_alloc_type;
     413                 : 
     414                 :       struct _Deque_impl
     415                 :       : public _Tp_alloc_type
     416              30 :       {
     417                 :         _Tp** _M_map;
     418                 :         size_t _M_map_size;
     419                 :         iterator _M_start;
     420                 :         iterator _M_finish;
     421                 : 
     422              21 :         _Deque_impl()
     423                 :         : _Tp_alloc_type(), _M_map(0), _M_map_size(0),
     424              21 :           _M_start(), _M_finish()
     425              21 :         { }
     426                 : 
     427              13 :         _Deque_impl(const _Tp_alloc_type& __a)
     428                 :         : _Tp_alloc_type(__a), _M_map(0), _M_map_size(0),
     429              13 :           _M_start(), _M_finish()
     430              13 :         { }
     431                 :       };
     432                 : 
     433                 :       _Tp_alloc_type&
     434            1085 :       _M_get_Tp_allocator()
     435            1085 :       { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
     436                 : 
     437                 :       const _Tp_alloc_type&
     438              77 :       _M_get_Tp_allocator() const
     439              77 :       { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
     440                 : 
     441                 :       _Map_alloc_type
     442              64 :       _M_get_map_allocator() const
     443              64 :       { return _Map_alloc_type(_M_get_Tp_allocator()); }
     444                 : 
     445                 :       _Tp*
     446              47 :       _M_allocate_node()
     447                 :       { 
     448              47 :         return _M_impl._Tp_alloc_type::allocate(__deque_buf_size(sizeof(_Tp)));
     449                 :       }
     450                 : 
     451                 :       void
     452              43 :       _M_deallocate_node(_Tp* __p)
     453                 :       {
     454              43 :         _M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
     455              43 :       }
     456                 : 
     457                 :       _Tp**
     458              34 :       _M_allocate_map(size_t __n)
     459              34 :       { return _M_get_map_allocator().allocate(__n); }
     460                 : 
     461                 :       void
     462              30 :       _M_deallocate_map(_Tp** __p, size_t __n)
     463              30 :       { _M_get_map_allocator().deallocate(__p, __n); }
     464                 : 
     465                 :     protected:
     466                 :       void _M_initialize_map(size_t);
     467                 :       void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
     468                 :       void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
     469                 :       enum { _S_initial_map_size = 8 };
     470                 : 
     471                 :       _Deque_impl _M_impl;
     472                 :     };
     473                 : 
     474                 :   template<typename _Tp, typename _Alloc>
     475                 :     _Deque_base<_Tp, _Alloc>::
     476              30 :     ~_Deque_base()
     477                 :     {
     478              30 :       if (this->_M_impl._M_map)
     479                 :         {
     480              30 :           _M_destroy_nodes(this->_M_impl._M_start._M_node,
     481                 :                            this->_M_impl._M_finish._M_node + 1);
     482              30 :           _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
     483                 :         }
     484              30 :     }
     485                 : 
     486                 :   /**
     487                 :    *  @brief Layout storage.
     488                 :    *  @param  num_elements  The count of T's for which to allocate space
     489                 :    *                        at first.
     490                 :    *  @return   Nothing.
     491                 :    *
     492                 :    *  The initial underlying memory layout is a bit complicated...
     493                 :   */
     494                 :   template<typename _Tp, typename _Alloc>
     495                 :     void
     496                 :     _Deque_base<_Tp, _Alloc>::
     497              34 :     _M_initialize_map(size_t __num_elements)
     498                 :     {
     499                 :       const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
     500              34 :                                   + 1);
     501                 : 
     502              34 :       this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
     503                 :                                            size_t(__num_nodes + 2));
     504              34 :       this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
     505                 : 
     506                 :       // For "small" maps (needing less than _M_map_size nodes), allocation
     507                 :       // starts in the middle elements and grows outwards.  So nstart may be
     508                 :       // the beginning of _M_map, but for small maps it may be as far in as
     509                 :       // _M_map+3.
     510                 : 
     511                 :       _Tp** __nstart = (this->_M_impl._M_map
     512              34 :                         + (this->_M_impl._M_map_size - __num_nodes) / 2);
     513              34 :       _Tp** __nfinish = __nstart + __num_nodes;
     514                 : 
     515                 :       try
     516              34 :         { _M_create_nodes(__nstart, __nfinish); }
     517               0 :       catch(...)
     518                 :         {
     519               0 :           _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
     520               0 :           this->_M_impl._M_map = 0;
     521               0 :           this->_M_impl._M_map_size = 0;
     522               0 :           __throw_exception_again;
     523                 :         }
     524                 : 
     525              34 :       this->_M_impl._M_start._M_set_node(__nstart);
     526              34 :       this->_M_impl._M_finish._M_set_node(__nfinish - 1);
     527              34 :       this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
     528              34 :       this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
     529                 :                                         + __num_elements
     530                 :                                         % __deque_buf_size(sizeof(_Tp)));
     531              34 :     }
     532                 : 
     533                 :   template<typename _Tp, typename _Alloc>
     534                 :     void
     535                 :     _Deque_base<_Tp, _Alloc>::
     536              34 :     _M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
     537                 :     {
     538                 :       _Tp** __cur;
     539                 :       try
     540                 :         {
     541              68 :           for (__cur = __nstart; __cur < __nfinish; ++__cur)
     542              34 :             *__cur = this->_M_allocate_node();
     543                 :         }
     544               0 :       catch(...)
     545                 :         {
     546               0 :           _M_destroy_nodes(__nstart, __cur);
     547               0 :           __throw_exception_again;
     548                 :         }
     549              34 :     }
     550                 : 
     551                 :   template<typename _Tp, typename _Alloc>
     552                 :     void
     553                 :     _Deque_base<_Tp, _Alloc>::
     554            1046 :     _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
     555                 :     {
     556            1089 :       for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
     557              43 :         _M_deallocate_node(*__n);
     558            1046 :     }
     559                 : 
     560                 :   /**
     561                 :    *  @brief  A standard container using fixed-size memory allocation and
     562                 :    *  constant-time manipulation of elements at either end.
     563                 :    *
     564                 :    *  @ingroup Containers
     565                 :    *  @ingroup Sequences
     566                 :    *
     567                 :    *  Meets the requirements of a <a href="tables.html#65">container</a>, a
     568                 :    *  <a href="tables.html#66">reversible container</a>, and a
     569                 :    *  <a href="tables.html#67">sequence</a>, including the
     570                 :    *  <a href="tables.html#68">optional sequence requirements</a>.
     571                 :    *
     572                 :    *  In previous HP/SGI versions of deque, there was an extra template
     573                 :    *  parameter so users could control the node size.  This extension turned
     574                 :    *  out to violate the C++ standard (it can be detected using template
     575                 :    *  template parameters), and it was removed.
     576                 :    *
     577                 :    *  Here's how a deque<Tp> manages memory.  Each deque has 4 members:
     578                 :    *
     579                 :    *  - Tp**        _M_map
     580                 :    *  - size_t      _M_map_size
     581                 :    *  - iterator    _M_start, _M_finish
     582                 :    *
     583                 :    *  map_size is at least 8.  %map is an array of map_size
     584                 :    *  pointers-to-"nodes".  (The name %map has nothing to do with the
     585                 :    *  std::map class, and "nodes" should not be confused with
     586                 :    *  std::list's usage of "node".)
     587                 :    *
     588                 :    *  A "node" has no specific type name as such, but it is referred
     589                 :    *  to as "node" in this file.  It is a simple array-of-Tp.  If Tp
     590                 :    *  is very large, there will be one Tp element per node (i.e., an
     591                 :    *  "array" of one).  For non-huge Tp's, node size is inversely
     592                 :    *  related to Tp size: the larger the Tp, the fewer Tp's will fit
     593                 :    *  in a node.  The goal here is to keep the total size of a node
     594                 :    *  relatively small and constant over different Tp's, to improve
     595                 :    *  allocator efficiency.
     596                 :    *
     597                 :    *  Not every pointer in the %map array will point to a node.  If
     598                 :    *  the initial number of elements in the deque is small, the
     599                 :    *  /middle/ %map pointers will be valid, and the ones at the edges
     600                 :    *  will be unused.  This same situation will arise as the %map
     601                 :    *  grows: available %map pointers, if any, will be on the ends.  As
     602                 :    *  new nodes are created, only a subset of the %map's pointers need
     603                 :    *  to be copied "outward".
     604                 :    *
     605                 :    *  Class invariants:
     606                 :    * - For any nonsingular iterator i:
     607                 :    *    - i.node points to a member of the %map array.  (Yes, you read that
     608                 :    *      correctly:  i.node does not actually point to a node.)  The member of
     609                 :    *      the %map array is what actually points to the node.
     610                 :    *    - i.first == *(i.node)    (This points to the node (first Tp element).)
     611                 :    *    - i.last  == i.first + node_size
     612                 :    *    - i.cur is a pointer in the range [i.first, i.last).  NOTE:
     613                 :    *      the implication of this is that i.cur is always a dereferenceable
     614                 :    *      pointer, even if i is a past-the-end iterator.
     615                 :    * - Start and Finish are always nonsingular iterators.  NOTE: this
     616                 :    * means that an empty deque must have one node, a deque with <N
     617                 :    * elements (where N is the node buffer size) must have one node, a
     618                 :    * deque with N through (2N-1) elements must have two nodes, etc.
     619                 :    * - For every node other than start.node and finish.node, every
     620                 :    * element in the node is an initialized object.  If start.node ==
     621                 :    * finish.node, then [start.cur, finish.cur) are initialized
     622                 :    * objects, and the elements outside that range are uninitialized
     623                 :    * storage.  Otherwise, [start.cur, start.last) and [finish.first,
     624                 :    * finish.cur) are initialized objects, and [start.first, start.cur)
     625                 :    * and [finish.cur, finish.last) are uninitialized storage.
     626                 :    * - [%map, %map + map_size) is a valid, non-empty range.
     627                 :    * - [start.node, finish.node] is a valid range contained within
     628                 :    *   [%map, %map + map_size).
     629                 :    * - A pointer in the range [%map, %map + map_size) points to an allocated
     630                 :    *   node if and only if the pointer is in the range
     631                 :    *   [start.node, finish.node].
     632                 :    *
     633                 :    *  Here's the magic:  nothing in deque is "aware" of the discontiguous
     634                 :    *  storage!
     635                 :    *
     636                 :    *  The memory setup and layout occurs in the parent, _Base, and the iterator
     637                 :    *  class is entirely responsible for "leaping" from one node to the next.
     638                 :    *  All the implementation routines for deque itself work only through the
     639                 :    *  start and finish iterators.  This keeps the routines simple and sane,
     640                 :    *  and we can use other standard algorithms as well.
     641                 :   */
     642                 :   template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
     643                 :     class deque : protected _Deque_base<_Tp, _Alloc>
     644                 :     {
     645                 :       // concept requirements
     646                 :       typedef typename _Alloc::value_type        _Alloc_value_type;
     647                 :       __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
     648                 :       __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
     649                 : 
     650                 :       typedef _Deque_base<_Tp, _Alloc>           _Base;
     651                 :       typedef typename _Base::_Tp_alloc_type     _Tp_alloc_type;
     652                 : 
     653                 :     public:
     654                 :       typedef _Tp                                        value_type;
     655                 :       typedef typename _Tp_alloc_type::pointer           pointer;
     656                 :       typedef typename _Tp_alloc_type::const_pointer     const_pointer;
     657                 :       typedef typename _Tp_alloc_type::reference         reference;
     658                 :       typedef typename _Tp_alloc_type::const_reference   const_reference;
     659                 :       typedef typename _Base::iterator                   iterator;
     660                 :       typedef typename _Base::const_iterator             const_iterator;
     661                 :       typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;
     662                 :       typedef std::reverse_iterator<iterator>            reverse_iterator;
     663                 :       typedef size_t                             size_type;
     664                 :       typedef ptrdiff_t                          difference_type;
     665                 :       typedef _Alloc                             allocator_type;
     666                 : 
     667                 :     protected:
     668                 :       typedef pointer*                           _Map_pointer;
     669                 : 
     670               0 :       static size_t _S_buffer_size()
     671               0 :       { return __deque_buf_size(sizeof(_Tp)); }
     672                 : 
     673                 :       // Functions controlling memory layout, and nothing else.
     674                 :       using _Base::_M_initialize_map;
     675                 :       using _Base::_M_create_nodes;
     676                 :       using _Base::_M_destroy_nodes;
     677                 :       using _Base::_M_allocate_node;
     678                 :       using _Base::_M_deallocate_node;
     679                 :       using _Base::_M_allocate_map;
     680                 :       using _Base::_M_deallocate_map;
     681                 :       using _Base::_M_get_Tp_allocator;
     682                 : 
     683                 :       /** 
     684                 :        *  A total of four data members accumulated down the hierarchy.
     685                 :        *  May be accessed via _M_impl.*
     686                 :        */
     687                 :       using _Base::_M_impl;
     688                 : 
     689                 :     public:
     690                 :       // [23.2.1.1] construct/copy/destroy
     691                 :       // (assign() and get_allocator() are also listed in this section)
     692                 :       /**
     693                 :        *  @brief  Default constructor creates no elements.
     694                 :        */
     695              21 :       deque()
     696              21 :       : _Base() { }
     697                 : 
     698                 :       /**
     699                 :        *  @brief  Creates a %deque with no elements.
     700                 :        *  @param  a  An allocator object.
     701                 :        */
     702                 :       explicit
     703                 :       deque(const allocator_type& __a)
     704                 :       : _Base(__a, 0) { }
     705                 : 
     706                 :       /**
     707                 :        *  @brief  Creates a %deque with copies of an exemplar element.
     708                 :        *  @param  n  The number of elements to initially create.
     709                 :        *  @param  value  An element to copy.
     710                 :        *  @param  a  An allocator.
     711                 :        *
     712                 :        *  This constructor fills the %deque with @a n copies of @a value.
     713                 :        */
     714                 :       explicit
     715                 :       deque(size_type __n, const value_type& __value = value_type(),
     716                 :             const allocator_type& __a = allocator_type())
     717                 :       : _Base(__a, __n)
     718                 :       { _M_fill_initialize(__value); }
     719                 : 
     720                 :       /**
     721                 :        *  @brief  %Deque copy constructor.
     722                 :        *  @param  x  A %deque of identical element and allocator types.
     723                 :        *
     724                 :        *  The newly-created %deque uses a copy of the allocation object used
     725                 :        *  by @a x.
     726                 :        */
     727              13 :       deque(const deque& __x)
     728              13 :       : _Base(__x._M_get_Tp_allocator(), __x.size())
     729              13 :       { std::__uninitialized_copy_a(__x.begin(), __x.end(), 
     730                 :                                     this->_M_impl._M_start,
     731              13 :                                     _M_get_Tp_allocator()); }
     732                 : 
     733                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     734                 :       /**
     735                 :        *  @brief  %Deque move constructor.
     736                 :        *  @param  x  A %deque of identical element and allocator types.
     737                 :        *
     738                 :        *  The newly-created %deque contains the exact contents of @a x.
     739                 :        *  The contents of @a x are a valid, but unspecified %deque.
     740                 :        */
     741                 :       deque(deque&&  __x)
     742                 :       : _Base(std::forward<_Base>(__x)) { }
     743                 : #endif
     744                 : 
     745                 :       /**
     746                 :        *  @brief  Builds a %deque from a range.
     747                 :        *  @param  first  An input iterator.
     748                 :        *  @param  last  An input iterator.
     749                 :        *  @param  a  An allocator object.
     750                 :        *
     751                 :        *  Create a %deque consisting of copies of the elements from [first,
     752                 :        *  last).
     753                 :        *
     754                 :        *  If the iterators are forward, bidirectional, or random-access, then
     755                 :        *  this will call the elements' copy constructor N times (where N is
     756                 :        *  distance(first,last)) and do no memory reallocation.  But if only
     757                 :        *  input iterators are used, then this will do at most 2N calls to the
     758                 :        *  copy constructor, and logN memory reallocations.
     759                 :        */
     760                 :       template<typename _InputIterator>
     761                 :         deque(_InputIterator __first, _InputIterator __last,
     762                 :               const allocator_type& __a = allocator_type())
     763                 :         : _Base(__a)
     764                 :         {
     765                 :           // Check whether it's an integral type.  If so, it's not an iterator.
     766                 :           typedef typename std::__is_integer<_InputIterator>::__type _Integral;
     767                 :           _M_initialize_dispatch(__first, __last, _Integral());
     768                 :         }
     769                 : 
     770                 :       /**
     771                 :        *  The dtor only erases the elements, and note that if the elements
     772                 :        *  themselves are pointers, the pointed-to memory is not touched in any
     773                 :        *  way.  Managing the pointer is the user's responsibility.
     774                 :        */
     775              30 :       ~deque()
     776              30 :       { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
     777                 : 
     778                 :       /**
     779                 :        *  @brief  %Deque assignment operator.
     780                 :        *  @param  x  A %deque of identical element and allocator types.
     781                 :        *
     782                 :        *  All the elements of @a x are copied, but unlike the copy constructor,
     783                 :        *  the allocator object is not copied.
     784                 :        */
     785                 :       deque&
     786                 :       operator=(const deque& __x);
     787                 : 
     788                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     789                 :       /**
     790                 :        *  @brief  %Deque move assignment operator.
     791                 :        *  @param  x  A %deque of identical element and allocator types.
     792                 :        *
     793                 :        *  The contents of @a x are moved into this deque (without copying).
     794                 :        *  @a x is a valid, but unspecified %deque.
     795                 :        */
     796                 :       deque&
     797                 :       operator=(deque&& __x)
     798                 :       {
     799                 :         // NB: DR 675.
     800                 :         this->clear();
     801                 :         this->swap(__x); 
     802                 :         return *this;
     803                 :       }
     804                 : #endif
     805                 : 
     806                 :       /**
     807                 :        *  @brief  Assigns a given value to a %deque.
     808                 :        *  @param  n  Number of elements to be assigned.
     809                 :        *  @param  val  Value to be assigned.
     810                 :        *
     811                 :        *  This function fills a %deque with @a n copies of the given
     812                 :        *  value.  Note that the assignment completely changes the
     813                 :        *  %deque and that the resulting %deque's size is the same as
     814                 :        *  the number of elements assigned.  Old data may be lost.
     815                 :        */
     816                 :       void
     817                 :       assign(size_type __n, const value_type& __val)
     818                 :       { _M_fill_assign(__n, __val); }
     819                 : 
     820                 :       /**
     821                 :        *  @brief  Assigns a range to a %deque.
     822                 :        *  @param  first  An input iterator.
     823                 :        *  @param  last   An input iterator.
     824                 :        *
     825                 :        *  This function fills a %deque with copies of the elements in the
     826                 :        *  range [first,last).
     827                 :        *
     828                 :        *  Note that the assignment completely changes the %deque and that the
     829                 :        *  resulting %deque's size is the same as the number of elements
     830                 :        *  assigned.  Old data may be lost.
     831                 :        */
     832                 :       template<typename _InputIterator>
     833                 :         void
     834                 :         assign(_InputIterator __first, _InputIterator __last)
     835                 :         {
     836                 :           typedef typename std::__is_integer<_InputIterator>::__type _Integral;
     837                 :           _M_assign_dispatch(__first, __last, _Integral());
     838                 :         }
     839                 : 
     840                 :       /// Get a copy of the memory allocation object.
     841                 :       allocator_type
     842                 :       get_allocator() const
     843                 :       { return _Base::get_allocator(); }
     844                 : 
     845                 :       // iterators
     846                 :       /**
     847                 :        *  Returns a read/write iterator that points to the first element in the
     848                 :        *  %deque.  Iteration is done in ordinary element order.
     849                 :        */
     850                 :       iterator
     851            7800 :       begin()
     852            7800 :       { return this->_M_impl._M_start; }
     853                 : 
     854                 :       /**
     855                 :        *  Returns a read-only (constant) iterator that points to the first
     856                 :        *  element in the %deque.  Iteration is done in ordinary element order.
     857                 :        */
     858                 :       const_iterator
     859              17 :       begin() const
     860              17 :       { return this->_M_impl._M_start; }
     861                 : 
     862                 :       /**
     863                 :        *  Returns a read/write iterator that points one past the last
     864                 :        *  element in the %deque.  Iteration is done in ordinary
     865                 :        *  element order.
     866                 :        */
     867                 :       iterator
     868           10575 :       end()
     869           10575 :       { return this->_M_impl._M_finish; }
     870                 : 
     871                 :       /**
     872                 :        *  Returns a read-only (constant) iterator that points one past
     873                 :        *  the last element in the %deque.  Iteration is done in
     874                 :        *  ordinary element order.
     875                 :        */
     876                 :       const_iterator
     877              17 :       end() const
     878              17 :       { return this->_M_impl._M_finish; }
     879                 : 
     880                 :       /**
     881                 :        *  Returns a read/write reverse iterator that points to the
     882                 :        *  last element in the %deque.  Iteration is done in reverse
     883                 :        *  element order.
     884                 :        */
     885                 :       reverse_iterator
     886                 :       rbegin()
     887                 :       { return reverse_iterator(this->_M_impl._M_finish); }
     888                 : 
     889                 :       /**
     890                 :        *  Returns a read-only (constant) reverse iterator that points
     891                 :        *  to the last element in the %deque.  Iteration is done in
     892                 :        *  reverse element order.
     893                 :        */
     894                 :       const_reverse_iterator
     895                 :       rbegin() const
     896                 :       { return const_reverse_iterator(this->_M_impl._M_finish); }
     897                 : 
     898                 :       /**
     899                 :        *  Returns a read/write reverse iterator that points to one
     900                 :        *  before the first element in the %deque.  Iteration is done
     901                 :        *  in reverse element order.
     902                 :        */
     903                 :       reverse_iterator
     904                 :       rend()
     905                 :       { return reverse_iterator(this->_M_impl._M_start); }
     906                 : 
     907                 :       /**
     908                 :        *  Returns a read-only (constant) reverse iterator that points
     909                 :        *  to one before the first element in the %deque.  Iteration is
     910                 :        *  done in reverse element order.
     911                 :        */
     912                 :       const_reverse_iterator
     913                 :       rend() const
     914                 :       { return const_reverse_iterator(this->_M_impl._M_start); }
     915                 : 
     916                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     917                 :       /**
     918                 :        *  Returns a read-only (constant) iterator that points to the first
     919                 :        *  element in the %deque.  Iteration is done in ordinary element order.
     920                 :        */
     921                 :       const_iterator
     922                 :       cbegin() const
     923                 :       { return this->_M_impl._M_start; }
     924                 : 
     925                 :       /**
     926                 :        *  Returns a read-only (constant) iterator that points one past
     927                 :        *  the last element in the %deque.  Iteration is done in
     928                 :        *  ordinary element order.
     929                 :        */
     930                 :       const_iterator
     931                 :       cend() const
     932                 :       { return this->_M_impl._M_finish; }
     933                 : 
     934                 :       /**
     935                 :        *  Returns a read-only (constant) reverse iterator that points
     936                 :        *  to the last element in the %deque.  Iteration is done in
     937                 :        *  reverse element order.
     938                 :        */
     939                 :       const_reverse_iterator
     940                 :       crbegin() const
     941                 :       { return const_reverse_iterator(this->_M_impl._M_finish); }
     942                 : 
     943                 :       /**
     944                 :        *  Returns a read-only (constant) reverse iterator that points
     945                 :        *  to one before the first element in the %deque.  Iteration is
     946                 :        *  done in reverse element order.
     947                 :        */
     948                 :       const_reverse_iterator
     949                 :       crend() const
     950                 :       { return const_reverse_iterator(this->_M_impl._M_start); }
     951                 : #endif
     952                 : 
     953                 :       // [23.2.1.2] capacity
     954                 :       /**  Returns the number of elements in the %deque.  */
     955                 :       size_type
     956             111 :       size() const
     957             111 :       { return this->_M_impl._M_finish - this->_M_impl._M_start; }
     958                 : 
     959                 :       /**  Returns the size() of the largest possible %deque.  */
     960                 :       size_type
     961               0 :       max_size() const
     962               0 :       { return _M_get_Tp_allocator().max_size(); }
     963                 : 
     964                 :       /**
     965                 :        *  @brief  Resizes the %deque to the specified number of elements.
     966                 :        *  @param  new_size  Number of elements the %deque should contain.
     967                 :        *  @param  x  Data with which new elements should be populated.
     968                 :        *
     969                 :        *  This function will %resize the %deque to the specified
     970                 :        *  number of elements.  If the number is smaller than the
     971                 :        *  %deque's current size the %deque is truncated, otherwise the
     972                 :        *  %deque is extended and new elements are populated with given
     973                 :        *  data.
     974                 :        */
     975                 :       void
     976                 :       resize(size_type __new_size, value_type __x = value_type())
     977                 :       {
     978                 :         const size_type __len = size();
     979                 :         if (__new_size < __len)
     980                 :           _M_erase_at_end(this->_M_impl._M_start + difference_type(__new_size));
     981                 :         else
     982                 :           insert(this->_M_impl._M_finish, __new_size - __len, __x);
     983                 :       }
     984                 : 
     985                 :       /**
     986                 :        *  Returns true if the %deque is empty.  (Thus begin() would
     987                 :        *  equal end().)
     988                 :        */
     989                 :       bool
     990              32 :       empty() const
     991              32 :       { return this->_M_impl._M_finish == this->_M_impl._M_start; }
     992                 : 
     993                 :       // element access
     994                 :       /**
     995                 :        *  @brief Subscript access to the data contained in the %deque.
     996                 :        *  @param n The index of the element for which data should be
     997                 :        *  accessed.
     998                 :        *  @return  Read/write reference to data.
     999                 :        *
    1000                 :        *  This operator allows for easy, array-style, data access.
    1001                 :        *  Note that data access with this operator is unchecked and
    1002                 :        *  out_of_range lookups are not defined. (For checked lookups
    1003                 :        *  see at().)
    1004                 :        */
    1005                 :       reference
    1006                 :       operator[](size_type __n)
    1007                 :       { return this->_M_impl._M_start[difference_type(__n)]; }
    1008                 : 
    1009                 :       /**
    1010                 :        *  @brief Subscript access to the data contained in the %deque.
    1011                 :        *  @param n The index of the element for which data should be
    1012                 :        *  accessed.
    1013                 :        *  @return  Read-only (constant) reference to data.
    1014                 :        *
    1015                 :        *  This operator allows for easy, array-style, data access.
    1016                 :        *  Note that data access with this operator is unchecked and
    1017                 :        *  out_of_range lookups are not defined. (For checked lookups
    1018                 :        *  see at().)
    1019                 :        */
    1020                 :       const_reference
    1021                 :       operator[](size_type __n) const
    1022                 :       { return this->_M_impl._M_start[difference_type(__n)]; }
    1023                 : 
    1024                 :     protected:
    1025                 :       /// Safety check used only from at().
    1026                 :       void
    1027                 :       _M_range_check(size_type __n) const
    1028                 :       {
    1029                 :         if (__n >= this->size())
    1030                 :           __throw_out_of_range(__N("deque::_M_range_check"));
    1031                 :       }
    1032                 : 
    1033                 :     public:
    1034                 :       /**
    1035                 :        *  @brief  Provides access to the data contained in the %deque.
    1036                 :        *  @param n The index of the element for which data should be
    1037                 :        *  accessed.
    1038                 :        *  @return  Read/write reference to data.
    1039                 :        *  @throw  std::out_of_range  If @a n is an invalid index.
    1040                 :        *
    1041                 :        *  This function provides for safer data access.  The parameter
    1042                 :        *  is first checked that it is in the range of the deque.  The
    1043                 :        *  function throws out_of_range if the check fails.
    1044                 :        */
    1045                 :       reference
    1046                 :       at(size_type __n)
    1047                 :       {
    1048                 :         _M_range_check(__n);
    1049                 :         return (*this)[__n];
    1050                 :       }
    1051                 : 
    1052                 :       /**
    1053                 :        *  @brief  Provides access to the data contained in the %deque.
    1054                 :        *  @param n The index of the element for which data should be
    1055                 :        *  accessed.
    1056                 :        *  @return  Read-only (constant) reference to data.
    1057                 :        *  @throw  std::out_of_range  If @a n is an invalid index.
    1058                 :        *
    1059                 :        *  This function provides for safer data access.  The parameter is first
    1060                 :        *  checked that it is in the range of the deque.  The function throws
    1061                 :        *  out_of_range if the check fails.
    1062                 :        */
    1063                 :       const_reference
    1064                 :       at(size_type __n) const
    1065                 :       {
    1066                 :         _M_range_check(__n);
    1067                 :         return (*this)[__n];
    1068                 :       }
    1069                 : 
    1070                 :       /**
    1071                 :        *  Returns a read/write reference to the data at the first
    1072                 :        *  element of the %deque.
    1073                 :        */
    1074                 :       reference
    1075                 :       front()
    1076                 :       { return *begin(); }
    1077                 : 
    1078                 :       /**
    1079                 :        *  Returns a read-only (constant) reference to the data at the first
    1080                 :        *  element of the %deque.
    1081                 :        */
    1082                 :       const_reference
    1083                 :       front() const
    1084                 :       { return *begin(); }
    1085                 : 
    1086                 :       /**
    1087                 :        *  Returns a read/write reference to the data at the last element of the
    1088                 :        *  %deque.
    1089                 :        */
    1090                 :       reference
    1091              39 :       back()
    1092                 :       {
    1093              39 :         iterator __tmp = end();
    1094              39 :         --__tmp;
    1095              39 :         return *__tmp;
    1096                 :       }
    1097                 : 
    1098                 :       /**
    1099                 :        *  Returns a read-only (constant) reference to the data at the last
    1100                 :        *  element of the %deque.
    1101                 :        */
    1102                 :       const_reference
    1103                 :       back() const
    1104                 :       {
    1105                 :         const_iterator __tmp = end();
    1106                 :         --__tmp;
    1107                 :         return *__tmp;
    1108                 :       }
    1109                 : 
    1110                 :       // [23.2.1.2] modifiers
    1111                 :       /**
    1112                 :        *  @brief  Add data to the front of the %deque.
    1113                 :        *  @param  x  Data to be added.
    1114                 :        *
    1115                 :        *  This is a typical stack operation.  The function creates an
    1116                 :        *  element at the front of the %deque and assigns the given
    1117                 :        *  data to it.  Due to the nature of a %deque this operation
    1118                 :        *  can be done in constant time.
    1119                 :        */
    1120                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
    1121                 :       void
    1122                 :       push_front(const value_type& __x)
    1123                 :       {
    1124                 :         if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
    1125                 :           {
    1126                 :             this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, __x);
    1127                 :             --this->_M_impl._M_start._M_cur;
    1128                 :           }
    1129                 :         else
    1130                 :           _M_push_front_aux(__x);
    1131                 :       }
    1132                 : #else
    1133                 :       template<typename... _Args>
    1134                 :         void
    1135                 :         push_front(_Args&&... __args)
    1136                 :         {
    1137                 :           if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
    1138                 :             {
    1139                 :               this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1,
    1140                 :                                       std::forward<_Args>(__args)...);
    1141                 :               --this->_M_impl._M_start._M_cur;
    1142                 :             }
    1143                 :           else
    1144                 :             _M_push_front_aux(std::forward<_Args>(__args)...);
    1145                 :         }
    1146                 : #endif
    1147                 : 
    1148                 :       /**
    1149                 :        *  @brief  Add data to the end of the %deque.
    1150                 :        *  @param  x  Data to be added.
    1151                 :        *
    1152                 :        *  This is a typical stack operation.  The function creates an
    1153                 :        *  element at the end of the %deque and assigns the given data
    1154                 :        *  to it.  Due to the nature of a %deque this operation can be
    1155                 :        *  done in constant time.
    1156                 :        */
    1157                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
    1158                 :       void
    1159           12012 :       push_back(const value_type& __x)
    1160                 :       {
    1161           12012 :         if (this->_M_impl._M_finish._M_cur
    1162                 :             != this->_M_impl._M_finish._M_last - 1)
    1163                 :           {
    1164           11999 :             this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x);
    1165           11999 :             ++this->_M_impl._M_finish._M_cur;
    1166                 :           }
    1167                 :         else
    1168              13 :           _M_push_back_aux(__x);
    1169           12012 :       }
    1170                 : #else
    1171                 :       template<typename... _Args>
    1172                 :         void
    1173                 :         push_back(_Args&&... __args)
    1174                 :         {
    1175                 :           if (this->_M_impl._M_finish._M_cur
    1176                 :               != this->_M_impl._M_finish._M_last - 1)
    1177                 :             {
    1178                 :               this->_M_impl.construct(this->_M_impl._M_finish._M_cur,
    1179                 :                                       std::forward<_Args>(__args)...);
    1180                 :               ++this->_M_impl._M_finish._M_cur;
    1181                 :             }
    1182                 :           else
    1183                 :             _M_push_back_aux(std::forward<_Args>(__args)...);
    1184                 :         }
    1185                 : #endif
    1186                 : 
    1187                 :       /**
    1188                 :        *  @brief  Removes first element.
    1189                 :        *
    1190                 :        *  This is a typical stack operation.  It shrinks the %deque by one.
    1191                 :        *
    1192                 :        *  Note that no data is returned, and if the first element's data is
    1193                 :        *  needed, it should be retrieved before pop_front() is called.
    1194                 :        */
    1195                 :       void
    1196                 :       pop_front()
    1197                 :       {
    1198                 :         if (this->_M_impl._M_start._M_cur
    1199                 :             != this->_M_impl._M_start._M_last - 1)
    1200                 :           {
    1201                 :             this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
    1202                 :             ++this->_M_impl._M_start._M_cur;
    1203                 :           }
    1204                 :         else
    1205                 :           _M_pop_front_aux();
    1206                 :       }
    1207                 : 
    1208                 :       /**
    1209                 :        *  @brief  Removes last element.
    1210                 :        *
    1211                 :        *  This is a typical stack operation.  It shrinks the %deque by one.
    1212                 :        *
    1213                 :        *  Note that no data is returned, and if the last element's data is
    1214                 :        *  needed, it should be retrieved before pop_back() is called.
    1215                 :        */
    1216                 :       void
    1217              24 :       pop_back()
    1218                 :       {
    1219              24 :         if (this->_M_impl._M_finish._M_cur
    1220                 :             != this->_M_impl._M_finish._M_first)
    1221                 :           {
    1222              24 :             --this->_M_impl._M_finish._M_cur;
    1223              24 :             this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
    1224                 :           }
    1225                 :         else
    1226               0 :           _M_pop_back_aux();
    1227              24 :       }
    1228                 : 
    1229                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1230                 :       /**
    1231                 :        *  @brief  Inserts an object in %deque before specified iterator.
    1232                 :        *  @param  position  An iterator into the %deque.
    1233                 :        *  @param  args  Arguments.
    1234                 :        *  @return  An iterator that points to the inserted data.
    1235                 :        *
    1236                 :        *  This function will insert an object of type T constructed
    1237                 :        *  with T(std::forward<Args>(args)...) before the specified location.
    1238                 :        */
    1239                 :       template<typename... _Args>
    1240                 :         iterator
    1241                 :         emplace(iterator __position, _Args&&... __args);
    1242                 : #endif
    1243                 : 
    1244                 :       /**
    1245                 :        *  @brief  Inserts given value into %deque before specified iterator.
    1246                 :        *  @param  position  An iterator into the %deque.
    1247                 :        *  @param  x  Data to be inserted.
    1248                 :        *  @return  An iterator that points to the inserted data.
    1249                 :        *
    1250                 :        *  This function will insert a copy of the given value before the
    1251                 :        *  specified location.
    1252                 :        */
    1253                 :       iterator
    1254                 :       insert(iterator __position, const value_type& __x);
    1255                 : 
    1256                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1257                 :       /**
    1258                 :        *  @brief  Inserts given rvalue into %deque before specified iterator.
    1259                 :        *  @param  position  An iterator into the %deque.
    1260                 :        *  @param  x  Data to be inserted.
    1261                 :        *  @return  An iterator that points to the inserted data.
    1262                 :        *
    1263                 :        *  This function will insert a copy of the given rvalue before the
    1264                 :        *  specified location.
    1265                 :        */
    1266                 :       iterator
    1267                 :       insert(iterator __position, value_type&& __x)
    1268                 :       { return emplace(__position, std::move(__x)); }
    1269                 : #endif
    1270                 : 
    1271                 :       /**
    1272                 :        *  @brief  Inserts a number of copies of given data into the %deque.
    1273                 :        *  @param  position  An iterator into the %deque.
    1274                 :        *  @param  n  Number of elements to be inserted.
    1275                 :        *  @param  x  Data to be inserted.
    1276                 :        *
    1277                 :        *  This function will insert a specified number of copies of the given
    1278                 :        *  data before the location specified by @a position.
    1279                 :        */
    1280                 :       void
    1281                 :       insert(iterator __position, size_type __n, const value_type& __x)
    1282                 :       { _M_fill_insert(__position, __n, __x); }
    1283                 : 
    1284                 :       /**
    1285                 :        *  @brief  Inserts a range into the %deque.
    1286                 :        *  @param  position  An iterator into the %deque.
    1287                 :        *  @param  first  An input iterator.
    1288                 :        *  @param  last   An input iterator.
    1289                 :        *
    1290                 :        *  This function will insert copies of the data in the range
    1291                 :        *  [first,last) into the %deque before the location specified
    1292                 :        *  by @a pos.  This is known as "range insert."
    1293                 :        */
    1294                 :       template<typename _InputIterator>
    1295                 :         void
    1296                 :         insert(iterator __position, _InputIterator __first,
    1297               0 :                _InputIterator __last)
    1298                 :         {
    1299                 :           // Check whether it's an integral type.  If so, it's not an iterator.
    1300                 :           typedef typename std::__is_integer<_InputIterator>::__type _Integral;
    1301               0 :           _M_insert_dispatch(__position, __first, __last, _Integral());
    1302               0 :         }
    1303                 : 
    1304                 :       /**
    1305                 :        *  @brief  Remove element at given position.
    1306                 :        *  @param  position  Iterator pointing to element to be erased.
    1307                 :        *  @return  An iterator pointing to the next element (or end()).
    1308                 :        *
    1309                 :        *  This function will erase the element at the given position and thus
    1310                 :        *  shorten the %deque by one.
    1311                 :        *
    1312                 :        *  The user is cautioned that
    1313                 :        *  this function only erases the element, and that if the element is
    1314                 :        *  itself a pointer, the pointed-to memory is not touched in any way.
    1315                 :        *  Managing the pointer is the user's responsibility.
    1316                 :        */
    1317                 :       iterator
    1318                 :       erase(iterator __position);
    1319                 : 
    1320                 :       /**
    1321                 :        *  @brief  Remove a range of elements.
    1322                 :        *  @param  first  Iterator pointing to the first element to be erased.
    1323                 :        *  @param  last  Iterator pointing to one past the last element to be
    1324                 :        *                erased.
    1325                 :        *  @return  An iterator pointing to the element pointed to by @a last
    1326                 :        *           prior to erasing (or end()).
    1327                 :        *
    1328                 :        *  This function will erase the elements in the range [first,last) and
    1329                 :        *  shorten the %deque accordingly.
    1330                 :        *
    1331                 :        *  The user is cautioned that
    1332                 :        *  this function only erases the elements, and that if the elements
    1333                 :        *  themselves are pointers, the pointed-to memory is not touched in any
    1334                 :        *  way.  Managing the pointer is the user's responsibility.
    1335                 :        */
    1336                 :       iterator
    1337                 :       erase(iterator __first, iterator __last);
    1338                 : 
    1339                 :       /**
    1340                 :        *  @brief  Swaps data with another %deque.
    1341                 :        *  @param  x  A %deque of the same element and allocator types.
    1342                 :        *
    1343                 :        *  This exchanges the elements between two deques in constant time.
    1344                 :        *  (Four pointers, so it should be quite fast.)
    1345                 :        *  Note that the global std::swap() function is specialized such that
    1346                 :        *  std::swap(d1,d2) will feed to this function.
    1347                 :        */
    1348                 :       void
    1349                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1350                 :       swap(deque&& __x)
    1351                 : #else
    1352                 :       swap(deque& __x)
    1353                 : #endif
    1354                 :       {
    1355                 :         std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
    1356                 :         std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
    1357                 :         std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
    1358                 :         std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
    1359                 : 
    1360                 :         // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1361                 :         // 431. Swapping containers with unequal allocators.
    1362                 :         std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
    1363                 :                                                     __x._M_get_Tp_allocator());
    1364                 :       }
    1365                 : 
    1366                 :       /**
    1367                 :        *  Erases all the elements.  Note that this function only erases the
    1368                 :        *  elements, and that if the elements themselves are pointers, the
    1369                 :        *  pointed-to memory is not touched in any way.  Managing the pointer is
    1370                 :        *  the user's responsibility.
    1371                 :        */
    1372                 :       void
    1373             922 :       clear()
    1374             922 :       { _M_erase_at_end(begin()); }
    1375                 : 
    1376                 :     protected:
    1377                 :       // Internal constructor functions follow.
    1378                 : 
    1379                 :       // called by the range constructor to implement [23.1.1]/9
    1380                 : 
    1381                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1382                 :       // 438. Ambiguity in the "do the right thing" clause
    1383                 :       template<typename _Integer>
    1384                 :         void
    1385                 :         _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
    1386                 :         {
    1387                 :           _M_initialize_map(static_cast<size_type>(__n));
    1388                 :           _M_fill_initialize(__x);
    1389                 :         }
    1390                 : 
    1391                 :       // called by the range constructor to implement [23.1.1]/9
    1392                 :       template<typename _InputIterator>
    1393                 :         void
    1394                 :         _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
    1395                 :                                __false_type)
    1396                 :         {
    1397                 :           typedef typename std::iterator_traits<_InputIterator>::
    1398                 :             iterator_category _IterCategory;
    1399                 :           _M_range_initialize(__first, __last, _IterCategory());
    1400                 :         }
    1401                 : 
    1402                 :       // called by the second initialize_dispatch above
    1403                 :       //@{
    1404                 :       /**
    1405                 :        *  @brief Fills the deque with whatever is in [first,last).
    1406                 :        *  @param  first  An input iterator.
    1407                 :        *  @param  last  An input iterator.
    1408                 :        *  @return   Nothing.
    1409                 :        *
    1410                 :        *  If the iterators are actually forward iterators (or better), then the
    1411                 :        *  memory layout can be done all at once.  Else we move forward using
    1412                 :        *  push_back on each value from the iterator.
    1413                 :        */
    1414                 :       template<typename _InputIterator>
    1415                 :         void
    1416                 :         _M_range_initialize(_InputIterator __first, _InputIterator __last,
    1417                 :                             std::input_iterator_tag);
    1418                 : 
    1419                 :       // called by the second initialize_dispatch above
    1420                 :       template<typename _ForwardIterator>
    1421                 :         void
    1422                 :         _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
    1423                 :                             std::forward_iterator_tag);
    1424                 :       //@}
    1425                 : 
    1426                 :       /**
    1427                 :        *  @brief Fills the %deque with copies of value.
    1428                 :        *  @param  value  Initial value.
    1429                 :        *  @return   Nothing.
    1430                 :        *  @pre _M_start and _M_finish have already been initialized,
    1431                 :        *  but none of the %deque's elements have yet been constructed.
    1432                 :        *
    1433                 :        *  This function is called only when the user provides an explicit size
    1434                 :        *  (with or without an explicit exemplar value).
    1435                 :        */
    1436                 :       void
    1437                 :       _M_fill_initialize(const value_type& __value);
    1438                 : 
    1439                 :       // Internal assign functions follow.  The *_aux functions do the actual
    1440                 :       // assignment work for the range versions.
    1441                 : 
    1442                 :       // called by the range assign to implement [23.1.1]/9
    1443                 : 
    1444                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1445                 :       // 438. Ambiguity in the "do the right thing" clause
    1446                 :       template<typename _Integer>
    1447                 :         void
    1448                 :         _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
    1449                 :         { _M_fill_assign(__n, __val); }
    1450                 : 
    1451                 :       // called by the range assign to implement [23.1.1]/9
    1452                 :       template<typename _InputIterator>
    1453                 :         void
    1454                 :         _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
    1455                 :                            __false_type)
    1456                 :         {
    1457                 :           typedef typename std::iterator_traits<_InputIterator>::
    1458                 :             iterator_category _IterCategory;
    1459                 :           _M_assign_aux(__first, __last, _IterCategory());
    1460                 :         }
    1461                 : 
    1462                 :       // called by the second assign_dispatch above
    1463                 :       template<typename _InputIterator>
    1464                 :         void
    1465                 :         _M_assign_aux(_InputIterator __first, _InputIterator __last,
    1466                 :                       std::input_iterator_tag);
    1467                 : 
    1468                 :       // called by the second assign_dispatch above
    1469                 :       template<typename _ForwardIterator>
    1470                 :         void
    1471                 :         _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
    1472                 :                       std::forward_iterator_tag)
    1473                 :         {
    1474                 :           const size_type __len = std::distance(__first, __last);
    1475                 :           if (__len > size())
    1476                 :             {
    1477                 :               _ForwardIterator __mid = __first;
    1478                 :               std::advance(__mid, size());
    1479                 :               std::copy(__first, __mid, begin());
    1480                 :               insert(end(), __mid, __last);
    1481                 :             }
    1482                 :           else
    1483                 :             _M_erase_at_end(std::copy(__first, __last, begin()));
    1484                 :         }
    1485                 : 
    1486                 :       // Called by assign(n,t), and the range assign when it turns out
    1487                 :       // to be the same thing.
    1488                 :       void
    1489                 :       _M_fill_assign(size_type __n, const value_type& __val)
    1490                 :       {
    1491                 :         if (__n > size())
    1492                 :           {
    1493                 :             std::fill(begin(), end(), __val);
    1494                 :             insert(end(), __n - size(), __val);
    1495                 :           }
    1496                 :         else
    1497                 :           {
    1498                 :             _M_erase_at_end(begin() + difference_type(__n));
    1499                 :             std::fill(begin(), end(), __val);
    1500                 :           }
    1501                 :       }
    1502                 : 
    1503                 :       //@{
    1504                 :       /// Helper functions for push_* and pop_*.
    1505                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
    1506                 :       void _M_push_back_aux(const value_type&);
    1507                 : 
    1508                 :       void _M_push_front_aux(const value_type&);
    1509                 : #else
    1510                 :       template<typename... _Args>
    1511                 :         void _M_push_back_aux(_Args&&... __args);
    1512                 : 
    1513                 :       template<typename... _Args>
    1514                 :         void _M_push_front_aux(_Args&&... __args);
    1515                 : #endif
    1516                 : 
    1517                 :       void _M_pop_back_aux();
    1518                 : 
    1519                 :       void _M_pop_front_aux();
    1520                 :       //@}
    1521                 : 
    1522                 :       // Internal insert functions follow.  The *_aux functions do the actual
    1523                 :       // insertion work when all shortcuts fail.
    1524                 : 
    1525                 :       // called by the range insert to implement [23.1.1]/9
    1526                 : 
    1527                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1528                 :       // 438. Ambiguity in the "do the right thing" clause
    1529                 :       template<typename _Integer>
    1530                 :         void
    1531                 :         _M_insert_dispatch(iterator __pos,
    1532                 :                            _Integer __n, _Integer __x, __true_type)
    1533                 :         { _M_fill_insert(__pos, __n, __x); }
    1534                 : 
    1535                 :       // called by the range insert to implement [23.1.1]/9
    1536                 :       template<typename _InputIterator>
    1537                 :         void
    1538                 :         _M_insert_dispatch(iterator __pos,
    1539                 :                            _InputIterator __first, _InputIterator __last,
    1540               0 :                            __false_type)
    1541                 :         {
    1542                 :           typedef typename std::iterator_traits<_InputIterator>::
    1543                 :             iterator_category _IterCategory;
    1544               0 :           _M_range_insert_aux(__pos, __first, __last, _IterCategory());
    1545               0 :         }
    1546                 : 
    1547                 :       // called by the second insert_dispatch above
    1548                 :       template<typename _InputIterator>
    1549                 :         void
    1550                 :         _M_range_insert_aux(iterator __pos, _InputIterator __first,
    1551                 :                             _InputIterator __last, std::input_iterator_tag);
    1552                 : 
    1553                 :       // called by the second insert_dispatch above
    1554                 :       template<typename _ForwardIterator>
    1555                 :         void
    1556                 :         _M_range_insert_aux(iterator __pos, _ForwardIterator __first,
    1557                 :                             _ForwardIterator __last, std::forward_iterator_tag);
    1558                 : 
    1559                 :       // Called by insert(p,n,x), and the range insert when it turns out to be
    1560                 :       // the same thing.  Can use fill functions in optimal situations,
    1561                 :       // otherwise passes off to insert_aux(p,n,x).
    1562                 :       void
    1563                 :       _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
    1564                 : 
    1565                 :       // called by insert(p,x)
    1566                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
    1567                 :       iterator
    1568                 :       _M_insert_aux(iterator __pos, const value_type& __x);
    1569                 : #else
    1570                 :       template<typename... _Args>
    1571                 :         iterator
    1572                 :         _M_insert_aux(iterator __pos, _Args&&... __args);
    1573                 : #endif
    1574                 : 
    1575                 :       // called by insert(p,n,x) via fill_insert
    1576                 :       void
    1577                 :       _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
    1578                 : 
    1579                 :       // called by range_insert_aux for forward iterators
    1580                 :       template<typename _ForwardIterator>
    1581                 :         void
    1582                 :         _M_insert_aux(iterator __pos,
    1583                 :                       _ForwardIterator __first, _ForwardIterator __last,
    1584                 :                       size_type __n);
    1585                 : 
    1586                 : 
    1587                 :       // Internal erase functions follow.
    1588                 : 
    1589                 :       void
    1590                 :       _M_destroy_data_aux(iterator __first, iterator __last);
    1591                 : 
    1592                 :       // Called by ~deque().
    1593                 :       // NB: Doesn't deallocate the nodes.
    1594                 :       template<typename _Alloc1>
    1595                 :         void
    1596                 :         _M_destroy_data(iterator __first, iterator __last, const _Alloc1&)
    1597                 :         { _M_destroy_data_aux(__first, __last); }
    1598                 : 
    1599                 :       void
    1600                 :       _M_destroy_data(iterator __first, iterator __last,
    1601            1046 :                       const std::allocator<_Tp>&)
    1602                 :       {
    1603                 :         if (!__has_trivial_destructor(value_type))
    1604              26 :           _M_destroy_data_aux(__first, __last);
    1605            1046 :       }
    1606                 : 
    1607                 :       // Called by erase(q1, q2).
    1608                 :       void
    1609              90 :       _M_erase_at_begin(iterator __pos)
    1610                 :       {
    1611              90 :         _M_destroy_data(begin(), __pos, _M_get_Tp_allocator());
    1612              90 :         _M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node);
    1613              90 :         this->_M_impl._M_start = __pos;
    1614              90 :       }
    1615                 : 
    1616                 :       // Called by erase(q1, q2), resize(), clear(), _M_assign_aux,
    1617                 :       // _M_fill_assign, operator=.
    1618                 :       void
    1619             926 :       _M_erase_at_end(iterator __pos)
    1620                 :       {
    1621             926 :         _M_destroy_data(__pos, end(), _M_get_Tp_allocator());
    1622             926 :         _M_destroy_nodes(__pos._M_node + 1,
    1623                 :                          this->_M_impl._M_finish._M_node + 1);
    1624             926 :         this->_M_impl._M_finish = __pos;
    1625             926 :       }
    1626                 : 
    1627                 :       //@{
    1628                 :       /// Memory-handling helpers for the previous internal insert functions.
    1629                 :       iterator
    1630               0 :       _M_reserve_elements_at_front(size_type __n)
    1631                 :       {
    1632                 :         const size_type __vacancies = this->_M_impl._M_start._M_cur
    1633               0 :                                       - this->_M_impl._M_start._M_first;
    1634               0 :         if (__n > __vacancies)
    1635               0 :           _M_new_elements_at_front(__n - __vacancies);
    1636               0 :         return this->_M_impl._M_start - difference_type(__n);
    1637                 :       }
    1638                 : 
    1639                 :       iterator
    1640               0 :       _M_reserve_elements_at_back(size_type __n)
    1641                 :       {
    1642                 :         const size_type __vacancies = (this->_M_impl._M_finish._M_last
    1643               0 :                                        - this->_M_impl._M_finish._M_cur) - 1;
    1644               0 :         if (__n > __vacancies)
    1645               0 :           _M_new_elements_at_back(__n - __vacancies);
    1646               0 :         return this->_M_impl._M_finish + difference_type(__n);
    1647                 :       }
    1648                 : 
    1649                 :       void
    1650                 :       _M_new_elements_at_front(size_type __new_elements);
    1651                 : 
    1652                 :       void
    1653                 :       _M_new_elements_at_back(size_type __new_elements);
    1654                 :       //@}
    1655                 : 
    1656                 : 
    1657                 :       //@{
    1658                 :       /**
    1659                 :        *  @brief Memory-handling helpers for the major %map.
    1660                 :        *
    1661                 :        *  Makes sure the _M_map has space for new nodes.  Does not
    1662                 :        *  actually add the nodes.  Can invalidate _M_map pointers.
    1663                 :        *  (And consequently, %deque iterators.)
    1664                 :        */
    1665                 :       void
    1666              13 :       _M_reserve_map_at_back(size_type __nodes_to_add = 1)
    1667                 :       {
    1668              13 :         if (__nodes_to_add + 1 > this->_M_impl._M_map_size
    1669                 :             - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
    1670               0 :           _M_reallocate_map(__nodes_to_add, false);
    1671              13 :       }
    1672                 : 
    1673                 :       void
    1674               0 :       _M_reserve_map_at_front(size_type __nodes_to_add = 1)
    1675                 :       {
    1676               0 :         if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
    1677                 :                                        - this->_M_impl._M_map))
    1678               0 :           _M_reallocate_map(__nodes_to_add, true);
    1679               0 :       }
    1680                 : 
    1681                 :       void
    1682                 :       _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
    1683                 :       //@}
    1684                 :     };
    1685                 : 
    1686                 : 
    1687                 :   /**
    1688                 :    *  @brief  Deque equality comparison.
    1689                 :    *  @param  x  A %deque.
    1690                 :    *  @param  y  A %deque of the same type as @a x.
    1691                 :    *  @return  True iff the size and elements of the deques are equal.
    1692                 :    *
    1693                 :    *  This is an equivalence relation.  It is linear in the size of the
    1694                 :    *  deques.  Deques are considered equivalent if their sizes are equal,
    1695                 :    *  and if corresponding elements compare equal.
    1696                 :   */
    1697                 :   template<typename _Tp, typename _Alloc>
    1698                 :     inline bool
    1699                 :     operator==(const deque<_Tp, _Alloc>& __x,
    1700                 :                          const deque<_Tp, _Alloc>& __y)
    1701                 :     { return __x.size() == __y.size()
    1702                 :              && std::equal(__x.begin(), __x.end(), __y.begin()); }
    1703                 : 
    1704                 :   /**
    1705                 :    *  @brief  Deque ordering relation.
    1706                 :    *  @param  x  A %deque.
    1707                 :    *  @param  y  A %deque of the same type as @a x.
    1708                 :    *  @return  True iff @a x is lexicographically less than @a y.
    1709                 :    *
    1710                 :    *  This is a total ordering relation.  It is linear in the size of the
    1711                 :    *  deques.  The elements must be comparable with @c <.
    1712                 :    *
    1713                 :    *  See std::lexicographical_compare() for how the determination is made.
    1714                 :   */
    1715                 :   template<typename _Tp, typename _Alloc>
    1716                 :     inline bool
    1717                 :     operator<(const deque<_Tp, _Alloc>& __x,
    1718                 :               const deque<_Tp, _Alloc>& __y)
    1719                 :     { return std::lexicographical_compare(__x.begin(), __x.end(),
    1720                 :                                           __y.begin(), __y.end()); }
    1721                 : 
    1722                 :   /// Based on operator==
    1723                 :   template<typename _Tp, typename _Alloc>
    1724                 :     inline bool
    1725                 :     operator!=(const deque<_Tp, _Alloc>& __x,
    1726                 :                const deque<_Tp, _Alloc>& __y)
    1727                 :     { return !(__x == __y); }
    1728                 : 
    1729                 :   /// Based on operator<
    1730                 :   template<typename _Tp, typename _Alloc>
    1731                 :     inline bool
    1732                 :     operator>(const deque<_Tp, _Alloc>& __x,
    1733                 :               const deque<_Tp, _Alloc>& __y)
    1734                 :     { return __y < __x; }
    1735                 : 
    1736                 :   /// Based on operator<
    1737                 :   template<typename _Tp, typename _Alloc>
    1738                 :     inline bool
    1739                 :     operator<=(const deque<_Tp, _Alloc>& __x,
    1740                 :                const deque<_Tp, _Alloc>& __y)
    1741                 :     { return !(__y < __x); }
    1742                 : 
    1743                 :   /// Based on operator<
    1744                 :   template<typename _Tp, typename _Alloc>
    1745                 :     inline bool
    1746                 :     operator>=(const deque<_Tp, _Alloc>& __x,
    1747                 :                const deque<_Tp, _Alloc>& __y)
    1748                 :     { return !(__x < __y); }
    1749                 : 
    1750                 :   /// See std::deque::swap().
    1751                 :   template<typename _Tp, typename _Alloc>
    1752                 :     inline void
    1753                 :     swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
    1754                 :     { __x.swap(__y); }
    1755                 : 
    1756                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1757                 :   template<typename _Tp, typename _Alloc>
    1758                 :     inline void
    1759                 :     swap(deque<_Tp,_Alloc>&& __x, deque<_Tp,_Alloc>& __y)
    1760                 :     { __x.swap(__y); }
    1761                 : 
    1762                 :   template<typename _Tp, typename _Alloc>
    1763                 :     inline void
    1764                 :     swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>&& __y)
    1765                 :     { __x.swap(__y); }
    1766                 : #endif
    1767                 : 
    1768                 : _GLIBCXX_END_NESTED_NAMESPACE
    1769                 : 
    1770                 : #endif /* _STL_DEQUE_H */

Generated by: LTP GCOV extension version 1.6