LCOV - lcov.info - /usr/include/c++/4.3/bits/stl_list.h

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

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

Generated by: LTP GCOV extension version 1.6