LCOV - code coverage report
Current view: directory - tools/gcc-4.5/include/c++/4.5.2/bits - stl_list.h (source / functions) Found Hit Coverage
Test: app.info Lines: 130 82 63.1 %
Date: 2012-06-02 Functions: 201 73 36.3 %

       1                 : // List 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,1997
      41                 :  * Silicon Graphics Computer Systems, Inc.
      42                 :  *
      43                 :  * Permission to use, copy, modify, distribute and sell this software
      44                 :  * and its documentation for any purpose is hereby granted without fee,
      45                 :  * provided that the above copyright notice appear in all copies and
      46                 :  * that both that copyright notice and this permission notice appear
      47                 :  * in supporting documentation.  Silicon Graphics makes no
      48                 :  * representations about the suitability of this software for any
      49                 :  * purpose.  It is provided "as is" without express or implied warranty.
      50                 :  */
      51                 : 
      52                 : /** @file stl_list.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_LIST_H
      58                 : #define _STL_LIST_H 1
      59                 : 
      60                 : #include <bits/concept_check.h>
      61                 : #include <initializer_list>
      62                 : 
      63                 : _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
      64                 : 
      65                 :   // Supporting structures are split into common and templated types; the
      66                 :   // latter publicly inherits from the former in an effort to reduce code
      67                 :   // duplication.  This results in some "needless" static_cast'ing later on,
      68                 :   // but it's all safe downcasting.
      69                 : 
      70                 :   /// Common part of a node in the %list. 
      71                 :   struct _List_node_base
      72                 :   {
      73                 :     _List_node_base* _M_next;
      74                 :     _List_node_base* _M_prev;
      75                 : 
      76                 :     static void
      77                 :     swap(_List_node_base& __x, _List_node_base& __y) throw ();
      78                 : 
      79                 :     void
      80                 :     _M_transfer(_List_node_base * const __first,
      81                 :                 _List_node_base * const __last) throw ();
      82                 : 
      83                 :     void
      84                 :     _M_reverse() throw ();
      85                 : 
      86                 :     void
      87                 :     _M_hook(_List_node_base * const __position) throw ();
      88                 : 
      89                 :     void
      90                 :     _M_unhook() throw ();
      91                 :   };
      92                 : 
      93                 :   /// An actual node in the %list.
      94                 :   template<typename _Tp>
      95                 :     struct _List_node : public _List_node_base
      96         8578097 :     {
      97                 :       ///< User's data.
      98                 :       _Tp _M_data;
      99                 : 
     100                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     101                 :       template<typename... _Args>
     102            1987 :         _List_node(_Args&&... __args)
     103            1987 :         : _List_node_base(), _M_data(std::forward<_Args>(__args)...) { }
     104                 : #endif
     105                 :     };
     106                 : 
     107                 :   /**
     108                 :    *  @brief A list::iterator.
     109                 :    *
     110                 :    *  All the functions are op overloads.
     111                 :   */
     112                 :   template<typename _Tp>
     113                 :     struct _List_iterator
     114                 :     {
     115                 :       typedef _List_iterator<_Tp>                _Self;
     116                 :       typedef _List_node<_Tp>                    _Node;
     117                 : 
     118                 :       typedef ptrdiff_t                          difference_type;
     119                 :       typedef std::bidirectional_iterator_tag    iterator_category;
     120                 :       typedef _Tp                                value_type;
     121                 :       typedef _Tp*                               pointer;
     122                 :       typedef _Tp&                               reference;
     123                 : 
     124             667 :       _List_iterator()
     125             667 :       : _M_node() { }
     126                 : 
     127                 :       explicit
     128           13060 :       _List_iterator(_List_node_base* __x)
     129           13060 :       : _M_node(__x) { }
     130                 : 
     131                 :       // Must downcast from List_node_base to _List_node to get to _M_data.
     132                 :       reference
     133            5917 :       operator*() const
     134            5917 :       { return static_cast<_Node*>(_M_node)->_M_data; }
     135                 : 
     136                 :       pointer
     137               0 :       operator->() const
     138               0 :       { return &static_cast<_Node*>(_M_node)->_M_data; }
     139                 : 
     140                 :       _Self&
     141            3284 :       operator++()
     142                 :       {
     143            3284 :         _M_node = _M_node->_M_next;
     144            3284 :         return *this;
     145                 :       }
     146                 : 
     147                 :       _Self
     148             100 :       operator++(int)
     149                 :       {
     150             100 :         _Self __tmp = *this;
     151             100 :         _M_node = _M_node->_M_next;
     152                 :         return __tmp;
     153                 :       }
     154                 : 
     155                 :       _Self&
     156             496 :       operator--()
     157                 :       {
     158             496 :         _M_node = _M_node->_M_prev;
     159             496 :         return *this;
     160                 :       }
     161                 : 
     162                 :       _Self
     163                 :       operator--(int)
     164                 :       {
     165                 :         _Self __tmp = *this;
     166                 :         _M_node = _M_node->_M_prev;
     167                 :         return __tmp;
     168                 :       }
     169                 : 
     170                 :       bool
     171             213 :       operator==(const _Self& __x) const
     172             213 :       { return _M_node == __x._M_node; }
     173                 : 
     174                 :       bool
     175            5407 :       operator!=(const _Self& __x) const
     176            5407 :       { return _M_node != __x._M_node; }
     177                 : 
     178                 :       // The only member points to the %list element.
     179                 :       _List_node_base* _M_node;
     180                 :     };
     181                 : 
     182                 :   /**
     183                 :    *  @brief A list::const_iterator.
     184                 :    *
     185                 :    *  All the functions are op overloads.
     186                 :   */
     187                 :   template<typename _Tp>
     188                 :     struct _List_const_iterator
     189                 :     {
     190                 :       typedef _List_const_iterator<_Tp>          _Self;
     191                 :       typedef const _List_node<_Tp>              _Node;
     192                 :       typedef _List_iterator<_Tp>                iterator;
     193                 : 
     194                 :       typedef ptrdiff_t                          difference_type;
     195                 :       typedef std::bidirectional_iterator_tag    iterator_category;
     196                 :       typedef _Tp                                value_type;
     197                 :       typedef const _Tp*                         pointer;
     198                 :       typedef const _Tp&                         reference;
     199                 : 
     200                 :       _List_const_iterator()
     201                 :       : _M_node() { }
     202                 : 
     203                 :       explicit
     204               0 :       _List_const_iterator(const _List_node_base* __x)
     205               0 :       : _M_node(__x) { }
     206                 : 
     207                 :       _List_const_iterator(const iterator& __x)
     208                 :       : _M_node(__x._M_node) { }
     209                 : 
     210                 :       // Must downcast from List_node_base to _List_node to get to
     211                 :       // _M_data.
     212                 :       reference
     213                 :       operator*() const
     214                 :       { return static_cast<_Node*>(_M_node)->_M_data; }
     215                 : 
     216                 :       pointer
     217               0 :       operator->() const
     218               0 :       { return &static_cast<_Node*>(_M_node)->_M_data; }
     219                 : 
     220                 :       _Self&
     221               0 :       operator++()
     222                 :       {
     223               0 :         _M_node = _M_node->_M_next;
     224               0 :         return *this;
     225                 :       }
     226                 : 
     227                 :       _Self
     228                 :       operator++(int)
     229                 :       {
     230                 :         _Self __tmp = *this;
     231                 :         _M_node = _M_node->_M_next;
     232                 :         return __tmp;
     233                 :       }
     234                 : 
     235                 :       _Self&
     236                 :       operator--()
     237                 :       {
     238                 :         _M_node = _M_node->_M_prev;
     239                 :         return *this;
     240                 :       }
     241                 : 
     242                 :       _Self
     243                 :       operator--(int)
     244                 :       {
     245                 :         _Self __tmp = *this;
     246                 :         _M_node = _M_node->_M_prev;
     247                 :         return __tmp;
     248                 :       }
     249                 : 
     250                 :       bool
     251                 :       operator==(const _Self& __x) const
     252                 :       { return _M_node == __x._M_node; }
     253                 : 
     254                 :       bool
     255               0 :       operator!=(const _Self& __x) const
     256               0 :       { return _M_node != __x._M_node; }
     257                 : 
     258                 :       // The only member points to the %list element.
     259                 :       const _List_node_base* _M_node;
     260                 :     };
     261                 : 
     262                 :   template<typename _Val>
     263                 :     inline bool
     264                 :     operator==(const _List_iterator<_Val>& __x,
     265                 :                const _List_const_iterator<_Val>& __y)
     266                 :     { return __x._M_node == __y._M_node; }
     267                 : 
     268                 :   template<typename _Val>
     269                 :     inline bool
     270                 :     operator!=(const _List_iterator<_Val>& __x,
     271                 :                const _List_const_iterator<_Val>& __y)
     272                 :     { return __x._M_node != __y._M_node; }
     273                 : 
     274                 : 
     275                 :   /// See bits/stl_deque.h's _Deque_base for an explanation.
     276                 :   template<typename _Tp, typename _Alloc>
     277                 :     class _List_base
     278                 :     {
     279                 :     protected:
     280                 :       // NOTA BENE
     281                 :       // The stored instance is not actually of "allocator_type"'s
     282                 :       // type.  Instead we rebind the type to
     283                 :       // Allocator<List_node<Tp>>, which according to [20.1.5]/4
     284                 :       // should probably be the same.  List_node<Tp> is not the same
     285                 :       // size as Tp (it's two pointers larger), and specializations on
     286                 :       // Tp may go unused because List_node<Tp> is being bound
     287                 :       // instead.
     288                 :       //
     289                 :       // We put this to the test in the constructors and in
     290                 :       // get_allocator, where we use conversions between
     291                 :       // allocator_type and _Node_alloc_type. The conversion is
     292                 :       // required by table 32 in [20.1.5].
     293                 :       typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
     294                 :         _Node_alloc_type;
     295                 : 
     296                 :       typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
     297                 : 
     298                 :       struct _List_impl 
     299                 :       : public _Node_alloc_type
     300         1832027 :       {
     301                 :         _List_node_base _M_node;
     302                 : 
     303            7217 :         _List_impl()
     304            7217 :         : _Node_alloc_type(), _M_node()
     305            7217 :         { }
     306                 : 
     307                 :         _List_impl(const _Node_alloc_type& __a)
     308                 :         : _Node_alloc_type(__a), _M_node()
     309                 :         { }
     310                 :       };
     311                 : 
     312                 :       _List_impl _M_impl;
     313                 : 
     314                 :       _List_node<_Tp>*
     315            1987 :       _M_get_node()
     316            1987 :       { return _M_impl._Node_alloc_type::allocate(1); }
     317                 :       
     318                 :       void
     319         8578097 :       _M_put_node(_List_node<_Tp>* __p)
     320         8578097 :       { _M_impl._Node_alloc_type::deallocate(__p, 1); }
     321                 :       
     322                 :   public:
     323                 :       typedef _Alloc allocator_type;
     324                 : 
     325                 :       _Node_alloc_type&
     326         8580084 :       _M_get_Node_allocator()
     327         8580084 :       { return *static_cast<_Node_alloc_type*>(&this->_M_impl); }
     328                 : 
     329                 :       const _Node_alloc_type&
     330                 :       _M_get_Node_allocator() const
     331                 :       { return *static_cast<const _Node_alloc_type*>(&this->_M_impl); }
     332                 : 
     333                 :       _Tp_alloc_type
     334                 :       _M_get_Tp_allocator() const
     335                 :       { return _Tp_alloc_type(_M_get_Node_allocator()); }
     336                 : 
     337                 :       allocator_type
     338                 :       get_allocator() const
     339                 :       { return allocator_type(_M_get_Node_allocator()); }
     340                 : 
     341            7217 :       _List_base()
     342            7217 :       : _M_impl()
     343            7217 :       { _M_init(); }
     344                 : 
     345                 :       _List_base(const allocator_type& __a)
     346                 :       : _M_impl(__a)
     347                 :       { _M_init(); }
     348                 : 
     349                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     350                 :       _List_base(_List_base&& __x)
     351                 :       : _M_impl(__x._M_get_Node_allocator())
     352                 :       {
     353                 :         _M_init();
     354                 :         _List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node);   
     355                 :       }
     356                 : #endif
     357                 : 
     358                 :       // This is what actually destroys the list.
     359         1832027 :       ~_List_base()
     360         1832027 :       { _M_clear(); }
     361                 : 
     362                 :       void
     363                 :       _M_clear();
     364                 : 
     365                 :       void
     366            7217 :       _M_init()
     367                 :       {
     368            7217 :         this->_M_impl._M_node._M_next = &this->_M_impl._M_node;
     369            7217 :         this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;
     370            7217 :       }
     371                 :     };
     372                 : 
     373                 :   /**
     374                 :    *  @brief A standard container with linear time access to elements,
     375                 :    *  and fixed time insertion/deletion at any point in the sequence.
     376                 :    *
     377                 :    *  @ingroup sequences
     378                 :    *
     379                 :    *  Meets the requirements of a <a href="tables.html#65">container</a>, a
     380                 :    *  <a href="tables.html#66">reversible container</a>, and a
     381                 :    *  <a href="tables.html#67">sequence</a>, including the
     382                 :    *  <a href="tables.html#68">optional sequence requirements</a> with the
     383                 :    *  %exception of @c at and @c operator[].
     384                 :    *
     385                 :    *  This is a @e doubly @e linked %list.  Traversal up and down the
     386                 :    *  %list requires linear time, but adding and removing elements (or
     387                 :    *  @e nodes) is done in constant time, regardless of where the
     388                 :    *  change takes place.  Unlike std::vector and std::deque,
     389                 :    *  random-access iterators are not provided, so subscripting ( @c
     390                 :    *  [] ) access is not allowed.  For algorithms which only need
     391                 :    *  sequential access, this lack makes no difference.
     392                 :    *
     393                 :    *  Also unlike the other standard containers, std::list provides
     394                 :    *  specialized algorithms %unique to linked lists, such as
     395                 :    *  splicing, sorting, and in-place reversal.
     396                 :    *
     397                 :    *  A couple points on memory allocation for list<Tp>:
     398                 :    *
     399                 :    *  First, we never actually allocate a Tp, we allocate
     400                 :    *  List_node<Tp>'s and trust [20.1.5]/4 to DTRT.  This is to ensure
     401                 :    *  that after elements from %list<X,Alloc1> are spliced into
     402                 :    *  %list<X,Alloc2>, destroying the memory of the second %list is a
     403                 :    *  valid operation, i.e., Alloc1 giveth and Alloc2 taketh away.
     404                 :    *
     405                 :    *  Second, a %list conceptually represented as
     406                 :    *  @code
     407                 :    *    A <---> B <---> C <---> D
     408                 :    *  @endcode
     409                 :    *  is actually circular; a link exists between A and D.  The %list
     410                 :    *  class holds (as its only data member) a private list::iterator
     411                 :    *  pointing to @e D, not to @e A!  To get to the head of the %list,
     412                 :    *  we start at the tail and move forward by one.  When this member
     413                 :    *  iterator's next/previous pointers refer to itself, the %list is
     414                 :    *  %empty. 
     415                 :   */
     416                 :   template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
     417                 :     class list : protected _List_base<_Tp, _Alloc>
     418         1832027 :     {
     419                 :       // concept requirements
     420                 :       typedef typename _Alloc::value_type                _Alloc_value_type;
     421                 :       __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
     422                 :       __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
     423                 : 
     424                 :       typedef _List_base<_Tp, _Alloc>                    _Base;
     425                 :       typedef typename _Base::_Tp_alloc_type             _Tp_alloc_type;
     426                 : 
     427                 :     public:
     428                 :       typedef _Tp                                        value_type;
     429                 :       typedef typename _Tp_alloc_type::pointer           pointer;
     430                 :       typedef typename _Tp_alloc_type::const_pointer     const_pointer;
     431                 :       typedef typename _Tp_alloc_type::reference         reference;
     432                 :       typedef typename _Tp_alloc_type::const_reference   const_reference;
     433                 :       typedef _List_iterator<_Tp>                        iterator;
     434                 :       typedef _List_const_iterator<_Tp>                  const_iterator;
     435                 :       typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;
     436                 :       typedef std::reverse_iterator<iterator>            reverse_iterator;
     437                 :       typedef size_t                                     size_type;
     438                 :       typedef ptrdiff_t                                  difference_type;
     439                 :       typedef _Alloc                                     allocator_type;
     440                 : 
     441                 :     protected:
     442                 :       // Note that pointers-to-_Node's can be ctor-converted to
     443                 :       // iterator types.
     444                 :       typedef _List_node<_Tp>                              _Node;
     445                 : 
     446                 :       using _Base::_M_impl;
     447                 :       using _Base::_M_put_node;
     448                 :       using _Base::_M_get_node;
     449                 :       using _Base::_M_get_Tp_allocator;
     450                 :       using _Base::_M_get_Node_allocator;
     451                 : 
     452                 :       /**
     453                 :        *  @param  x  An instance of user data.
     454                 :        *
     455                 :        *  Allocates space for a new node and constructs a copy of @a x in it.
     456                 :        */
     457                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
     458                 :       _Node*
     459                 :       _M_create_node(const value_type& __x)
     460                 :       {
     461                 :         _Node* __p = this->_M_get_node();
     462                 :         __try
     463                 :           {
     464                 :             _M_get_Tp_allocator().construct(&__p->_M_data, __x);
     465                 :           }
     466                 :         __catch(...)
     467                 :           {
     468                 :             _M_put_node(__p);
     469                 :             __throw_exception_again;
     470                 :           }
     471                 :         return __p;
     472                 :       }
     473                 : #else
     474                 :       template<typename... _Args>
     475                 :         _Node*
     476            1987 :         _M_create_node(_Args&&... __args)
     477                 :         {
     478            1987 :           _Node* __p = this->_M_get_node();
     479                 :           __try
     480                 :             {
     481            1987 :               _M_get_Node_allocator().construct(__p,
     482                 :                                                 std::forward<_Args>(__args)...);
     483                 :             }
     484               0 :           __catch(...)
     485                 :             {
     486               0 :               _M_put_node(__p);
     487               0 :               __throw_exception_again;
     488                 :             }
     489            1987 :           return __p;
     490                 :         }
     491                 : #endif
     492                 : 
     493                 :     public:
     494                 :       // [23.2.2.1] construct/copy/destroy
     495                 :       // (assign() and get_allocator() are also listed in this section)
     496                 :       /**
     497                 :        *  @brief  Default constructor creates no elements.
     498                 :        */
     499            7217 :       list()
     500            7217 :       : _Base() { }
     501                 : 
     502                 :       /**
     503                 :        *  @brief  Creates a %list with no elements.
     504                 :        *  @param  a  An allocator object.
     505                 :        */
     506                 :       explicit
     507                 :       list(const allocator_type& __a)
     508                 :       : _Base(__a) { }
     509                 : 
     510                 :       /**
     511                 :        *  @brief  Creates a %list with copies of an exemplar element.
     512                 :        *  @param  n  The number of elements to initially create.
     513                 :        *  @param  value  An element to copy.
     514                 :        *  @param  a  An allocator object.
     515                 :        *
     516                 :        *  This constructor fills the %list with @a n copies of @a value.
     517                 :        */
     518                 :       explicit
     519                 :       list(size_type __n, const value_type& __value = value_type(),
     520                 :            const allocator_type& __a = allocator_type())
     521                 :       : _Base(__a)
     522                 :       { _M_fill_initialize(__n, __value); }
     523                 : 
     524                 :       /**
     525                 :        *  @brief  %List copy constructor.
     526                 :        *  @param  x  A %list of identical element and allocator types.
     527                 :        *
     528                 :        *  The newly-created %list uses a copy of the allocation object used
     529                 :        *  by @a x.
     530                 :        */
     531                 :       list(const list& __x)
     532                 :       : _Base(__x._M_get_Node_allocator())
     533                 :       { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
     534                 : 
     535                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     536                 :       /**
     537                 :        *  @brief  %List move constructor.
     538                 :        *  @param  x  A %list of identical element and allocator types.
     539                 :        *
     540                 :        *  The newly-created %list contains the exact contents of @a x.
     541                 :        *  The contents of @a x are a valid, but unspecified %list.
     542                 :        */
     543                 :       list(list&& __x)
     544                 :       : _Base(std::forward<_Base>(__x)) { }
     545                 : 
     546                 :       /**
     547                 :        *  @brief  Builds a %list from an initializer_list
     548                 :        *  @param  l  An initializer_list of value_type.
     549                 :        *  @param  a  An allocator object.
     550                 :        *
     551                 :        *  Create a %list consisting of copies of the elements in the
     552                 :        *  initializer_list @a l.  This is linear in l.size().
     553                 :        */
     554                 :       list(initializer_list<value_type> __l,
     555                 :            const allocator_type& __a = allocator_type())
     556                 :       : _Base(__a)
     557                 :       { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); }
     558                 : #endif
     559                 : 
     560                 :       /**
     561                 :        *  @brief  Builds a %list from a range.
     562                 :        *  @param  first  An input iterator.
     563                 :        *  @param  last  An input iterator.
     564                 :        *  @param  a  An allocator object.
     565                 :        *
     566                 :        *  Create a %list consisting of copies of the elements from
     567                 :        *  [@a first,@a last).  This is linear in N (where N is
     568                 :        *  distance(@a first,@a last)).
     569                 :        */
     570                 :       template<typename _InputIterator>
     571                 :         list(_InputIterator __first, _InputIterator __last,
     572                 :              const allocator_type& __a = allocator_type())
     573                 :         : _Base(__a)
     574                 :         { 
     575                 :           // Check whether it's an integral type.  If so, it's not an iterator.
     576                 :           typedef typename std::__is_integer<_InputIterator>::__type _Integral;
     577                 :           _M_initialize_dispatch(__first, __last, _Integral());
     578                 :         }
     579                 : 
     580                 :       /**
     581                 :        *  No explicit dtor needed as the _Base dtor takes care of
     582                 :        *  things.  The _Base dtor only erases the elements, and note
     583                 :        *  that if the elements themselves are pointers, the pointed-to
     584                 :        *  memory is not touched in any way.  Managing the pointer is
     585                 :        *  the user's responsibility.
     586                 :        */
     587                 : 
     588                 :       /**
     589                 :        *  @brief  %List assignment operator.
     590                 :        *  @param  x  A %list of identical element and allocator types.
     591                 :        *
     592                 :        *  All the elements of @a x are copied, but unlike the copy
     593                 :        *  constructor, the allocator object is not copied.
     594                 :        */
     595                 :       list&
     596                 :       operator=(const list& __x);
     597                 : 
     598                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     599                 :       /**
     600                 :        *  @brief  %List move assignment operator.
     601                 :        *  @param  x  A %list of identical element and allocator types.
     602                 :        *
     603                 :        *  The contents of @a x are moved into this %list (without copying).
     604                 :        *  @a x is a valid, but unspecified %list
     605                 :        */
     606                 :       list&
     607                 :       operator=(list&& __x)
     608                 :       {
     609                 :         // NB: DR 1204.
     610                 :         // NB: DR 675.
     611                 :         this->clear();
     612                 :         this->swap(__x);
     613                 :         return *this;
     614                 :       }
     615                 : 
     616                 :       /**
     617                 :        *  @brief  %List initializer list assignment operator.
     618                 :        *  @param  l  An initializer_list of value_type.
     619                 :        *
     620                 :        *  Replace the contents of the %list with copies of the elements
     621                 :        *  in the initializer_list @a l.  This is linear in l.size().
     622                 :        */
     623                 :       list&
     624                 :       operator=(initializer_list<value_type> __l)
     625                 :       {
     626                 :         this->assign(__l.begin(), __l.end());
     627                 :         return *this;
     628                 :       }
     629                 : #endif
     630                 : 
     631                 :       /**
     632                 :        *  @brief  Assigns a given value to a %list.
     633                 :        *  @param  n  Number of elements to be assigned.
     634                 :        *  @param  val  Value to be assigned.
     635                 :        *
     636                 :        *  This function fills a %list with @a n copies of the given
     637                 :        *  value.  Note that the assignment completely changes the %list
     638                 :        *  and that the resulting %list's size is the same as the number
     639                 :        *  of elements assigned.  Old data may be lost.
     640                 :        */
     641                 :       void
     642                 :       assign(size_type __n, const value_type& __val)
     643                 :       { _M_fill_assign(__n, __val); }
     644                 : 
     645                 :       /**
     646                 :        *  @brief  Assigns a range to a %list.
     647                 :        *  @param  first  An input iterator.
     648                 :        *  @param  last   An input iterator.
     649                 :        *
     650                 :        *  This function fills a %list with copies of the elements in the
     651                 :        *  range [@a first,@a last).
     652                 :        *
     653                 :        *  Note that the assignment completely changes the %list and
     654                 :        *  that the resulting %list's size is the same as the number of
     655                 :        *  elements assigned.  Old data may be lost.
     656                 :        */
     657                 :       template<typename _InputIterator>
     658                 :         void
     659                 :         assign(_InputIterator __first, _InputIterator __last)
     660                 :         {
     661                 :           // Check whether it's an integral type.  If so, it's not an iterator.
     662                 :           typedef typename std::__is_integer<_InputIterator>::__type _Integral;
     663                 :           _M_assign_dispatch(__first, __last, _Integral());
     664                 :         }
     665                 : 
     666                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     667                 :       /**
     668                 :        *  @brief  Assigns an initializer_list to a %list.
     669                 :        *  @param  l  An initializer_list of value_type.
     670                 :        *
     671                 :        *  Replace the contents of the %list with copies of the elements
     672                 :        *  in the initializer_list @a l.  This is linear in l.size().
     673                 :        */
     674                 :       void
     675                 :       assign(initializer_list<value_type> __l)
     676                 :       { this->assign(__l.begin(), __l.end()); }
     677                 : #endif
     678                 : 
     679                 :       /// Get a copy of the memory allocation object.
     680                 :       allocator_type
     681                 :       get_allocator() const
     682                 :       { return _Base::get_allocator(); }
     683                 : 
     684                 :       // iterators
     685                 :       /**
     686                 :        *  Returns a read/write iterator that points to the first element in the
     687                 :        *  %list.  Iteration is done in ordinary element order.
     688                 :        */
     689                 :       iterator
     690            5392 :       begin()
     691            5392 :       { return iterator(this->_M_impl._M_node._M_next); }
     692                 : 
     693                 :       /**
     694                 :        *  Returns a read-only (constant) iterator that points to the
     695                 :        *  first element in the %list.  Iteration is done in ordinary
     696                 :        *  element order.
     697                 :        */
     698                 :       const_iterator
     699               0 :       begin() const
     700               0 :       { return const_iterator(this->_M_impl._M_node._M_next); }
     701                 : 
     702                 :       /**
     703                 :        *  Returns a read/write iterator that points one past the last
     704                 :        *  element in the %list.  Iteration is done in ordinary element
     705                 :        *  order.
     706                 :        */
     707                 :       iterator
     708            7071 :       end()
     709            7071 :       { return iterator(&this->_M_impl._M_node); }
     710                 : 
     711                 :       /**
     712                 :        *  Returns a read-only (constant) iterator that points one past
     713                 :        *  the last element in the %list.  Iteration is done in ordinary
     714                 :        *  element order.
     715                 :        */
     716                 :       const_iterator
     717               0 :       end() const
     718               0 :       { return const_iterator(&this->_M_impl._M_node); }
     719                 : 
     720                 :       /**
     721                 :        *  Returns a read/write reverse iterator that points to the last
     722                 :        *  element in the %list.  Iteration is done in reverse element
     723                 :        *  order.
     724                 :        */
     725                 :       reverse_iterator
     726              90 :       rbegin()
     727              90 :       { return reverse_iterator(end()); }
     728                 : 
     729                 :       /**
     730                 :        *  Returns a read-only (constant) reverse iterator that points to
     731                 :        *  the last element in the %list.  Iteration is done in reverse
     732                 :        *  element order.
     733                 :        */
     734                 :       const_reverse_iterator
     735                 :       rbegin() const
     736                 :       { return const_reverse_iterator(end()); }
     737                 : 
     738                 :       /**
     739                 :        *  Returns a read/write reverse iterator that points to one
     740                 :        *  before the first element in the %list.  Iteration is done in
     741                 :        *  reverse element order.
     742                 :        */
     743                 :       reverse_iterator
     744             209 :       rend()
     745             209 :       { return reverse_iterator(begin()); }
     746                 : 
     747                 :       /**
     748                 :        *  Returns a read-only (constant) reverse iterator that points to one
     749                 :        *  before the first element in the %list.  Iteration is done in reverse
     750                 :        *  element order.
     751                 :        */
     752                 :       const_reverse_iterator
     753                 :       rend() const
     754                 :       { return const_reverse_iterator(begin()); }
     755                 : 
     756                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     757                 :       /**
     758                 :        *  Returns a read-only (constant) iterator that points to the
     759                 :        *  first element in the %list.  Iteration is done in ordinary
     760                 :        *  element order.
     761                 :        */
     762                 :       const_iterator
     763                 :       cbegin() const
     764                 :       { return const_iterator(this->_M_impl._M_node._M_next); }
     765                 : 
     766                 :       /**
     767                 :        *  Returns a read-only (constant) iterator that points one past
     768                 :        *  the last element in the %list.  Iteration is done in ordinary
     769                 :        *  element order.
     770                 :        */
     771                 :       const_iterator
     772                 :       cend() const
     773                 :       { return const_iterator(&this->_M_impl._M_node); }
     774                 : 
     775                 :       /**
     776                 :        *  Returns a read-only (constant) reverse iterator that points to
     777                 :        *  the last element in the %list.  Iteration is done in reverse
     778                 :        *  element order.
     779                 :        */
     780                 :       const_reverse_iterator
     781                 :       crbegin() const
     782                 :       { return const_reverse_iterator(end()); }
     783                 : 
     784                 :       /**
     785                 :        *  Returns a read-only (constant) reverse iterator that points to one
     786                 :        *  before the first element in the %list.  Iteration is done in reverse
     787                 :        *  element order.
     788                 :        */
     789                 :       const_reverse_iterator
     790                 :       crend() const
     791                 :       { return const_reverse_iterator(begin()); }
     792                 : #endif
     793                 : 
     794                 :       // [23.2.2.2] capacity
     795                 :       /**
     796                 :        *  Returns true if the %list is empty.  (Thus begin() would equal
     797                 :        *  end().)
     798                 :        */
     799                 :       bool
     800            1826 :       empty() const
     801            1826 :       { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }
     802                 : 
     803                 :       /**  Returns the number of elements in the %list.  */
     804                 :       size_type
     805               0 :       size() const
     806               0 :       { return std::distance(begin(), end()); }
     807                 : 
     808                 :       /**  Returns the size() of the largest possible %list.  */
     809                 :       size_type
     810                 :       max_size() const
     811                 :       { return _M_get_Node_allocator().max_size(); }
     812                 : 
     813                 :       /**
     814                 :        *  @brief Resizes the %list to the specified number of elements.
     815                 :        *  @param new_size Number of elements the %list should contain.
     816                 :        *  @param x Data with which new elements should be populated.
     817                 :        *
     818                 :        *  This function will %resize the %list to the specified number
     819                 :        *  of elements.  If the number is smaller than the %list's
     820                 :        *  current size the %list is truncated, otherwise the %list is
     821                 :        *  extended and new elements are populated with given data.
     822                 :        */
     823                 :       void
     824                 :       resize(size_type __new_size, value_type __x = value_type());
     825                 : 
     826                 :       // element access
     827                 :       /**
     828                 :        *  Returns a read/write reference to the data at the first
     829                 :        *  element of the %list.
     830                 :        */
     831                 :       reference
     832             344 :       front()
     833             344 :       { return *begin(); }
     834                 : 
     835                 :       /**
     836                 :        *  Returns a read-only (constant) reference to the data at the first
     837                 :        *  element of the %list.
     838                 :        */
     839                 :       const_reference
     840                 :       front() const
     841                 :       { return *begin(); }
     842                 : 
     843                 :       /**
     844                 :        *  Returns a read/write reference to the data at the last element
     845                 :        *  of the %list.
     846                 :        */
     847                 :       reference
     848             180 :       back()
     849                 :       { 
     850             180 :         iterator __tmp = end();
     851             180 :         --__tmp;
     852             180 :         return *__tmp;
     853                 :       }
     854                 : 
     855                 :       /**
     856                 :        *  Returns a read-only (constant) reference to the data at the last
     857                 :        *  element of the %list.
     858                 :        */
     859                 :       const_reference
     860                 :       back() const
     861                 :       { 
     862                 :         const_iterator __tmp = end();
     863                 :         --__tmp;
     864                 :         return *__tmp;
     865                 :       }
     866                 : 
     867                 :       // [23.2.2.3] modifiers
     868                 :       /**
     869                 :        *  @brief  Add data to the front of the %list.
     870                 :        *  @param  x  Data to be added.
     871                 :        *
     872                 :        *  This is a typical stack operation.  The function creates an
     873                 :        *  element at the front of the %list and assigns the given data
     874                 :        *  to it.  Due to the nature of a %list this operation can be
     875                 :        *  done in constant time, and does not invalidate iterators and
     876                 :        *  references.
     877                 :        */
     878                 :       void
     879                 :       push_front(const value_type& __x)
     880                 :       { this->_M_insert(begin(), __x); }
     881                 : 
     882                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     883                 :       void
     884                 :       push_front(value_type&& __x)
     885                 :       { this->_M_insert(begin(), std::move(__x)); }
     886                 : 
     887                 :       template<typename... _Args>
     888                 :         void
     889                 :         emplace_front(_Args&&... __args)
     890                 :         { this->_M_insert(begin(), std::forward<_Args>(__args)...); }
     891                 : #endif
     892                 : 
     893                 :       /**
     894                 :        *  @brief  Removes first element.
     895                 :        *
     896                 :        *  This is a typical stack operation.  It shrinks the %list by
     897                 :        *  one.  Due to the nature of a %list this operation can be done
     898                 :        *  in constant time, and only invalidates iterators/references to
     899                 :        *  the element being removed.
     900                 :        *
     901                 :        *  Note that no data is returned, and if the first element's data
     902                 :        *  is needed, it should be retrieved before pop_front() is
     903                 :        *  called.
     904                 :        */
     905                 :       void
     906            1418 :       pop_front()
     907            1418 :       { this->_M_erase(begin()); }
     908                 : 
     909                 :       /**
     910                 :        *  @brief  Add data to the end of the %list.
     911                 :        *  @param  x  Data to be added.
     912                 :        *
     913                 :        *  This is a typical stack operation.  The function creates an
     914                 :        *  element at the end of the %list and assigns the given data to
     915                 :        *  it.  Due to the nature of a %list this operation can be done
     916                 :        *  in constant time, and does not invalidate iterators and
     917                 :        *  references.
     918                 :        */
     919                 :       void
     920            1418 :       push_back(const value_type& __x)
     921            1418 :       { this->_M_insert(end(), __x); }
     922                 : 
     923                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     924                 :       void
     925               0 :       push_back(value_type&& __x)
     926               0 :       { this->_M_insert(end(), std::move(__x)); }
     927                 : 
     928                 :       template<typename... _Args>
     929                 :         void
     930                 :         emplace_back(_Args&&... __args)
     931                 :         { this->_M_insert(end(), std::forward<_Args>(__args)...); }
     932                 : #endif
     933                 : 
     934                 :       /**
     935                 :        *  @brief  Removes last element.
     936                 :        *
     937                 :        *  This is a typical stack operation.  It shrinks the %list by
     938                 :        *  one.  Due to the nature of a %list this operation can be done
     939                 :        *  in constant time, and only invalidates iterators/references to
     940                 :        *  the element being removed.
     941                 :        *
     942                 :        *  Note that no data is returned, and if the last element's data
     943                 :        *  is needed, it should be retrieved before pop_back() is called.
     944                 :        */
     945                 :       void
     946                 :       pop_back()
     947                 :       { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
     948                 : 
     949                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     950                 :       /**
     951                 :        *  @brief  Constructs object in %list before specified iterator.
     952                 :        *  @param  position  A const_iterator into the %list.
     953                 :        *  @param  args  Arguments.
     954                 :        *  @return  An iterator that points to the inserted data.
     955                 :        *
     956                 :        *  This function will insert an object of type T constructed
     957                 :        *  with T(std::forward<Args>(args)...) before the specified
     958                 :        *  location.  Due to the nature of a %list this operation can
     959                 :        *  be done in constant time, and does not invalidate iterators
     960                 :        *  and references.
     961                 :        */
     962                 :       template<typename... _Args>
     963                 :         iterator
     964                 :         emplace(iterator __position, _Args&&... __args);
     965                 : #endif
     966                 : 
     967                 :       /**
     968                 :        *  @brief  Inserts given value into %list before specified iterator.
     969                 :        *  @param  position  An iterator into the %list.
     970                 :        *  @param  x  Data to be inserted.
     971                 :        *  @return  An iterator that points to the inserted data.
     972                 :        *
     973                 :        *  This function will insert a copy of the given value before
     974                 :        *  the specified location.  Due to the nature of a %list this
     975                 :        *  operation can be done in constant time, and does not
     976                 :        *  invalidate iterators and references.
     977                 :        */
     978                 :       iterator
     979                 :       insert(iterator __position, const value_type& __x);
     980                 : 
     981                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     982                 :       /**
     983                 :        *  @brief  Inserts given rvalue into %list before specified iterator.
     984                 :        *  @param  position  An iterator into the %list.
     985                 :        *  @param  x  Data to be inserted.
     986                 :        *  @return  An iterator that points to the inserted data.
     987                 :        *
     988                 :        *  This function will insert a copy of the given rvalue before
     989                 :        *  the specified location.  Due to the nature of a %list this
     990                 :        *  operation can be done in constant time, and does not
     991                 :        *  invalidate iterators and references.
     992                 :         */
     993                 :       iterator
     994                 :       insert(iterator __position, value_type&& __x)
     995                 :       { return emplace(__position, std::move(__x)); }
     996                 : 
     997                 :       /**
     998                 :        *  @brief  Inserts the contents of an initializer_list into %list
     999                 :        *          before specified iterator.
    1000                 :        *  @param  p  An iterator into the %list.
    1001                 :        *  @param  l  An initializer_list of value_type.
    1002                 :        *
    1003                 :        *  This function will insert copies of the data in the
    1004                 :        *  initializer_list @a l into the %list before the location
    1005                 :        *  specified by @a p.
    1006                 :        *
    1007                 :        *  This operation is linear in the number of elements inserted and
    1008                 :        *  does not invalidate iterators and references.
    1009                 :        */
    1010                 :       void
    1011                 :       insert(iterator __p, initializer_list<value_type> __l)
    1012                 :       { this->insert(__p, __l.begin(), __l.end()); }
    1013                 : #endif
    1014                 : 
    1015                 :       /**
    1016                 :        *  @brief  Inserts a number of copies of given data into the %list.
    1017                 :        *  @param  position  An iterator into the %list.
    1018                 :        *  @param  n  Number of elements to be inserted.
    1019                 :        *  @param  x  Data to be inserted.
    1020                 :        *
    1021                 :        *  This function will insert a specified number of copies of the
    1022                 :        *  given data before the location specified by @a position.
    1023                 :        *
    1024                 :        *  This operation is linear in the number of elements inserted and
    1025                 :        *  does not invalidate iterators and references.
    1026                 :        */
    1027                 :       void
    1028                 :       insert(iterator __position, size_type __n, const value_type& __x)
    1029                 :       {  
    1030                 :         list __tmp(__n, __x, _M_get_Node_allocator());
    1031                 :         splice(__position, __tmp);
    1032                 :       }
    1033                 : 
    1034                 :       /**
    1035                 :        *  @brief  Inserts a range into the %list.
    1036                 :        *  @param  position  An iterator into the %list.
    1037                 :        *  @param  first  An input iterator.
    1038                 :        *  @param  last   An input iterator.
    1039                 :        *
    1040                 :        *  This function will insert copies of the data in the range [@a
    1041                 :        *  first,@a last) into the %list before the location specified by
    1042                 :        *  @a position.
    1043                 :        *
    1044                 :        *  This operation is linear in the number of elements inserted and
    1045                 :        *  does not invalidate iterators and references.
    1046                 :        */
    1047                 :       template<typename _InputIterator>
    1048                 :         void
    1049                 :         insert(iterator __position, _InputIterator __first,
    1050                 :                _InputIterator __last)
    1051                 :         {
    1052                 :           list __tmp(__first, __last, _M_get_Node_allocator());
    1053                 :           splice(__position, __tmp);
    1054                 :         }
    1055                 : 
    1056                 :       /**
    1057                 :        *  @brief  Remove element at given position.
    1058                 :        *  @param  position  Iterator pointing to element to be erased.
    1059                 :        *  @return  An iterator pointing to the next element (or end()).
    1060                 :        *
    1061                 :        *  This function will erase the element at the given position and thus
    1062                 :        *  shorten the %list by one.
    1063                 :        *
    1064                 :        *  Due to the nature of a %list this operation can be done in
    1065                 :        *  constant time, and only invalidates iterators/references to
    1066                 :        *  the element being removed.  The user is also cautioned that
    1067                 :        *  this function only erases the element, and that if the element
    1068                 :        *  is itself a pointer, the pointed-to memory is not touched in
    1069                 :        *  any way.  Managing the pointer is the user's responsibility.
    1070                 :        */
    1071                 :       iterator
    1072                 :       erase(iterator __position);
    1073                 : 
    1074                 :       /**
    1075                 :        *  @brief  Remove a range of elements.
    1076                 :        *  @param  first  Iterator pointing to the first element to be erased.
    1077                 :        *  @param  last  Iterator pointing to one past the last element to be
    1078                 :        *                erased.
    1079                 :        *  @return  An iterator pointing to the element pointed to by @a last
    1080                 :        *           prior to erasing (or end()).
    1081                 :        *
    1082                 :        *  This function will erase the elements in the range @a
    1083                 :        *  [first,last) and shorten the %list accordingly.
    1084                 :        *
    1085                 :        *  This operation is linear time in the size of the range and only
    1086                 :        *  invalidates iterators/references to the element being removed.
    1087                 :        *  The user is also cautioned that this function only erases the
    1088                 :        *  elements, and that if the elements themselves are pointers, the
    1089                 :        *  pointed-to memory is not touched in any way.  Managing the pointer
    1090                 :        *  is the user's responsibility.
    1091                 :        */
    1092                 :       iterator
    1093               4 :       erase(iterator __first, iterator __last)
    1094                 :       {
    1095              36 :         while (__first != __last)
    1096              28 :           __first = erase(__first);
    1097               4 :         return __last;
    1098                 :       }
    1099                 : 
    1100                 :       /**
    1101                 :        *  @brief  Swaps data with another %list.
    1102                 :        *  @param  x  A %list of the same element and allocator types.
    1103                 :        *
    1104                 :        *  This exchanges the elements between two lists in constant
    1105                 :        *  time.  Note that the global std::swap() function is
    1106                 :        *  specialized such that std::swap(l1,l2) will feed to this
    1107                 :        *  function.
    1108                 :        */
    1109                 :       void
    1110               0 :       swap(list& __x)
    1111                 :       {
    1112               0 :         _List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node);
    1113                 : 
    1114                 :         // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1115                 :         // 431. Swapping containers with unequal allocators.
    1116               0 :         std::__alloc_swap<typename _Base::_Node_alloc_type>::
    1117                 :           _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator());
    1118               0 :       }
    1119                 : 
    1120                 :       /**
    1121                 :        *  Erases all the elements.  Note that this function only erases
    1122                 :        *  the elements, and that if the elements themselves are
    1123                 :        *  pointers, the pointed-to memory is not touched in any way.
    1124                 :        *  Managing the pointer is the user's responsibility.
    1125                 :        */
    1126                 :       void
    1127               0 :       clear()
    1128                 :       {
    1129               0 :         _Base::_M_clear();
    1130               0 :         _Base::_M_init();
    1131               0 :       }
    1132                 : 
    1133                 :       // [23.2.2.4] list operations
    1134                 :       /**
    1135                 :        *  @brief  Insert contents of another %list.
    1136                 :        *  @param  position  Iterator referencing the element to insert before.
    1137                 :        *  @param  x  Source list.
    1138                 :        *
    1139                 :        *  The elements of @a x are inserted in constant time in front of
    1140                 :        *  the element referenced by @a position.  @a x becomes an empty
    1141                 :        *  list.
    1142                 :        *
    1143                 :        *  Requires this != @a x.
    1144                 :        */
    1145                 :       void
    1146                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1147                 :       splice(iterator __position, list&& __x)
    1148                 : #else
    1149                 :       splice(iterator __position, list& __x)
    1150                 : #endif
    1151                 :       {
    1152                 :         if (!__x.empty())
    1153                 :           {
    1154                 :             _M_check_equal_allocators(__x);
    1155                 : 
    1156                 :             this->_M_transfer(__position, __x.begin(), __x.end());
    1157                 :           }
    1158                 :       }
    1159                 : 
    1160                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1161                 :       void
    1162                 :       splice(iterator __position, list& __x)
    1163                 :       { splice(__position, std::move(__x)); }
    1164                 : #endif
    1165                 : 
    1166                 :       /**
    1167                 :        *  @brief  Insert element from another %list.
    1168                 :        *  @param  position  Iterator referencing the element to insert before.
    1169                 :        *  @param  x  Source list.
    1170                 :        *  @param  i  Iterator referencing the element to move.
    1171                 :        *
    1172                 :        *  Removes the element in list @a x referenced by @a i and
    1173                 :        *  inserts it into the current list before @a position.
    1174                 :        */
    1175                 :       void
    1176                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1177               0 :       splice(iterator __position, list&& __x, iterator __i)
    1178                 : #else
    1179                 :       splice(iterator __position, list& __x, iterator __i)
    1180                 : #endif
    1181                 :       {
    1182               0 :         iterator __j = __i;
    1183               0 :         ++__j;
    1184               0 :         if (__position == __i || __position == __j)
    1185               0 :           return;
    1186                 : 
    1187               0 :         if (this != &__x)
    1188               0 :           _M_check_equal_allocators(__x);
    1189                 : 
    1190               0 :         this->_M_transfer(__position, __i, __j);
    1191                 :       }
    1192                 : 
    1193                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1194                 :       void
    1195               0 :       splice(iterator __position, list& __x, iterator __i)
    1196               0 :       { splice(__position, std::move(__x), __i); }
    1197                 : #endif
    1198                 : 
    1199                 :       /**
    1200                 :        *  @brief  Insert range from another %list.
    1201                 :        *  @param  position  Iterator referencing the element to insert before.
    1202                 :        *  @param  x  Source list.
    1203                 :        *  @param  first  Iterator referencing the start of range in x.
    1204                 :        *  @param  last  Iterator referencing the end of range in x.
    1205                 :        *
    1206                 :        *  Removes elements in the range [first,last) and inserts them
    1207                 :        *  before @a position in constant time.
    1208                 :        *
    1209                 :        *  Undefined if @a position is in [first,last).
    1210                 :        */
    1211                 :       void
    1212                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1213                 :       splice(iterator __position, list&& __x, iterator __first,
    1214                 :              iterator __last)
    1215                 : #else
    1216                 :       splice(iterator __position, list& __x, iterator __first,
    1217                 :              iterator __last)
    1218                 : #endif
    1219                 :       {
    1220                 :         if (__first != __last)
    1221                 :           {
    1222                 :             if (this != &__x)
    1223                 :               _M_check_equal_allocators(__x);
    1224                 : 
    1225                 :             this->_M_transfer(__position, __first, __last);
    1226                 :           }
    1227                 :       }
    1228                 : 
    1229                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1230                 :       void
    1231                 :       splice(iterator __position, list& __x, iterator __first, iterator __last)
    1232                 :       { splice(__position, std::move(__x), __first, __last); }
    1233                 : #endif
    1234                 : 
    1235                 :       /**
    1236                 :        *  @brief  Remove all elements equal to value.
    1237                 :        *  @param  value  The value to remove.
    1238                 :        *
    1239                 :        *  Removes every element in the list equal to @a value.
    1240                 :        *  Remaining elements stay in list order.  Note that this
    1241                 :        *  function only erases the elements, and that if the elements
    1242                 :        *  themselves are pointers, the pointed-to memory is not
    1243                 :        *  touched in any way.  Managing the pointer is the user's
    1244                 :        *  responsibility.
    1245                 :        */
    1246                 :       void
    1247                 :       remove(const _Tp& __value);
    1248                 : 
    1249                 :       /**
    1250                 :        *  @brief  Remove all elements satisfying a predicate.
    1251                 :        *  @param  Predicate  Unary predicate function or object.
    1252                 :        *
    1253                 :        *  Removes every element in the list for which the predicate
    1254                 :        *  returns true.  Remaining elements stay in list order.  Note
    1255                 :        *  that this function only erases the elements, and that if the
    1256                 :        *  elements themselves are pointers, the pointed-to memory is
    1257                 :        *  not touched in any way.  Managing the pointer is the user's
    1258                 :        *  responsibility.
    1259                 :        */
    1260                 :       template<typename _Predicate>
    1261                 :         void
    1262                 :         remove_if(_Predicate);
    1263                 : 
    1264                 :       /**
    1265                 :        *  @brief  Remove consecutive duplicate elements.
    1266                 :        *
    1267                 :        *  For each consecutive set of elements with the same value,
    1268                 :        *  remove all but the first one.  Remaining elements stay in
    1269                 :        *  list order.  Note that this function only erases the
    1270                 :        *  elements, and that if the elements themselves are pointers,
    1271                 :        *  the pointed-to memory is not touched in any way.  Managing
    1272                 :        *  the pointer is the user's responsibility.
    1273                 :        */
    1274                 :       void
    1275                 :       unique();
    1276                 : 
    1277                 :       /**
    1278                 :        *  @brief  Remove consecutive elements satisfying a predicate.
    1279                 :        *  @param  BinaryPredicate  Binary predicate function or object.
    1280                 :        *
    1281                 :        *  For each consecutive set of elements [first,last) that
    1282                 :        *  satisfy predicate(first,i) where i is an iterator in
    1283                 :        *  [first,last), remove all but the first one.  Remaining
    1284                 :        *  elements stay in list order.  Note that this function only
    1285                 :        *  erases the elements, and that if the elements themselves are
    1286                 :        *  pointers, the pointed-to memory is not touched in any way.
    1287                 :        *  Managing the pointer is the user's responsibility.
    1288                 :        */
    1289                 :       template<typename _BinaryPredicate>
    1290                 :         void
    1291                 :         unique(_BinaryPredicate);
    1292                 : 
    1293                 :       /**
    1294                 :        *  @brief  Merge sorted lists.
    1295                 :        *  @param  x  Sorted list to merge.
    1296                 :        *
    1297                 :        *  Assumes that both @a x and this list are sorted according to
    1298                 :        *  operator<().  Merges elements of @a x into this list in
    1299                 :        *  sorted order, leaving @a x empty when complete.  Elements in
    1300                 :        *  this list precede elements in @a x that are equal.
    1301                 :        */
    1302                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1303                 :       void
    1304                 :       merge(list&& __x);
    1305                 : 
    1306                 :       void
    1307               0 :       merge(list& __x)
    1308               0 :       { merge(std::move(__x)); }
    1309                 : #else
    1310                 :       void
    1311                 :       merge(list& __x);
    1312                 : #endif
    1313                 : 
    1314                 :       /**
    1315                 :        *  @brief  Merge sorted lists according to comparison function.
    1316                 :        *  @param  x  Sorted list to merge.
    1317                 :        *  @param StrictWeakOrdering Comparison function defining
    1318                 :        *  sort order.
    1319                 :        *
    1320                 :        *  Assumes that both @a x and this list are sorted according to
    1321                 :        *  StrictWeakOrdering.  Merges elements of @a x into this list
    1322                 :        *  in sorted order, leaving @a x empty when complete.  Elements
    1323                 :        *  in this list precede elements in @a x that are equivalent
    1324                 :        *  according to StrictWeakOrdering().
    1325                 :        */
    1326                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1327                 :       template<typename _StrictWeakOrdering>
    1328                 :         void
    1329                 :         merge(list&&, _StrictWeakOrdering);
    1330                 : 
    1331                 :       template<typename _StrictWeakOrdering>
    1332                 :         void
    1333                 :         merge(list& __x, _StrictWeakOrdering __comp)
    1334                 :         { merge(std::move(__x), __comp); }
    1335                 : #else
    1336                 :       template<typename _StrictWeakOrdering>
    1337                 :         void
    1338                 :         merge(list&, _StrictWeakOrdering);
    1339                 : #endif
    1340                 : 
    1341                 :       /**
    1342                 :        *  @brief  Reverse the elements in list.
    1343                 :        *
    1344                 :        *  Reverse the order of elements in the list in linear time.
    1345                 :        */
    1346                 :       void
    1347                 :       reverse()
    1348                 :       { this->_M_impl._M_node._M_reverse(); }
    1349                 : 
    1350                 :       /**
    1351                 :        *  @brief  Sort the elements.
    1352                 :        *
    1353                 :        *  Sorts the elements of this list in NlogN time.  Equivalent
    1354                 :        *  elements remain in list order.
    1355                 :        */
    1356                 :       void
    1357                 :       sort();
    1358                 : 
    1359                 :       /**
    1360                 :        *  @brief  Sort the elements according to comparison function.
    1361                 :        *
    1362                 :        *  Sorts the elements of this list in NlogN time.  Equivalent
    1363                 :        *  elements remain in list order.
    1364                 :        */
    1365                 :       template<typename _StrictWeakOrdering>
    1366                 :         void
    1367                 :         sort(_StrictWeakOrdering);
    1368                 : 
    1369                 :     protected:
    1370                 :       // Internal constructor functions follow.
    1371                 : 
    1372                 :       // Called by the range constructor to implement [23.1.1]/9
    1373                 : 
    1374                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1375                 :       // 438. Ambiguity in the "do the right thing" clause
    1376                 :       template<typename _Integer>
    1377                 :         void
    1378                 :         _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
    1379                 :         { _M_fill_initialize(static_cast<size_type>(__n), __x); }
    1380                 : 
    1381                 :       // Called by the range constructor to implement [23.1.1]/9
    1382                 :       template<typename _InputIterator>
    1383                 :         void
    1384                 :         _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
    1385                 :                                __false_type)
    1386                 :         {
    1387                 :           for (; __first != __last; ++__first)
    1388                 :             push_back(*__first);
    1389                 :         }
    1390                 : 
    1391                 :       // Called by list(n,v,a), and the range constructor when it turns out
    1392                 :       // to be the same thing.
    1393                 :       void
    1394                 :       _M_fill_initialize(size_type __n, const value_type& __x)
    1395                 :       {
    1396                 :         for (; __n > 0; --__n)
    1397                 :           push_back(__x);
    1398                 :       }
    1399                 : 
    1400                 : 
    1401                 :       // Internal assign functions follow.
    1402                 : 
    1403                 :       // Called by the range assign to implement [23.1.1]/9
    1404                 : 
    1405                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1406                 :       // 438. Ambiguity in the "do the right thing" clause
    1407                 :       template<typename _Integer>
    1408                 :         void
    1409                 :         _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
    1410                 :         { _M_fill_assign(__n, __val); }
    1411                 : 
    1412                 :       // Called by the range assign to implement [23.1.1]/9
    1413                 :       template<typename _InputIterator>
    1414                 :         void
    1415                 :         _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
    1416                 :                            __false_type);
    1417                 : 
    1418                 :       // Called by assign(n,t), and the range assign when it turns out
    1419                 :       // to be the same thing.
    1420                 :       void
    1421                 :       _M_fill_assign(size_type __n, const value_type& __val);
    1422                 : 
    1423                 : 
    1424                 :       // Moves the elements from [first,last) before position.
    1425                 :       void
    1426               0 :       _M_transfer(iterator __position, iterator __first, iterator __last)
    1427               0 :       { __position._M_node->_M_transfer(__first._M_node, __last._M_node); }
    1428                 : 
    1429                 :       // Inserts new element at position given and with value given.
    1430                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
    1431                 :       void
    1432                 :       _M_insert(iterator __position, const value_type& __x)
    1433                 :       {
    1434                 :         _Node* __tmp = _M_create_node(__x);
    1435                 :         __tmp->_M_hook(__position._M_node);
    1436                 :       }
    1437                 : #else
    1438                 :      template<typename... _Args>
    1439                 :        void
    1440            1418 :        _M_insert(iterator __position, _Args&&... __args)
    1441                 :        {
    1442            1418 :          _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
    1443            1418 :          __tmp->_M_hook(__position._M_node);
    1444            1418 :        }
    1445                 : #endif
    1446                 : 
    1447                 :       // Erases element at position given.
    1448                 :       void
    1449            1446 :       _M_erase(iterator __position)
    1450                 :       {
    1451            1446 :         __position._M_node->_M_unhook();
    1452            1446 :         _Node* __n = static_cast<_Node*>(__position._M_node);
    1453                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    1454            1446 :         _M_get_Node_allocator().destroy(__n);
    1455                 : #else
    1456                 :         _M_get_Tp_allocator().destroy(&__n->_M_data);
    1457                 : #endif
    1458            1446 :         _M_put_node(__n);
    1459            1446 :       }
    1460                 : 
    1461                 :       // To implement the splice (and merge) bits of N1599.
    1462                 :       void
    1463               0 :       _M_check_equal_allocators(list& __x)
    1464                 :       {
    1465               0 :         if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
    1466                 :             _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
    1467               0 :           __throw_runtime_error(__N("list::_M_check_equal_allocators"));
    1468               0 :       }
    1469                 :     };
    1470                 : 
    1471                 :   /**
    1472                 :    *  @brief  List equality comparison.
    1473                 :    *  @param  x  A %list.
    1474                 :    *  @param  y  A %list of the same type as @a x.
    1475                 :    *  @return  True iff the size and elements of the lists are equal.
    1476                 :    *
    1477                 :    *  This is an equivalence relation.  It is linear in the size of
    1478                 :    *  the lists.  Lists are considered equivalent if their sizes are
    1479                 :    *  equal, and if corresponding elements compare equal.
    1480                 :   */
    1481                 :   template<typename _Tp, typename _Alloc>
    1482                 :     inline bool
    1483                 :     operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    1484                 :     {
    1485                 :       typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
    1486                 :       const_iterator __end1 = __x.end();
    1487                 :       const_iterator __end2 = __y.end();
    1488                 : 
    1489                 :       const_iterator __i1 = __x.begin();
    1490                 :       const_iterator __i2 = __y.begin();
    1491                 :       while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
    1492                 :         {
    1493                 :           ++__i1;
    1494                 :           ++__i2;
    1495                 :         }
    1496                 :       return __i1 == __end1 && __i2 == __end2;
    1497                 :     }
    1498                 : 
    1499                 :   /**
    1500                 :    *  @brief  List ordering relation.
    1501                 :    *  @param  x  A %list.
    1502                 :    *  @param  y  A %list of the same type as @a x.
    1503                 :    *  @return  True iff @a x is lexicographically less than @a y.
    1504                 :    *
    1505                 :    *  This is a total ordering relation.  It is linear in the size of the
    1506                 :    *  lists.  The elements must be comparable with @c <.
    1507                 :    *
    1508                 :    *  See std::lexicographical_compare() for how the determination is made.
    1509                 :   */
    1510                 :   template<typename _Tp, typename _Alloc>
    1511                 :     inline bool
    1512                 :     operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    1513                 :     { return std::lexicographical_compare(__x.begin(), __x.end(),
    1514                 :                                           __y.begin(), __y.end()); }
    1515                 : 
    1516                 :   /// Based on operator==
    1517                 :   template<typename _Tp, typename _Alloc>
    1518                 :     inline bool
    1519                 :     operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    1520                 :     { return !(__x == __y); }
    1521                 : 
    1522                 :   /// Based on operator<
    1523                 :   template<typename _Tp, typename _Alloc>
    1524                 :     inline bool
    1525                 :     operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    1526                 :     { return __y < __x; }
    1527                 : 
    1528                 :   /// Based on operator<
    1529                 :   template<typename _Tp, typename _Alloc>
    1530                 :     inline bool
    1531                 :     operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    1532                 :     { return !(__y < __x); }
    1533                 : 
    1534                 :   /// Based on operator<
    1535                 :   template<typename _Tp, typename _Alloc>
    1536                 :     inline bool
    1537                 :     operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    1538                 :     { return !(__x < __y); }
    1539                 : 
    1540                 :   /// See std::list::swap().
    1541                 :   template<typename _Tp, typename _Alloc>
    1542                 :     inline void
    1543                 :     swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
    1544                 :     { __x.swap(__y); }
    1545                 : 
    1546                 : _GLIBCXX_END_NESTED_NAMESPACE
    1547                 : 
    1548                 : #endif /* _STL_LIST_H */

Generated by: LCOV version 1.7