LTP GCOV extension - code coverage report
Current view: | directory - usr/include/c++/4.3/bits - stl_vector.h
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 103
Code covered: | 91.3 % |  | Executed lines: | 94

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

Generated by: LTP GCOV extension version 1.6