LCOV - code coverage report
Current view: directory - tools/gcc-4.5/include/c++/4.5.2/bits - stl_deque.h (source / functions) Found Hit Coverage
Test: app.info Lines: 196 125 63.8 %
Date: 2012-06-02 Functions: 402 146 36.3 %

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

Generated by: LCOV version 1.7