LCOV - code coverage report
Current view: directory - tools/gcc-4.5/include/c++/4.5.2/bits - stl_vector.h (source / functions) Found Hit Coverage
Test: app.info Lines: 177 138 78.0 %
Date: 2012-06-02 Functions: 2042 402 19.7 %

       1                 : // Vector 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) 1996
      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_vector.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_VECTOR_H
      58                 : #define _STL_VECTOR_H 1
      59                 : 
      60                 : #include <bits/stl_iterator_base_funcs.h>
      61                 : #include <bits/functexcept.h>
      62                 : #include <bits/concept_check.h>
      63                 : #include <initializer_list>
      64                 : 
      65                 : _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
      66                 : 
      67                 :   /// See bits/stl_deque.h's _Deque_base for an explanation.
      68                 :   template<typename _Tp, typename _Alloc>
      69                 :     struct _Vector_base
      70                 :     {
      71                 :       typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
      72                 : 
      73                 :       struct _Vector_impl 
      74                 :       : public _Tp_alloc_type
      75          655492 :       {
      76                 :         typename _Tp_alloc_type::pointer _M_start;
      77                 :         typename _Tp_alloc_type::pointer _M_finish;
      78                 :         typename _Tp_alloc_type::pointer _M_end_of_storage;
      79                 : 
      80          676685 :         _Vector_impl()
      81          676685 :         : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
      82          676685 :         { }
      83                 : 
      84           35427 :         _Vector_impl(_Tp_alloc_type const& __a)
      85           35427 :         : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
      86           35427 :         { }
      87                 :       };
      88                 :       
      89                 :     public:
      90                 :       typedef _Alloc allocator_type;
      91                 : 
      92                 :       _Tp_alloc_type&
      93         7660037 :       _M_get_Tp_allocator()
      94         7660037 :       { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
      95                 : 
      96                 :       const _Tp_alloc_type&
      97         4527681 :       _M_get_Tp_allocator() const
      98         4527681 :       { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
      99                 : 
     100                 :       allocator_type
     101               0 :       get_allocator() const
     102               0 :       { return allocator_type(_M_get_Tp_allocator()); }
     103                 : 
     104          676685 :       _Vector_base()
     105          676685 :       : _M_impl() { }
     106                 : 
     107             251 :       _Vector_base(const allocator_type& __a)
     108             251 :       : _M_impl(__a) { }
     109                 : 
     110           32336 :       _Vector_base(size_t __n, const allocator_type& __a)
     111           32336 :       : _M_impl(__a)
     112                 :       {
     113           32336 :         this->_M_impl._M_start = this->_M_allocate(__n);
     114           32336 :         this->_M_impl._M_finish = this->_M_impl._M_start;
     115           32336 :         this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
     116           32336 :       }
     117                 : 
     118                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     119            2840 :       _Vector_base(_Vector_base&& __x)
     120            2840 :       : _M_impl(__x._M_get_Tp_allocator())
     121                 :       {
     122            2840 :         this->_M_impl._M_start = __x._M_impl._M_start;
     123            2840 :         this->_M_impl._M_finish = __x._M_impl._M_finish;
     124            2840 :         this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
     125            2840 :         __x._M_impl._M_start = 0;
     126            2840 :         __x._M_impl._M_finish = 0;
     127            2840 :         __x._M_impl._M_end_of_storage = 0;
     128            2840 :       }
     129                 : #endif
     130                 : 
     131          655492 :       ~_Vector_base()
     132          655492 :       { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
     133          655492 :                       - this->_M_impl._M_start); }
     134                 : 
     135                 :     public:
     136                 :       _Vector_impl _M_impl;
     137                 : 
     138                 :       typename _Tp_alloc_type::pointer
     139         2297150 :       _M_allocate(size_t __n)
     140         2297150 :       { return __n != 0 ? _M_impl.allocate(__n) : 0; }
     141                 : 
     142                 :       void
     143         2962438 :       _M_deallocate(typename _Tp_alloc_type::pointer __p, size_t __n)
     144                 :       {
     145         2962438 :         if (__p)
     146         2273376 :           _M_impl.deallocate(__p, __n);
     147         2962438 :       }
     148                 :     };
     149                 : 
     150                 : 
     151                 :   /**
     152                 :    *  @brief A standard container which offers fixed time access to
     153                 :    *  individual elements in any order.
     154                 :    *
     155                 :    *  @ingroup sequences
     156                 :    *
     157                 :    *  Meets the requirements of a <a href="tables.html#65">container</a>, a
     158                 :    *  <a href="tables.html#66">reversible container</a>, and a
     159                 :    *  <a href="tables.html#67">sequence</a>, including the
     160                 :    *  <a href="tables.html#68">optional sequence requirements</a> with the
     161                 :    *  %exception of @c push_front and @c pop_front.
     162                 :    *
     163                 :    *  In some terminology a %vector can be described as a dynamic
     164                 :    *  C-style array, it offers fast and efficient access to individual
     165                 :    *  elements in any order and saves the user from worrying about
     166                 :    *  memory and size allocation.  Subscripting ( @c [] ) access is
     167                 :    *  also provided as with C-style arrays.
     168                 :   */
     169                 :   template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
     170                 :     class vector : protected _Vector_base<_Tp, _Alloc>
     171                 :     {
     172                 :       // Concept requirements.
     173                 :       typedef typename _Alloc::value_type                _Alloc_value_type;
     174                 :       __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
     175                 :       __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
     176                 :       
     177                 :       typedef _Vector_base<_Tp, _Alloc>                    _Base;
     178                 :       typedef typename _Base::_Tp_alloc_type             _Tp_alloc_type;
     179                 : 
     180                 :     public:
     181                 :       typedef _Tp                                        value_type;
     182                 :       typedef typename _Tp_alloc_type::pointer           pointer;
     183                 :       typedef typename _Tp_alloc_type::const_pointer     const_pointer;
     184                 :       typedef typename _Tp_alloc_type::reference         reference;
     185                 :       typedef typename _Tp_alloc_type::const_reference   const_reference;
     186                 :       typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
     187                 :       typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
     188                 :       const_iterator;
     189                 :       typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
     190                 :       typedef std::reverse_iterator<iterator>              reverse_iterator;
     191                 :       typedef size_t                                     size_type;
     192                 :       typedef ptrdiff_t                                  difference_type;
     193                 :       typedef _Alloc                                     allocator_type;
     194                 : 
     195                 :     protected:
     196                 :       using _Base::_M_allocate;
     197                 :       using _Base::_M_deallocate;
     198                 :       using _Base::_M_impl;
     199                 :       using _Base::_M_get_Tp_allocator;
     200                 : 
     201                 :     public:
     202                 :       // [23.2.4.1] construct/copy/destroy
     203                 :       // (assign() and get_allocator() are also listed in this section)
     204                 :       /**
     205                 :        *  @brief  Default constructor creates no elements.
     206                 :        */
     207          676685 :       vector()
     208          676685 :       : _Base() { }
     209                 : 
     210                 :       /**
     211                 :        *  @brief  Creates a %vector with no elements.
     212                 :        *  @param  a  An allocator object.
     213                 :        */
     214                 :       explicit
     215               3 :       vector(const allocator_type& __a)
     216               3 :       : _Base(__a) { }
     217                 : 
     218                 :       /**
     219                 :        *  @brief  Creates a %vector with copies of an exemplar element.
     220                 :        *  @param  n  The number of elements to initially create.
     221                 :        *  @param  value  An element to copy.
     222                 :        *  @param  a  An allocator.
     223                 :        *
     224                 :        *  This constructor fills the %vector with @a n copies of @a value.
     225                 :        */
     226                 :       explicit
     227           32336 :       vector(size_type __n, const value_type& __value = value_type(),
     228                 :              const allocator_type& __a = allocator_type())
     229           32336 :       : _Base(__n, __a)
     230           32336 :       { _M_fill_initialize(__n, __value); }
     231                 : 
     232                 :       /**
     233                 :        *  @brief  %Vector copy constructor.
     234                 :        *  @param  x  A %vector of identical element and allocator types.
     235                 :        *
     236                 :        *  The newly-created %vector uses a copy of the allocation
     237                 :        *  object used by @a x.  All the elements of @a x are copied,
     238                 :        *  but any extra memory in
     239                 :        *  @a x (for fast expansion) will not be copied.
     240                 :        */
     241               0 :       vector(const vector& __x)
     242               0 :       : _Base(__x.size(), __x._M_get_Tp_allocator())
     243               0 :       { this->_M_impl._M_finish =
     244                 :           std::__uninitialized_copy_a(__x.begin(), __x.end(),
     245                 :                                       this->_M_impl._M_start,
     246                 :                                       _M_get_Tp_allocator());
     247               0 :       }
     248                 : 
     249                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     250                 :       /**
     251                 :        *  @brief  %Vector move constructor.
     252                 :        *  @param  x  A %vector of identical element and allocator types.
     253                 :        *
     254                 :        *  The newly-created %vector contains the exact contents of @a x.
     255                 :        *  The contents of @a x are a valid, but unspecified %vector.
     256                 :        */
     257            2840 :       vector(vector&& __x)
     258            2840 :       : _Base(std::forward<_Base>(__x)) { }
     259                 : 
     260                 :       /**
     261                 :        *  @brief  Builds a %vector from an initializer list.
     262                 :        *  @param  l  An initializer_list.
     263                 :        *  @param  a  An allocator.
     264                 :        *
     265                 :        *  Create a %vector consisting of copies of the elements in the
     266                 :        *  initializer_list @a l.
     267                 :        *
     268                 :        *  This will call the element type's copy constructor N times
     269                 :        *  (where N is @a l.size()) and do no memory reallocation.
     270                 :        */
     271                 :       vector(initializer_list<value_type> __l,
     272                 :              const allocator_type& __a = allocator_type())
     273                 :       : _Base(__a)
     274                 :       {
     275                 :         _M_range_initialize(__l.begin(), __l.end(),
     276                 :                             random_access_iterator_tag());
     277                 :       }
     278                 : #endif
     279                 : 
     280                 :       /**
     281                 :        *  @brief  Builds a %vector from a range.
     282                 :        *  @param  first  An input iterator.
     283                 :        *  @param  last  An input iterator.
     284                 :        *  @param  a  An allocator.
     285                 :        *
     286                 :        *  Create a %vector consisting of copies of the elements from
     287                 :        *  [first,last).
     288                 :        *
     289                 :        *  If the iterators are forward, bidirectional, or
     290                 :        *  random-access, then this will call the elements' copy
     291                 :        *  constructor N times (where N is distance(first,last)) and do
     292                 :        *  no memory reallocation.  But if only input iterators are
     293                 :        *  used, then this will do at most 2N calls to the copy
     294                 :        *  constructor, and logN memory reallocations.
     295                 :        */
     296                 :       template<typename _InputIterator>
     297             248 :         vector(_InputIterator __first, _InputIterator __last,
     298                 :                const allocator_type& __a = allocator_type())
     299             248 :         : _Base(__a)
     300                 :         {
     301                 :           // Check whether it's an integral type.  If so, it's not an iterator.
     302                 :           typedef typename std::__is_integer<_InputIterator>::__type _Integral;
     303             248 :           _M_initialize_dispatch(__first, __last, _Integral());
     304             248 :         }
     305                 : 
     306                 :       /**
     307                 :        *  The dtor only erases the elements, and note that if the
     308                 :        *  elements themselves are pointers, the pointed-to memory is
     309                 :        *  not touched in any way.  Managing the pointer is the user's
     310                 :        *  responsibility.
     311                 :        */
     312          655492 :       ~vector()
     313          655492 :       { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
     314          655492 :                       _M_get_Tp_allocator()); }
     315                 : 
     316                 :       /**
     317                 :        *  @brief  %Vector assignment operator.
     318                 :        *  @param  x  A %vector of identical element and allocator types.
     319                 :        *
     320                 :        *  All the elements of @a x are copied, but any extra memory in
     321                 :        *  @a x (for fast expansion) will not be copied.  Unlike the
     322                 :        *  copy constructor, the allocator object is not copied.
     323                 :        */
     324                 :       vector&
     325                 :       operator=(const vector& __x);
     326                 : 
     327                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     328                 :       /**
     329                 :        *  @brief  %Vector move assignment operator.
     330                 :        *  @param  x  A %vector of identical element and allocator types.
     331                 :        *
     332                 :        *  The contents of @a x are moved into this %vector (without copying).
     333                 :        *  @a x is a valid, but unspecified %vector.
     334                 :        */
     335                 :       vector&
     336             248 :       operator=(vector&& __x)
     337                 :       {
     338                 :         // NB: DR 1204.
     339                 :         // NB: DR 675.
     340             248 :         this->clear();
     341             248 :         this->swap(__x);
     342             248 :         return *this;
     343                 :       }
     344                 : 
     345                 :       /**
     346                 :        *  @brief  %Vector list assignment operator.
     347                 :        *  @param  l  An initializer_list.
     348                 :        *
     349                 :        *  This function fills a %vector with copies of the elements in the
     350                 :        *  initializer list @a l.
     351                 :        *
     352                 :        *  Note that the assignment completely changes the %vector and
     353                 :        *  that the resulting %vector's size is the same as the number
     354                 :        *  of elements assigned.  Old data may be lost.
     355                 :        */
     356                 :       vector&
     357                 :       operator=(initializer_list<value_type> __l)
     358                 :       {
     359                 :         this->assign(__l.begin(), __l.end());
     360                 :         return *this;
     361                 :       }
     362                 : #endif
     363                 : 
     364                 :       /**
     365                 :        *  @brief  Assigns a given value to a %vector.
     366                 :        *  @param  n  Number of elements to be assigned.
     367                 :        *  @param  val  Value to be assigned.
     368                 :        *
     369                 :        *  This function fills a %vector with @a n copies of the given
     370                 :        *  value.  Note that the assignment completely changes the
     371                 :        *  %vector and that the resulting %vector's size is the same as
     372                 :        *  the number of elements assigned.  Old data may be lost.
     373                 :        */
     374                 :       void
     375                 :       assign(size_type __n, const value_type& __val)
     376                 :       { _M_fill_assign(__n, __val); }
     377                 : 
     378                 :       /**
     379                 :        *  @brief  Assigns a range to a %vector.
     380                 :        *  @param  first  An input iterator.
     381                 :        *  @param  last   An input iterator.
     382                 :        *
     383                 :        *  This function fills a %vector with copies of the elements in the
     384                 :        *  range [first,last).
     385                 :        *
     386                 :        *  Note that the assignment completely changes the %vector and
     387                 :        *  that the resulting %vector's size is the same as the number
     388                 :        *  of elements assigned.  Old data may be lost.
     389                 :        */
     390                 :       template<typename _InputIterator>
     391                 :         void
     392              21 :         assign(_InputIterator __first, _InputIterator __last)
     393                 :         {
     394                 :           // Check whether it's an integral type.  If so, it's not an iterator.
     395                 :           typedef typename std::__is_integer<_InputIterator>::__type _Integral;
     396              21 :           _M_assign_dispatch(__first, __last, _Integral());
     397              21 :         }
     398                 : 
     399                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     400                 :       /**
     401                 :        *  @brief  Assigns an initializer list to a %vector.
     402                 :        *  @param  l  An initializer_list.
     403                 :        *
     404                 :        *  This function fills a %vector with copies of the elements in the
     405                 :        *  initializer list @a l.
     406                 :        *
     407                 :        *  Note that the assignment completely changes the %vector and
     408                 :        *  that the resulting %vector's size is the same as the number
     409                 :        *  of elements assigned.  Old data may be lost.
     410                 :        */
     411                 :       void
     412                 :       assign(initializer_list<value_type> __l)
     413                 :       { this->assign(__l.begin(), __l.end()); }
     414                 : #endif
     415                 : 
     416                 :       /// Get a copy of the memory allocation object.
     417                 :       using _Base::get_allocator;
     418                 : 
     419                 :       // iterators
     420                 :       /**
     421                 :        *  Returns a read/write iterator that points to the first
     422                 :        *  element in the %vector.  Iteration is done in ordinary
     423                 :        *  element order.
     424                 :        */
     425                 :       iterator
     426         4079883 :       begin()
     427         4079883 :       { return iterator(this->_M_impl._M_start); }
     428                 : 
     429                 :       /**
     430                 :        *  Returns a read-only (constant) iterator that points to the
     431                 :        *  first element in the %vector.  Iteration is done in ordinary
     432                 :        *  element order.
     433                 :        */
     434                 :       const_iterator
     435           16334 :       begin() const
     436           16334 :       { return const_iterator(this->_M_impl._M_start); }
     437                 : 
     438                 :       /**
     439                 :        *  Returns a read/write iterator that points one past the last
     440                 :        *  element in the %vector.  Iteration is done in ordinary
     441                 :        *  element order.
     442                 :        */
     443                 :       iterator
     444        33486821 :       end()
     445        33486821 :       { return iterator(this->_M_impl._M_finish); }
     446                 : 
     447                 :       /**
     448                 :        *  Returns a read-only (constant) iterator that points one past
     449                 :        *  the last element in the %vector.  Iteration is done in
     450                 :        *  ordinary element order.
     451                 :        */
     452                 :       const_iterator
     453           16334 :       end() const
     454           16334 :       { return const_iterator(this->_M_impl._M_finish); }
     455                 : 
     456                 :       /**
     457                 :        *  Returns a read/write reverse iterator that points to the
     458                 :        *  last element in the %vector.  Iteration is done in reverse
     459                 :        *  element order.
     460                 :        */
     461                 :       reverse_iterator
     462               0 :       rbegin()
     463               0 :       { return reverse_iterator(end()); }
     464                 : 
     465                 :       /**
     466                 :        *  Returns a read-only (constant) reverse iterator that points
     467                 :        *  to the last element in the %vector.  Iteration is done in
     468                 :        *  reverse element order.
     469                 :        */
     470                 :       const_reverse_iterator
     471                 :       rbegin() const
     472                 :       { return const_reverse_iterator(end()); }
     473                 : 
     474                 :       /**
     475                 :        *  Returns a read/write reverse iterator that points to one
     476                 :        *  before the first element in the %vector.  Iteration is done
     477                 :        *  in reverse element order.
     478                 :        */
     479                 :       reverse_iterator
     480               0 :       rend()
     481               0 :       { return reverse_iterator(begin()); }
     482                 : 
     483                 :       /**
     484                 :        *  Returns a read-only (constant) reverse iterator that points
     485                 :        *  to one before the first element in the %vector.  Iteration
     486                 :        *  is done in reverse element order.
     487                 :        */
     488                 :       const_reverse_iterator
     489                 :       rend() const
     490                 :       { return const_reverse_iterator(begin()); }
     491                 : 
     492                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     493                 :       /**
     494                 :        *  Returns a read-only (constant) iterator that points to the
     495                 :        *  first element in the %vector.  Iteration is done in ordinary
     496                 :        *  element order.
     497                 :        */
     498                 :       const_iterator
     499                 :       cbegin() const
     500                 :       { return const_iterator(this->_M_impl._M_start); }
     501                 : 
     502                 :       /**
     503                 :        *  Returns a read-only (constant) iterator that points one past
     504                 :        *  the last element in the %vector.  Iteration is done in
     505                 :        *  ordinary element order.
     506                 :        */
     507                 :       const_iterator
     508                 :       cend() const
     509                 :       { return const_iterator(this->_M_impl._M_finish); }
     510                 : 
     511                 :       /**
     512                 :        *  Returns a read-only (constant) reverse iterator that points
     513                 :        *  to the last element in the %vector.  Iteration is done in
     514                 :        *  reverse element order.
     515                 :        */
     516                 :       const_reverse_iterator
     517                 :       crbegin() const
     518                 :       { return const_reverse_iterator(end()); }
     519                 : 
     520                 :       /**
     521                 :        *  Returns a read-only (constant) reverse iterator that points
     522                 :        *  to one before the first element in the %vector.  Iteration
     523                 :        *  is done in reverse element order.
     524                 :        */
     525                 :       const_reverse_iterator
     526                 :       crend() const
     527                 :       { return const_reverse_iterator(begin()); }
     528                 : #endif
     529                 : 
     530                 :       // [23.2.4.2] capacity
     531                 :       /**  Returns the number of elements in the %vector.  */
     532                 :       size_type
     533        17193776 :       size() const
     534        17193776 :       { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
     535                 : 
     536                 :       /**  Returns the size() of the largest possible %vector.  */
     537                 :       size_type
     538         4527681 :       max_size() const
     539         4527681 :       { return _M_get_Tp_allocator().max_size(); }
     540                 : 
     541                 :       /**
     542                 :        *  @brief  Resizes the %vector to the specified number of elements.
     543                 :        *  @param  new_size  Number of elements the %vector should contain.
     544                 :        *  @param  x  Data with which new elements should be populated.
     545                 :        *
     546                 :        *  This function will %resize the %vector to the specified
     547                 :        *  number of elements.  If the number is smaller than the
     548                 :        *  %vector's current size the %vector is truncated, otherwise
     549                 :        *  the %vector is extended and new elements are populated with
     550                 :        *  given data.
     551                 :        */
     552                 :       void
     553           32606 :       resize(size_type __new_size, value_type __x = value_type())
     554                 :       {
     555           32606 :         if (__new_size < size())
     556               0 :           _M_erase_at_end(this->_M_impl._M_start + __new_size);
     557                 :         else
     558           32606 :           insert(end(), __new_size - size(), __x);
     559           32606 :       }
     560                 : 
     561                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     562                 :       /**  A non-binding request to reduce capacity() to size().  */
     563                 :       void
     564                 :       shrink_to_fit()
     565                 :       { std::__shrink_to_fit<vector>::_S_do_it(*this); }
     566                 : #endif
     567                 : 
     568                 :       /**
     569                 :        *  Returns the total number of elements that the %vector can
     570                 :        *  hold before needing to allocate more memory.
     571                 :        */
     572                 :       size_type
     573             748 :       capacity() const
     574                 :       { return size_type(this->_M_impl._M_end_of_storage
     575             748 :                          - this->_M_impl._M_start); }
     576                 : 
     577                 :       /**
     578                 :        *  Returns true if the %vector is empty.  (Thus begin() would
     579                 :        *  equal end().)
     580                 :        */
     581                 :       bool
     582           15610 :       empty() const
     583           15610 :       { return begin() == end(); }
     584                 : 
     585                 :       /**
     586                 :        *  @brief  Attempt to preallocate enough memory for specified number of
     587                 :        *          elements.
     588                 :        *  @param  n  Number of elements required.
     589                 :        *  @throw  std::length_error  If @a n exceeds @c max_size().
     590                 :        *
     591                 :        *  This function attempts to reserve enough memory for the
     592                 :        *  %vector to hold the specified number of elements.  If the
     593                 :        *  number requested is more than max_size(), length_error is
     594                 :        *  thrown.
     595                 :        *
     596                 :        *  The advantage of this function is that if optimal code is a
     597                 :        *  necessity and the user can determine the number of elements
     598                 :        *  that will be required, the user can reserve the memory in
     599                 :        *  %advance, and thus prevent a possible reallocation of memory
     600                 :        *  and copying of %vector data.
     601                 :        */
     602                 :       void
     603                 :       reserve(size_type __n);
     604                 : 
     605                 :       // element access
     606                 :       /**
     607                 :        *  @brief  Subscript access to the data contained in the %vector.
     608                 :        *  @param n The index of the element for which data should be
     609                 :        *  accessed.
     610                 :        *  @return  Read/write reference to data.
     611                 :        *
     612                 :        *  This operator allows for easy, array-style, data access.
     613                 :        *  Note that data access with this operator is unchecked and
     614                 :        *  out_of_range lookups are not defined. (For checked lookups
     615                 :        *  see at().)
     616                 :        */
     617                 :       reference
     618        14211093 :       operator[](size_type __n)
     619        14211093 :       { return *(this->_M_impl._M_start + __n); }
     620                 : 
     621                 :       /**
     622                 :        *  @brief  Subscript access to the data contained in the %vector.
     623                 :        *  @param n The index of the element for which data should be
     624                 :        *  accessed.
     625                 :        *  @return  Read-only (constant) reference to data.
     626                 :        *
     627                 :        *  This operator allows for easy, array-style, data access.
     628                 :        *  Note that data access with this operator is unchecked and
     629                 :        *  out_of_range lookups are not defined. (For checked lookups
     630                 :        *  see at().)
     631                 :        */
     632                 :       const_reference
     633        34067415 :       operator[](size_type __n) const
     634        34067415 :       { return *(this->_M_impl._M_start + __n); }
     635                 : 
     636                 :     protected:
     637                 :       /// Safety check used only from at().
     638                 :       void
     639               0 :       _M_range_check(size_type __n) const
     640                 :       {
     641               0 :         if (__n >= this->size())
     642               0 :           __throw_out_of_range(__N("vector::_M_range_check"));
     643               0 :       }
     644                 : 
     645                 :     public:
     646                 :       /**
     647                 :        *  @brief  Provides access to the data contained in the %vector.
     648                 :        *  @param n The index of the element for which data should be
     649                 :        *  accessed.
     650                 :        *  @return  Read/write reference to data.
     651                 :        *  @throw  std::out_of_range  If @a n is an invalid index.
     652                 :        *
     653                 :        *  This function provides for safer data access.  The parameter
     654                 :        *  is first checked that it is in the range of the vector.  The
     655                 :        *  function throws out_of_range if the check fails.
     656                 :        */
     657                 :       reference
     658               0 :       at(size_type __n)
     659                 :       {
     660               0 :         _M_range_check(__n);
     661               0 :         return (*this)[__n]; 
     662                 :       }
     663                 : 
     664                 :       /**
     665                 :        *  @brief  Provides access to the data contained in the %vector.
     666                 :        *  @param n The index of the element for which data should be
     667                 :        *  accessed.
     668                 :        *  @return  Read-only (constant) reference to data.
     669                 :        *  @throw  std::out_of_range  If @a n is an invalid index.
     670                 :        *
     671                 :        *  This function provides for safer data access.  The parameter
     672                 :        *  is first checked that it is in the range of the vector.  The
     673                 :        *  function throws out_of_range if the check fails.
     674                 :        */
     675                 :       const_reference
     676               0 :       at(size_type __n) const
     677                 :       {
     678               0 :         _M_range_check(__n);
     679               0 :         return (*this)[__n];
     680                 :       }
     681                 : 
     682                 :       /**
     683                 :        *  Returns a read/write reference to the data at the first
     684                 :        *  element of the %vector.
     685                 :        */
     686                 :       reference
     687               4 :       front()
     688               4 :       { return *begin(); }
     689                 : 
     690                 :       /**
     691                 :        *  Returns a read-only (constant) reference to the data at the first
     692                 :        *  element of the %vector.
     693                 :        */
     694                 :       const_reference
     695               0 :       front() const
     696               0 :       { return *begin(); }
     697                 : 
     698                 :       /**
     699                 :        *  Returns a read/write reference to the data at the last
     700                 :        *  element of the %vector.
     701                 :        */
     702                 :       reference
     703              82 :       back()
     704              82 :       { return *(end() - 1); }
     705                 :       
     706                 :       /**
     707                 :        *  Returns a read-only (constant) reference to the data at the
     708                 :        *  last element of the %vector.
     709                 :        */
     710                 :       const_reference
     711               0 :       back() const
     712               0 :       { return *(end() - 1); }
     713                 : 
     714                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
     715                 :       // DR 464. Suggestion for new member functions in standard containers.
     716                 :       // data access
     717                 :       /**
     718                 :        *   Returns a pointer such that [data(), data() + size()) is a valid
     719                 :        *   range.  For a non-empty %vector, data() == &front().
     720                 :        */
     721                 :       pointer
     722                 :       data()
     723                 :       { return pointer(this->_M_impl._M_start); }
     724                 : 
     725                 :       const_pointer
     726                 :       data() const
     727                 :       { return const_pointer(this->_M_impl._M_start); }
     728                 : 
     729                 :       // [23.2.4.3] modifiers
     730                 :       /**
     731                 :        *  @brief  Add data to the end of the %vector.
     732                 :        *  @param  x  Data to be added.
     733                 :        *
     734                 :        *  This is a typical stack operation.  The function creates an
     735                 :        *  element at the end of the %vector and assigns the given data
     736                 :        *  to it.  Due to the nature of a %vector this operation can be
     737                 :        *  done in constant time if the %vector has preallocated space
     738                 :        *  available.
     739                 :        */
     740                 :       void
     741         9880918 :       push_back(const value_type& __x)
     742                 :       {
     743         9880918 :         if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
     744                 :           {
     745         7656916 :             this->_M_impl.construct(this->_M_impl._M_finish, __x);
     746         7656916 :             ++this->_M_impl._M_finish;
     747                 :           }
     748                 :         else
     749         2224002 :           _M_insert_aux(end(), __x);
     750         9880918 :       }
     751                 : 
     752                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     753                 :       void
     754            8662 :       push_back(value_type&& __x)
     755            8662 :       { emplace_back(std::move(__x)); }
     756                 : 
     757                 :       template<typename... _Args>
     758                 :         void
     759                 :         emplace_back(_Args&&... __args);
     760                 : #endif
     761                 : 
     762                 :       /**
     763                 :        *  @brief  Removes last element.
     764                 :        *
     765                 :        *  This is a typical stack operation. It shrinks the %vector by one.
     766                 :        *
     767                 :        *  Note that no data is returned, and if the last element's
     768                 :        *  data is needed, it should be retrieved before pop_back() is
     769                 :        *  called.
     770                 :        */
     771                 :       void
     772               0 :       pop_back()
     773                 :       {
     774               0 :         --this->_M_impl._M_finish;
     775               0 :         this->_M_impl.destroy(this->_M_impl._M_finish);
     776               0 :       }
     777                 : 
     778                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     779                 :       /**
     780                 :        *  @brief  Inserts an object in %vector before specified iterator.
     781                 :        *  @param  position  An iterator into the %vector.
     782                 :        *  @param  args  Arguments.
     783                 :        *  @return  An iterator that points to the inserted data.
     784                 :        *
     785                 :        *  This function will insert an object of type T constructed
     786                 :        *  with T(std::forward<Args>(args)...) before the specified location.
     787                 :        *  Note that this kind of operation could be expensive for a %vector
     788                 :        *  and if it is frequently used the user should consider using
     789                 :        *  std::list.
     790                 :        */
     791                 :       template<typename... _Args>
     792                 :         iterator
     793                 :         emplace(iterator __position, _Args&&... __args);
     794                 : #endif
     795                 : 
     796                 :       /**
     797                 :        *  @brief  Inserts given value into %vector before specified iterator.
     798                 :        *  @param  position  An iterator into the %vector.
     799                 :        *  @param  x  Data to be inserted.
     800                 :        *  @return  An iterator that points to the inserted data.
     801                 :        *
     802                 :        *  This function will insert a copy of the given value before
     803                 :        *  the specified location.  Note that this kind of operation
     804                 :        *  could be expensive for a %vector and if it is frequently
     805                 :        *  used the user should consider using std::list.
     806                 :        */
     807                 :       iterator
     808                 :       insert(iterator __position, const value_type& __x);
     809                 : 
     810                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     811                 :       /**
     812                 :        *  @brief  Inserts given rvalue into %vector before specified iterator.
     813                 :        *  @param  position  An iterator into the %vector.
     814                 :        *  @param  x  Data to be inserted.
     815                 :        *  @return  An iterator that points to the inserted data.
     816                 :        *
     817                 :        *  This function will insert a copy of the given rvalue before
     818                 :        *  the specified location.  Note that this kind of operation
     819                 :        *  could be expensive for a %vector and if it is frequently
     820                 :        *  used the user should consider using std::list.
     821                 :        */
     822                 :       iterator
     823               4 :       insert(iterator __position, value_type&& __x)
     824               4 :       { return emplace(__position, std::move(__x)); }
     825                 : 
     826                 :       /**
     827                 :        *  @brief  Inserts an initializer_list into the %vector.
     828                 :        *  @param  position  An iterator into the %vector.
     829                 :        *  @param  l  An initializer_list.
     830                 :        *
     831                 :        *  This function will insert copies of the data in the 
     832                 :        *  initializer_list @a l into the %vector before the location
     833                 :        *  specified by @a position.
     834                 :        *
     835                 :        *  Note that this kind of operation could be expensive for a
     836                 :        *  %vector and if it is frequently used the user should
     837                 :        *  consider using std::list.
     838                 :        */
     839                 :       void
     840                 :       insert(iterator __position, initializer_list<value_type> __l)
     841                 :       { this->insert(__position, __l.begin(), __l.end()); }
     842                 : #endif
     843                 : 
     844                 :       /**
     845                 :        *  @brief  Inserts a number of copies of given data into the %vector.
     846                 :        *  @param  position  An iterator into the %vector.
     847                 :        *  @param  n  Number of elements to be inserted.
     848                 :        *  @param  x  Data to be inserted.
     849                 :        *
     850                 :        *  This function will insert a specified number of copies of
     851                 :        *  the given data before the location specified by @a position.
     852                 :        *
     853                 :        *  Note that this kind of operation could be expensive for a
     854                 :        *  %vector and if it is frequently used the user should
     855                 :        *  consider using std::list.
     856                 :        */
     857                 :       void
     858           32609 :       insert(iterator __position, size_type __n, const value_type& __x)
     859           32609 :       { _M_fill_insert(__position, __n, __x); }
     860                 : 
     861                 :       /**
     862                 :        *  @brief  Inserts a range into the %vector.
     863                 :        *  @param  position  An iterator into the %vector.
     864                 :        *  @param  first  An input iterator.
     865                 :        *  @param  last   An input iterator.
     866                 :        *
     867                 :        *  This function will insert copies of the data in the range
     868                 :        *  [first,last) into the %vector before the location specified
     869                 :        *  by @a pos.
     870                 :        *
     871                 :        *  Note that this kind of operation could be expensive for a
     872                 :        *  %vector and if it is frequently used the user should
     873                 :        *  consider using std::list.
     874                 :        */
     875                 :       template<typename _InputIterator>
     876                 :         void
     877               0 :         insert(iterator __position, _InputIterator __first,
     878                 :                _InputIterator __last)
     879                 :         {
     880                 :           // Check whether it's an integral type.  If so, it's not an iterator.
     881                 :           typedef typename std::__is_integer<_InputIterator>::__type _Integral;
     882               0 :           _M_insert_dispatch(__position, __first, __last, _Integral());
     883               0 :         }
     884                 : 
     885                 :       /**
     886                 :        *  @brief  Remove element at given position.
     887                 :        *  @param  position  Iterator pointing to element to be erased.
     888                 :        *  @return  An iterator pointing to the next element (or end()).
     889                 :        *
     890                 :        *  This function will erase the element at the given position and thus
     891                 :        *  shorten the %vector by one.
     892                 :        *
     893                 :        *  Note This operation could be expensive and if it is
     894                 :        *  frequently used the user should consider using std::list.
     895                 :        *  The user is also cautioned that this function only erases
     896                 :        *  the element, and that if the element is itself a pointer,
     897                 :        *  the pointed-to memory is not touched in any way.  Managing
     898                 :        *  the pointer is the user's responsibility.
     899                 :        */
     900                 :       iterator
     901                 :       erase(iterator __position);
     902                 : 
     903                 :       /**
     904                 :        *  @brief  Remove a range of elements.
     905                 :        *  @param  first  Iterator pointing to the first element to be erased.
     906                 :        *  @param  last  Iterator pointing to one past the last element to be
     907                 :        *                erased.
     908                 :        *  @return  An iterator pointing to the element pointed to by @a last
     909                 :        *           prior to erasing (or end()).
     910                 :        *
     911                 :        *  This function will erase the elements in the range [first,last) and
     912                 :        *  shorten the %vector accordingly.
     913                 :        *
     914                 :        *  Note This operation could be expensive and if it is
     915                 :        *  frequently used the user should consider using std::list.
     916                 :        *  The user is also cautioned that this function only erases
     917                 :        *  the elements, and that if the elements themselves are
     918                 :        *  pointers, the pointed-to memory is not touched in any way.
     919                 :        *  Managing the pointer is the user's responsibility.
     920                 :        */
     921                 :       iterator
     922                 :       erase(iterator __first, iterator __last);
     923                 : 
     924                 :       /**
     925                 :        *  @brief  Swaps data with another %vector.
     926                 :        *  @param  x  A %vector of the same element and allocator types.
     927                 :        *
     928                 :        *  This exchanges the elements between two vectors in constant time.
     929                 :        *  (Three pointers, so it should be quite fast.)
     930                 :        *  Note that the global std::swap() function is specialized such that
     931                 :        *  std::swap(v1,v2) will feed to this function.
     932                 :        */
     933                 :       void
     934             248 :       swap(vector& __x)
     935                 :       {
     936             248 :         std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
     937             248 :         std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
     938             248 :         std::swap(this->_M_impl._M_end_of_storage,
     939                 :                   __x._M_impl._M_end_of_storage);
     940                 : 
     941                 :         // _GLIBCXX_RESOLVE_LIB_DEFECTS
     942                 :         // 431. Swapping containers with unequal allocators.
     943             248 :         std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
     944                 :                                                     __x._M_get_Tp_allocator());
     945             248 :       }
     946                 : 
     947                 :       /**
     948                 :        *  Erases all the elements.  Note that this function only erases the
     949                 :        *  elements, and that if the elements themselves are pointers, the
     950                 :        *  pointed-to memory is not touched in any way.  Managing the pointer is
     951                 :        *  the user's responsibility.
     952                 :        */
     953                 :       void
     954            6357 :       clear()
     955            6357 :       { _M_erase_at_end(this->_M_impl._M_start); }
     956                 : 
     957                 :     protected:
     958                 :       /**
     959                 :        *  Memory expansion handler.  Uses the member allocation function to
     960                 :        *  obtain @a n bytes of memory, and then copies [first,last) into it.
     961                 :        */
     962                 :       template<typename _ForwardIterator>
     963                 :         pointer
     964             727 :         _M_allocate_and_copy(size_type __n,
     965                 :                              _ForwardIterator __first, _ForwardIterator __last)
     966                 :         {
     967             727 :           pointer __result = this->_M_allocate(__n);
     968                 :           __try
     969                 :             {
     970             727 :               std::__uninitialized_copy_a(__first, __last, __result,
     971                 :                                           _M_get_Tp_allocator());
     972             727 :               return __result;
     973                 :             }
     974               0 :           __catch(...)
     975                 :             {
     976               0 :               _M_deallocate(__result, __n);
     977               0 :               __throw_exception_again;
     978                 :             }
     979                 :         }
     980                 : 
     981                 : 
     982                 :       // Internal constructor functions follow.
     983                 : 
     984                 :       // Called by the range constructor to implement [23.1.1]/9
     985                 : 
     986                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
     987                 :       // 438. Ambiguity in the "do the right thing" clause
     988                 :       template<typename _Integer>
     989                 :         void
     990                 :         _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
     991                 :         {
     992                 :           this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
     993                 :           this->_M_impl._M_end_of_storage =
     994                 :             this->_M_impl._M_start + static_cast<size_type>(__n);
     995                 :           _M_fill_initialize(static_cast<size_type>(__n), __value);
     996                 :         }
     997                 : 
     998                 :       // Called by the range constructor to implement [23.1.1]/9
     999                 :       template<typename _InputIterator>
    1000                 :         void
    1001             248 :         _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
    1002                 :                                __false_type)
    1003                 :         {
    1004                 :           typedef typename std::iterator_traits<_InputIterator>::
    1005                 :             iterator_category _IterCategory;
    1006             248 :           _M_range_initialize(__first, __last, _IterCategory());
    1007             248 :         }
    1008                 : 
    1009                 :       // Called by the second initialize_dispatch above
    1010                 :       template<typename _InputIterator>
    1011                 :         void
    1012                 :         _M_range_initialize(_InputIterator __first,
    1013                 :                             _InputIterator __last, std::input_iterator_tag)
    1014                 :         {
    1015                 :           for (; __first != __last; ++__first)
    1016                 :             push_back(*__first);
    1017                 :         }
    1018                 : 
    1019                 :       // Called by the second initialize_dispatch above
    1020                 :       template<typename _ForwardIterator>
    1021                 :         void
    1022             248 :         _M_range_initialize(_ForwardIterator __first,
    1023                 :                             _ForwardIterator __last, std::forward_iterator_tag)
    1024                 :         {
    1025             248 :           const size_type __n = std::distance(__first, __last);
    1026             248 :           this->_M_impl._M_start = this->_M_allocate(__n);
    1027             248 :           this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
    1028             248 :           this->_M_impl._M_finish =
    1029                 :             std::__uninitialized_copy_a(__first, __last,
    1030                 :                                         this->_M_impl._M_start,
    1031                 :                                         _M_get_Tp_allocator());
    1032             248 :         }
    1033                 : 
    1034                 :       // Called by the first initialize_dispatch above and by the
    1035                 :       // vector(n,value,a) constructor.
    1036                 :       void
    1037           32336 :       _M_fill_initialize(size_type __n, const value_type& __value)
    1038                 :       {
    1039           32336 :         std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, 
    1040                 :                                       _M_get_Tp_allocator());
    1041           32336 :         this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
    1042           32336 :       }
    1043                 : 
    1044                 : 
    1045                 :       // Internal assign functions follow.  The *_aux functions do the actual
    1046                 :       // assignment work for the range versions.
    1047                 : 
    1048                 :       // Called by the range assign to implement [23.1.1]/9
    1049                 : 
    1050                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1051                 :       // 438. Ambiguity in the "do the right thing" clause
    1052                 :       template<typename _Integer>
    1053                 :         void
    1054                 :         _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
    1055                 :         { _M_fill_assign(__n, __val); }
    1056                 : 
    1057                 :       // Called by the range assign to implement [23.1.1]/9
    1058                 :       template<typename _InputIterator>
    1059                 :         void
    1060              21 :         _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
    1061                 :                            __false_type)
    1062                 :         {
    1063                 :           typedef typename std::iterator_traits<_InputIterator>::
    1064                 :             iterator_category _IterCategory;
    1065              21 :           _M_assign_aux(__first, __last, _IterCategory());
    1066              21 :         }
    1067                 : 
    1068                 :       // Called by the second assign_dispatch above
    1069                 :       template<typename _InputIterator>
    1070                 :         void
    1071                 :         _M_assign_aux(_InputIterator __first, _InputIterator __last,
    1072                 :                       std::input_iterator_tag);
    1073                 : 
    1074                 :       // Called by the second assign_dispatch above
    1075                 :       template<typename _ForwardIterator>
    1076                 :         void
    1077                 :         _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
    1078                 :                       std::forward_iterator_tag);
    1079                 : 
    1080                 :       // Called by assign(n,t), and the range assign when it turns out
    1081                 :       // to be the same thing.
    1082                 :       void
    1083                 :       _M_fill_assign(size_type __n, const value_type& __val);
    1084                 : 
    1085                 : 
    1086                 :       // Internal insert functions follow.
    1087                 : 
    1088                 :       // Called by the range insert to implement [23.1.1]/9
    1089                 : 
    1090                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1091                 :       // 438. Ambiguity in the "do the right thing" clause
    1092                 :       template<typename _Integer>
    1093                 :         void
    1094                 :         _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
    1095                 :                            __true_type)
    1096                 :         { _M_fill_insert(__pos, __n, __val); }
    1097                 : 
    1098                 :       // Called by the range insert to implement [23.1.1]/9
    1099                 :       template<typename _InputIterator>
    1100                 :         void
    1101               0 :         _M_insert_dispatch(iterator __pos, _InputIterator __first,
    1102                 :                            _InputIterator __last, __false_type)
    1103                 :         {
    1104                 :           typedef typename std::iterator_traits<_InputIterator>::
    1105                 :             iterator_category _IterCategory;
    1106               0 :           _M_range_insert(__pos, __first, __last, _IterCategory());
    1107               0 :         }
    1108                 : 
    1109                 :       // Called by the second insert_dispatch above
    1110                 :       template<typename _InputIterator>
    1111                 :         void
    1112                 :         _M_range_insert(iterator __pos, _InputIterator __first,
    1113                 :                         _InputIterator __last, std::input_iterator_tag);
    1114                 : 
    1115                 :       // Called by the second insert_dispatch above
    1116                 :       template<typename _ForwardIterator>
    1117                 :         void
    1118                 :         _M_range_insert(iterator __pos, _ForwardIterator __first,
    1119                 :                         _ForwardIterator __last, std::forward_iterator_tag);
    1120                 : 
    1121                 :       // Called by insert(p,n,x), and the range insert when it turns out to be
    1122                 :       // the same thing.
    1123                 :       void
    1124                 :       _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
    1125                 : 
    1126                 :       // Called by insert(p,x)
    1127                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
    1128                 :       void
    1129                 :       _M_insert_aux(iterator __position, const value_type& __x);
    1130                 : #else
    1131                 :       template<typename... _Args>
    1132                 :         void
    1133                 :         _M_insert_aux(iterator __position, _Args&&... __args);
    1134                 : #endif
    1135                 : 
    1136                 :       // Called by the latter.
    1137                 :       size_type
    1138         2263839 :       _M_check_len(size_type __n, const char* __s) const
    1139                 :       {
    1140         2263839 :         if (max_size() - size() < __n)
    1141               0 :           __throw_length_error(__N(__s));
    1142                 : 
    1143         2263839 :         const size_type __len = size() + std::max(size(), __n);
    1144         2263839 :         return (__len < size() || __len > max_size()) ? max_size() : __len;
    1145                 :       }
    1146                 : 
    1147                 :       // Internal erase functions follow.
    1148                 : 
    1149                 :       // Called by erase(q1,q2), clear(), resize(), _M_fill_assign,
    1150                 :       // _M_assign_aux.
    1151                 :       void
    1152            6406 :       _M_erase_at_end(pointer __pos)
    1153                 :       {
    1154            6406 :         std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
    1155            6406 :         this->_M_impl._M_finish = __pos;
    1156            6406 :       }
    1157                 :     };
    1158                 : 
    1159                 : 
    1160                 :   /**
    1161                 :    *  @brief  Vector equality comparison.
    1162                 :    *  @param  x  A %vector.
    1163                 :    *  @param  y  A %vector of the same type as @a x.
    1164                 :    *  @return  True iff the size and elements of the vectors are equal.
    1165                 :    *
    1166                 :    *  This is an equivalence relation.  It is linear in the size of the
    1167                 :    *  vectors.  Vectors are considered equivalent if their sizes are equal,
    1168                 :    *  and if corresponding elements compare equal.
    1169                 :   */
    1170                 :   template<typename _Tp, typename _Alloc>
    1171                 :     inline bool
    1172                 :     operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    1173                 :     { return (__x.size() == __y.size()
    1174                 :               && std::equal(__x.begin(), __x.end(), __y.begin())); }
    1175                 : 
    1176                 :   /**
    1177                 :    *  @brief  Vector ordering relation.
    1178                 :    *  @param  x  A %vector.
    1179                 :    *  @param  y  A %vector of the same type as @a x.
    1180                 :    *  @return  True iff @a x is lexicographically less than @a y.
    1181                 :    *
    1182                 :    *  This is a total ordering relation.  It is linear in the size of the
    1183                 :    *  vectors.  The elements must be comparable with @c <.
    1184                 :    *
    1185                 :    *  See std::lexicographical_compare() for how the determination is made.
    1186                 :   */
    1187                 :   template<typename _Tp, typename _Alloc>
    1188                 :     inline bool
    1189                 :     operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    1190                 :     { return std::lexicographical_compare(__x.begin(), __x.end(),
    1191                 :                                           __y.begin(), __y.end()); }
    1192                 : 
    1193                 :   /// Based on operator==
    1194                 :   template<typename _Tp, typename _Alloc>
    1195                 :     inline bool
    1196                 :     operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    1197                 :     { return !(__x == __y); }
    1198                 : 
    1199                 :   /// Based on operator<
    1200                 :   template<typename _Tp, typename _Alloc>
    1201                 :     inline bool
    1202                 :     operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    1203                 :     { return __y < __x; }
    1204                 : 
    1205                 :   /// Based on operator<
    1206                 :   template<typename _Tp, typename _Alloc>
    1207                 :     inline bool
    1208                 :     operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    1209                 :     { return !(__y < __x); }
    1210                 : 
    1211                 :   /// Based on operator<
    1212                 :   template<typename _Tp, typename _Alloc>
    1213                 :     inline bool
    1214                 :     operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    1215                 :     { return !(__x < __y); }
    1216                 : 
    1217                 :   /// See std::vector::swap().
    1218                 :   template<typename _Tp, typename _Alloc>
    1219                 :     inline void
    1220                 :     swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
    1221                 :     { __x.swap(__y); }
    1222                 : 
    1223                 : _GLIBCXX_END_NESTED_NAMESPACE
    1224                 : 
    1225                 : #endif /* _STL_VECTOR_H */

Generated by: LCOV version 1.7