LCOV - app.info - /tools/gcc-4.5/include/c++/4.5.2/bits/stl_deque.h

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: | 84 | 84 | 100.0 %
| Date: | 2012-04-07 | Functions: | 27 | 27 | 100.0 %

           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         9309989 :   __deque_buf_size(size_t __size)
          87                 :   { return (__size < _GLIBCXX_DEQUE_BUF_SIZE
          88         9309989 :             ? 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           19580 :       static size_t _S_buffer_size()
         109           19580 :       { 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           19580 :       _Deque_iterator()
         130           19580 :       : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { }
         131                 :
         132       108248257 :       _Deque_iterator(const iterator& __x)
         133                 :       : _M_cur(__x._M_cur), _M_first(__x._M_first),
         134       108248257 :         _M_last(__x._M_last), _M_node(__x._M_node) { }
         135                 :
         136                 :       reference
         137                 :       operator*() const
         138                 :       { return *_M_cur; }
         139                 :
         140                 :       pointer
         141                 :       operator->() const
         142                 :       { return _M_cur; }
         143                 :
         144                 :       _Self&
         145                 :       operator++()
         146                 :       {
         147                 :         ++_M_cur;
         148                 :         if (_M_cur == _M_last)
         149                 :           {
         150                 :             _M_set_node(_M_node + 1);
         151                 :             _M_cur = _M_first;
         152                 :           }
         153                 :         return *this;
         154                 :       }
         155                 :
         156                 :       _Self
         157                 :       operator++(int)
         158                 :       {
         159                 :         _Self __tmp = *this;
         160                 :         ++*this;
         161                 :         return __tmp;
         162                 :       }
         163                 :
         164                 :       _Self&
         165                 :       operator--()
         166                 :       {
         167                 :         if (_M_cur == _M_first)
         168                 :           {
         169                 :             _M_set_node(_M_node - 1);
         170                 :             _M_cur = _M_last;
         171                 :           }
         172                 :         --_M_cur;
         173                 :         return *this;
         174                 :       }
         175                 :
         176                 :       _Self
         177                 :       operator--(int)
         178                 :       {
         179                 :         _Self __tmp = *this;
         180                 :         --*this;
         181                 :         return __tmp;
         182                 :       }
         183                 :
         184                 :       _Self&
         185                 :       operator+=(difference_type __n)
         186                 :       {
         187                 :         const difference_type __offset = __n + (_M_cur - _M_first);
         188                 :         if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
         189                 :           _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                 :                                               / _S_buffer_size()) - 1;
         196                 :             _M_set_node(_M_node + __node_offset);
         197                 :             _M_cur = _M_first + (__offset - __node_offset
         198                 :                                  * difference_type(_S_buffer_size()));
         199                 :           }
         200                 :         return *this;
         201                 :       }
         202                 :
         203                 :       _Self
         204                 :       operator+(difference_type __n) const
         205                 :       {
         206                 :         _Self __tmp = *this;
         207                 :         return __tmp += __n;
         208                 :       }
         209                 :
         210                 :       _Self&
         211                 :       operator-=(difference_type __n)
         212                 :       { 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           19580 :       _M_set_node(_Map_pointer __new_node)
         232                 :       {
         233           19580 :         _M_node = __new_node;
         234           19580 :         _M_first = *__new_node;
         235           19580 :         _M_last = _M_first + difference_type(_S_buffer_size());
         236           19580 :       }
         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                 :     operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
         245                 :                const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
         246                 :     { 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                 :     operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
         252                 :                const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
         253                 :     { return __x._M_cur == __y._M_cur; }
         254                 :
         255                 :   template<typename _Tp, typename _Ref, typename _Ptr>
         256                 :     inline bool
         257                 :     operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
         258                 :                const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
         259                 :     { return !(__x == __y); }
         260                 :
         261                 :   template<typename _Tp, typename _RefL, typename _PtrL,
         262                 :            typename _RefR, typename _PtrR>
         263                 :     inline bool
         264                 :     operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
         265                 :                const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
         266                 :     { 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                 :     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                 :         + (__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                 :     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                 :                        __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                 :     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                 :                                 __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            4895 :       _Deque_base()
         449            4895 :       : _M_impl()
         450            4895 :       { _M_initialize_map(0); }
         451                 :
         452                 :       _Deque_base(const allocator_type& __a, size_t __num_elements)
         453                 :       : _M_impl(__a)
         454                 :       { _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            4895 :       _Deque_base(_Deque_base&& __x)
         462            4895 :       : _M_impl(__x._M_get_Tp_allocator())
         463                 :       {
         464            4895 :         _M_initialize_map(0);
         465            4895 :         if (__x._M_impl._M_map)
         466                 :           {
         467            4895 :             std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
         468            4895 :             std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
         469            4895 :             std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
         470            4895 :             std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
         471                 :           }
         472            4895 :       }
         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            9790 :       {
         488                 :         _Tp** _M_map;
         489                 :         size_t _M_map_size;
         490                 :         iterator _M_start;
         491                 :         iterator _M_finish;
         492                 :
         493            4895 :         _Deque_impl()
         494                 :         : _Tp_alloc_type(), _M_map(0), _M_map_size(0),
         495            4895 :           _M_start(), _M_finish()
         496            4895 :         { }
         497                 :
         498            4895 :         _Deque_impl(const _Tp_alloc_type& __a)
         499                 :         : _Tp_alloc_type(__a), _M_map(0), _M_map_size(0),
         500            4895 :           _M_start(), _M_finish()
         501            4895 :         { }
         502                 :       };
         503                 :
         504                 :       _Tp_alloc_type&
         505           14685 :       _M_get_Tp_allocator()
         506           14685 :       { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
         507                 :
         508                 :       const _Tp_alloc_type&
         509           19580 :       _M_get_Tp_allocator() const
         510           19580 :       { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
         511                 :
         512                 :       _Map_alloc_type
         513           19580 :       _M_get_map_allocator() const
         514           19580 :       { return _Map_alloc_type(_M_get_Tp_allocator()); }
         515                 :
         516                 :       _Tp*
         517            9790 :       _M_allocate_node()
         518                 :       {
         519            9790 :         return _M_impl._Tp_alloc_type::allocate(__deque_buf_size(sizeof(_Tp)));
         520                 :       }
         521                 :
         522                 :       void
         523            9790 :       _M_deallocate_node(_Tp* __p)
         524                 :       {
         525            9790 :         _M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
         526            9790 :       }
         527                 :
         528                 :       _Tp**
         529            9790 :       _M_allocate_map(size_t __n)
         530            9790 :       { return _M_get_map_allocator().allocate(__n); }
         531                 :
         532                 :       void
         533            9790 :       _M_deallocate_map(_Tp** __p, size_t __n)
         534            9790 :       { _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            9790 :     _Deque_base<_Tp, _Alloc>::
         547                 :     ~_Deque_base()
         548                 :     {
         549            9790 :       if (this->_M_impl._M_map)
         550                 :         {
         551            9790 :           _M_destroy_nodes(this->_M_impl._M_start._M_node,
         552                 :                            this->_M_impl._M_finish._M_node + 1);
         553            9790 :           _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
         554                 :         }
         555            9790 :     }
         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            9790 :     _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            9790 :                                   + 1);
         572                 :
         573            9790 :       this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
         574                 :                                            size_t(__num_nodes + 2));
         575            9790 :       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            9790 :                         + (this->_M_impl._M_map_size - __num_nodes) / 2);
         584            9790 :       _Tp** __nfinish = __nstart + __num_nodes;
         585                 :
         586                 :       __try
         587            9790 :         { _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            9790 :       this->_M_impl._M_start._M_set_node(__nstart);
         597            9790 :       this->_M_impl._M_finish._M_set_node(__nfinish - 1);
         598            9790 :       this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
         599            9790 :       this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
         600                 :                                         + __num_elements
         601                 :                                         % __deque_buf_size(sizeof(_Tp)));
         602            9790 :     }
         603                 :
         604                 :   template<typename _Tp, typename _Alloc>
         605                 :     void
         606            9790 :     _Deque_base<_Tp, _Alloc>::
         607                 :     _M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
         608                 :     {
         609                 :       _Tp** __cur;
         610                 :       __try
         611                 :         {
         612           19580 :           for (__cur = __nstart; __cur < __nfinish; ++__cur)
         613            9790 :             *__cur = this->_M_allocate_node();
         614                 :         }
         615                 :       __catch(...)
         616                 :         {
         617                 :           _M_destroy_nodes(__nstart, __cur);
         618                 :           __throw_exception_again;
         619                 :         }
         620            9790 :     }
         621                 :
         622                 :   template<typename _Tp, typename _Alloc>
         623                 :     void
         624            9790 :     _Deque_base<_Tp, _Alloc>::
         625                 :     _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
         626                 :     {
         627           19580 :       for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
         628            9790 :         _M_deallocate_node(*__n);
         629            9790 :     }
         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                 :       static size_t _S_buffer_size()
         741                 :       { 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            4895 :       deque()
         766            4895 :       : _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                 :       deque(const deque& __x)
         798                 :       : _Base(__x._M_get_Tp_allocator(), __x.size())
         799                 :       { std::__uninitialized_copy_a(__x.begin(), __x.end(),
         800                 :                                     this->_M_impl._M_start,
         801                 :                                     _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            4895 :       deque(deque&&  __x)
         812            4895 :       : _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            9790 :       ~deque()
         865            9790 :       { _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            9790 :       begin()
         977            9790 :       { 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                 :       begin() const
         985                 :       { 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       108228677 :       end()
         994       108228677 :       { 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                 :       end() const
        1003                 :       { 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                 :       size() const
        1082                 :       { 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                 :       empty() const
        1123                 :       { 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                 :       front()
        1208                 :       { 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                 :       back()
        1224                 :       {
        1225                 :         iterator __tmp = end();
        1226                 :         --__tmp;
        1227                 :         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                 :       back() const
        1236                 :       {
        1237                 :         const_iterator __tmp = end();
        1238                 :         --__tmp;
        1239                 :         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                 :       push_back(const value_type& __x)
        1285                 :       {
        1286                 :         if (this->_M_impl._M_finish._M_cur
        1287                 :             != this->_M_impl._M_finish._M_last - 1)
        1288                 :           {
        1289                 :             this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x);
        1290                 :             ++this->_M_impl._M_finish._M_cur;
        1291                 :           }
        1292                 :         else
        1293                 :           _M_push_back_aux(__x);
        1294                 :       }
        1295                 :
        1296                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
        1297                 :       void
        1298                 :       push_back(value_type&& __x)
        1299                 :       { 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                 :       pop_front()
        1316                 :       {
        1317                 :         if (this->_M_impl._M_start._M_cur
        1318                 :             != this->_M_impl._M_start._M_last - 1)
        1319                 :           {
        1320                 :             this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
        1321                 :             ++this->_M_impl._M_start._M_cur;
        1322                 :           }
        1323                 :         else
        1324                 :           _M_pop_front_aux();
        1325                 :       }
        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                 :       pop_back()
        1337                 :       {
        1338                 :         if (this->_M_impl._M_finish._M_cur
        1339                 :             != this->_M_impl._M_finish._M_first)
        1340                 :           {
        1341                 :             --this->_M_impl._M_finish._M_cur;
        1342                 :             this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
        1343                 :           }
        1344                 :         else
        1345                 :           _M_pop_back_aux();
        1346                 :       }
        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                 :       swap(deque& __x)
        1482                 :       {
        1483                 :         std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
        1484                 :         std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
        1485                 :         std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
        1486                 :         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                 :         std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
        1491                 :                                                     __x._M_get_Tp_allocator());
        1492                 :       }
        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                 :       clear()
        1502                 :       { _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            9790 :       _M_destroy_data(iterator __first, iterator __last,
        1729                 :                       const std::allocator<_Tp>&)
        1730                 :       {
        1731                 :         if (!__has_trivial_destructor(value_type))
        1732                 :           _M_destroy_data_aux(__first, __last);
        1733            9790 :       }
        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                 :       _M_erase_at_end(iterator __pos)
        1748                 :       {
        1749                 :         _M_destroy_data(__pos, end(), _M_get_Tp_allocator());
        1750                 :         _M_destroy_nodes(__pos._M_node + 1,
        1751                 :                          this->_M_impl._M_finish._M_node + 1);
        1752                 :         this->_M_impl._M_finish = __pos;
        1753                 :       }
        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                 :       _M_reserve_map_at_back(size_type __nodes_to_add = 1)
        1795                 :       {
        1796                 :         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                 :           _M_reallocate_map(__nodes_to_add, false);
        1799                 :       }
        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