LCOV - code coverage report
Current view: directory - tools/gcc-4.5/include/c++/4.5.2/bits - stl_iterator.h (source / functions) Found Hit Coverage
Test: app.info Lines: 87 61 70.1 %
Date: 2012-06-02 Functions: 1317 255 19.4 %

       1                 : // Iterators -*- C++ -*-
       2                 : 
       3                 : // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
       4                 : // Free Software Foundation, Inc.
       5                 : //
       6                 : // This file is part of the GNU ISO C++ Library.  This library is free
       7                 : // software; you can redistribute it and/or modify it under the
       8                 : // terms of the GNU General Public License as published by the
       9                 : // Free Software Foundation; either version 3, or (at your option)
      10                 : // any later version.
      11                 : 
      12                 : // This library is distributed in the hope that it will be useful,
      13                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 : // GNU General Public License for more details.
      16                 : 
      17                 : // Under Section 7 of GPL version 3, you are granted additional
      18                 : // permissions described in the GCC Runtime Library Exception, version
      19                 : // 3.1, as published by the Free Software Foundation.
      20                 : 
      21                 : // You should have received a copy of the GNU General Public License and
      22                 : // a copy of the GCC Runtime Library Exception along with this program;
      23                 : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      24                 : // <http://www.gnu.org/licenses/>.
      25                 : 
      26                 : /*
      27                 :  *
      28                 :  * Copyright (c) 1994
      29                 :  * Hewlett-Packard Company
      30                 :  *
      31                 :  * Permission to use, copy, modify, distribute and sell this software
      32                 :  * and its documentation for any purpose is hereby granted without fee,
      33                 :  * provided that the above copyright notice appear in all copies and
      34                 :  * that both that copyright notice and this permission notice appear
      35                 :  * in supporting documentation.  Hewlett-Packard Company makes no
      36                 :  * representations about the suitability of this software for any
      37                 :  * purpose.  It is provided "as is" without express or implied warranty.
      38                 :  *
      39                 :  *
      40                 :  * Copyright (c) 1996-1998
      41                 :  * Silicon Graphics Computer Systems, Inc.
      42                 :  *
      43                 :  * Permission to use, copy, modify, distribute and sell this software
      44                 :  * and its documentation for any purpose is hereby granted without fee,
      45                 :  * provided that the above copyright notice appear in all copies and
      46                 :  * that both that copyright notice and this permission notice appear
      47                 :  * in supporting documentation.  Silicon Graphics makes no
      48                 :  * representations about the suitability of this software for any
      49                 :  * purpose.  It is provided "as is" without express or implied warranty.
      50                 :  */
      51                 : 
      52                 : /** @file stl_iterator.h
      53                 :  *  This is an internal header file, included by other library headers.
      54                 :  *  You should not attempt to use it directly.
      55                 :  *
      56                 :  *  This file implements reverse_iterator, back_insert_iterator,
      57                 :  *  front_insert_iterator, insert_iterator, __normal_iterator, and their
      58                 :  *  supporting functions and overloaded operators.
      59                 :  */
      60                 : 
      61                 : #ifndef _STL_ITERATOR_H
      62                 : #define _STL_ITERATOR_H 1
      63                 : 
      64                 : #include <bits/cpp_type_traits.h>
      65                 : #include <ext/type_traits.h>
      66                 : #include <bits/move.h>
      67                 : 
      68                 : _GLIBCXX_BEGIN_NAMESPACE(std)
      69                 : 
      70                 :   /**
      71                 :    * @addtogroup iterators
      72                 :    * @{
      73                 :    */
      74                 : 
      75                 :   // 24.4.1 Reverse iterators
      76                 :   /**
      77                 :    *  Bidirectional and random access iterators have corresponding reverse
      78                 :    *  %iterator adaptors that iterate through the data structure in the
      79                 :    *  opposite direction.  They have the same signatures as the corresponding
      80                 :    *  iterators.  The fundamental relation between a reverse %iterator and its
      81                 :    *  corresponding %iterator @c i is established by the identity:
      82                 :    *  @code
      83                 :    *      &*(reverse_iterator(i)) == &*(i - 1)
      84                 :    *  @endcode
      85                 :    *
      86                 :    *  <em>This mapping is dictated by the fact that while there is always a
      87                 :    *  pointer past the end of an array, there might not be a valid pointer
      88                 :    *  before the beginning of an array.</em> [24.4.1]/1,2
      89                 :    *
      90                 :    *  Reverse iterators can be tricky and surprising at first.  Their
      91                 :    *  semantics make sense, however, and the trickiness is a side effect of
      92                 :    *  the requirement that the iterators must be safe.
      93                 :   */
      94                 :   template<typename _Iterator>
      95                 :     class reverse_iterator
      96                 :     : public iterator<typename iterator_traits<_Iterator>::iterator_category,
      97                 :                       typename iterator_traits<_Iterator>::value_type,
      98                 :                       typename iterator_traits<_Iterator>::difference_type,
      99                 :                       typename iterator_traits<_Iterator>::pointer,
     100                 :                       typename iterator_traits<_Iterator>::reference>
     101                 :     {
     102                 :     protected:
     103                 :       _Iterator current;
     104                 : 
     105                 :       typedef iterator_traits<_Iterator>          __traits_type;
     106                 : 
     107                 :     public:
     108                 :       typedef _Iterator                                 iterator_type;
     109                 :       typedef typename __traits_type::difference_type   difference_type;
     110                 :       typedef typename __traits_type::pointer           pointer;
     111                 :       typedef typename __traits_type::reference         reference;
     112                 : 
     113                 :       /**
     114                 :        *  The default constructor default-initializes member @p current.
     115                 :        *  If it is a pointer, that means it is zero-initialized.
     116                 :       */
     117                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
     118                 :       // 235 No specification of default ctor for reverse_iterator
     119              90 :       reverse_iterator() : current() { }
     120                 : 
     121                 :       /**
     122                 :        *  This %iterator will move in the opposite direction that @p x does.
     123                 :       */
     124                 :       explicit
     125             299 :       reverse_iterator(iterator_type __x) : current(__x) { }
     126                 : 
     127                 :       /**
     128                 :        *  The copy constructor is normal.
     129                 :       */
     130               0 :       reverse_iterator(const reverse_iterator& __x)
     131               0 :       : current(__x.current) { }
     132                 : 
     133                 :       /**
     134                 :        *  A reverse_iterator across other types can be copied in the normal
     135                 :        *  fashion.
     136                 :       */
     137                 :       template<typename _Iter>
     138                 :         reverse_iterator(const reverse_iterator<_Iter>& __x)
     139                 :         : current(__x.base()) { }
     140                 : 
     141                 :       /**
     142                 :        *  @return  @c current, the %iterator used for underlying work.
     143                 :       */
     144                 :       iterator_type
     145             418 :       base() const
     146             418 :       { return current; }
     147                 : 
     148                 :       /**
     149                 :        *  @return  TODO
     150                 :        *
     151                 :        *  @doctodo
     152                 :       */
     153                 :       reference
     154             287 :       operator*() const
     155                 :       {
     156             287 :         _Iterator __tmp = current;
     157             287 :         return *--__tmp;
     158                 :       }
     159                 : 
     160                 :       /**
     161                 :        *  @return  TODO
     162                 :        *
     163                 :        *  @doctodo
     164                 :       */
     165                 :       pointer
     166               0 :       operator->() const
     167               0 :       { return &(operator*()); }
     168                 : 
     169                 :       /**
     170                 :        *  @return  TODO
     171                 :        *
     172                 :        *  @doctodo
     173                 :       */
     174                 :       reverse_iterator&
     175              29 :       operator++()
     176                 :       {
     177              29 :         --current;
     178              29 :         return *this;
     179                 :       }
     180                 : 
     181                 :       /**
     182                 :        *  @return  TODO
     183                 :        *
     184                 :        *  @doctodo
     185                 :       */
     186                 :       reverse_iterator
     187               0 :       operator++(int)
     188                 :       {
     189               0 :         reverse_iterator __tmp = *this;
     190               0 :         --current;
     191                 :         return __tmp;
     192                 :       }
     193                 : 
     194                 :       /**
     195                 :        *  @return  TODO
     196                 :        *
     197                 :        *  @doctodo
     198                 :       */
     199                 :       reverse_iterator&
     200                 :       operator--()
     201                 :       {
     202                 :         ++current;
     203                 :         return *this;
     204                 :       }
     205                 : 
     206                 :       /**
     207                 :        *  @return  TODO
     208                 :        *
     209                 :        *  @doctodo
     210                 :       */
     211                 :       reverse_iterator
     212                 :       operator--(int)
     213                 :       {
     214                 :         reverse_iterator __tmp = *this;
     215                 :         ++current;
     216                 :         return __tmp;
     217                 :       }
     218                 : 
     219                 :       /**
     220                 :        *  @return  TODO
     221                 :        *
     222                 :        *  @doctodo
     223                 :       */
     224                 :       reverse_iterator
     225                 :       operator+(difference_type __n) const
     226                 :       { return reverse_iterator(current - __n); }
     227                 : 
     228                 :       /**
     229                 :        *  @return  TODO
     230                 :        *
     231                 :        *  @doctodo
     232                 :       */
     233                 :       reverse_iterator&
     234                 :       operator+=(difference_type __n)
     235                 :       {
     236                 :         current -= __n;
     237                 :         return *this;
     238                 :       }
     239                 : 
     240                 :       /**
     241                 :        *  @return  TODO
     242                 :        *
     243                 :        *  @doctodo
     244                 :       */
     245                 :       reverse_iterator
     246                 :       operator-(difference_type __n) const
     247                 :       { return reverse_iterator(current + __n); }
     248                 : 
     249                 :       /**
     250                 :        *  @return  TODO
     251                 :        *
     252                 :        *  @doctodo
     253                 :       */
     254                 :       reverse_iterator&
     255                 :       operator-=(difference_type __n)
     256                 :       {
     257                 :         current += __n;
     258                 :         return *this;
     259                 :       }
     260                 : 
     261                 :       /**
     262                 :        *  @return  TODO
     263                 :        *
     264                 :        *  @doctodo
     265                 :       */
     266                 :       reference
     267                 :       operator[](difference_type __n) const
     268                 :       { return *(*this + __n); }
     269                 :     };
     270                 : 
     271                 :   //@{
     272                 :   /**
     273                 :    *  @param  x  A %reverse_iterator.
     274                 :    *  @param  y  A %reverse_iterator.
     275                 :    *  @return  A simple bool.
     276                 :    *
     277                 :    *  Reverse iterators forward many operations to their underlying base()
     278                 :    *  iterators.  Others are implemented in terms of one another.
     279                 :    *
     280                 :   */
     281                 :   template<typename _Iterator>
     282                 :     inline bool
     283             209 :     operator==(const reverse_iterator<_Iterator>& __x,
     284                 :                const reverse_iterator<_Iterator>& __y)
     285             209 :     { return __x.base() == __y.base(); }
     286                 : 
     287                 :   template<typename _Iterator>
     288                 :     inline bool
     289                 :     operator<(const reverse_iterator<_Iterator>& __x,
     290                 :               const reverse_iterator<_Iterator>& __y)
     291                 :     { return __y.base() < __x.base(); }
     292                 : 
     293                 :   template<typename _Iterator>
     294                 :     inline bool
     295             119 :     operator!=(const reverse_iterator<_Iterator>& __x,
     296                 :                const reverse_iterator<_Iterator>& __y)
     297             119 :     { return !(__x == __y); }
     298                 : 
     299                 :   template<typename _Iterator>
     300                 :     inline bool
     301                 :     operator>(const reverse_iterator<_Iterator>& __x,
     302                 :               const reverse_iterator<_Iterator>& __y)
     303                 :     { return __y < __x; }
     304                 : 
     305                 :   template<typename _Iterator>
     306                 :     inline bool
     307                 :     operator<=(const reverse_iterator<_Iterator>& __x,
     308                 :                const reverse_iterator<_Iterator>& __y)
     309                 :     { return !(__y < __x); }
     310                 : 
     311                 :   template<typename _Iterator>
     312                 :     inline bool
     313                 :     operator>=(const reverse_iterator<_Iterator>& __x,
     314                 :                const reverse_iterator<_Iterator>& __y)
     315                 :     { return !(__x < __y); }
     316                 : 
     317                 :   template<typename _Iterator>
     318                 :     inline typename reverse_iterator<_Iterator>::difference_type
     319               0 :     operator-(const reverse_iterator<_Iterator>& __x,
     320                 :               const reverse_iterator<_Iterator>& __y)
     321               0 :     { return __y.base() - __x.base(); }
     322                 : 
     323                 :   template<typename _Iterator>
     324                 :     inline reverse_iterator<_Iterator>
     325                 :     operator+(typename reverse_iterator<_Iterator>::difference_type __n,
     326                 :               const reverse_iterator<_Iterator>& __x)
     327                 :     { return reverse_iterator<_Iterator>(__x.base() - __n); }
     328                 : 
     329                 :   // _GLIBCXX_RESOLVE_LIB_DEFECTS
     330                 :   // DR 280. Comparison of reverse_iterator to const reverse_iterator.
     331                 :   template<typename _IteratorL, typename _IteratorR>
     332                 :     inline bool
     333                 :     operator==(const reverse_iterator<_IteratorL>& __x,
     334                 :                const reverse_iterator<_IteratorR>& __y)
     335                 :     { return __x.base() == __y.base(); }
     336                 : 
     337                 :   template<typename _IteratorL, typename _IteratorR>
     338                 :     inline bool
     339                 :     operator<(const reverse_iterator<_IteratorL>& __x,
     340                 :               const reverse_iterator<_IteratorR>& __y)
     341                 :     { return __y.base() < __x.base(); }
     342                 : 
     343                 :   template<typename _IteratorL, typename _IteratorR>
     344                 :     inline bool
     345                 :     operator!=(const reverse_iterator<_IteratorL>& __x,
     346                 :                const reverse_iterator<_IteratorR>& __y)
     347                 :     { return !(__x == __y); }
     348                 : 
     349                 :   template<typename _IteratorL, typename _IteratorR>
     350                 :     inline bool
     351                 :     operator>(const reverse_iterator<_IteratorL>& __x,
     352                 :               const reverse_iterator<_IteratorR>& __y)
     353                 :     { return __y < __x; }
     354                 : 
     355                 :   template<typename _IteratorL, typename _IteratorR>
     356                 :     inline bool
     357                 :     operator<=(const reverse_iterator<_IteratorL>& __x,
     358                 :                const reverse_iterator<_IteratorR>& __y)
     359                 :     { return !(__y < __x); }
     360                 : 
     361                 :   template<typename _IteratorL, typename _IteratorR>
     362                 :     inline bool
     363                 :     operator>=(const reverse_iterator<_IteratorL>& __x,
     364                 :                const reverse_iterator<_IteratorR>& __y)
     365                 :     { return !(__x < __y); }
     366                 : 
     367                 :   template<typename _IteratorL, typename _IteratorR>
     368                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     369                 :     // DR 685.
     370                 :     inline auto
     371                 :     operator-(const reverse_iterator<_IteratorL>& __x,
     372                 :               const reverse_iterator<_IteratorR>& __y)
     373                 :     -> decltype(__y.base() - __x.base())
     374                 : #else
     375                 :     inline typename reverse_iterator<_IteratorL>::difference_type
     376                 :     operator-(const reverse_iterator<_IteratorL>& __x,
     377                 :               const reverse_iterator<_IteratorR>& __y)
     378                 : #endif
     379                 :     { return __y.base() - __x.base(); }
     380                 :   //@}
     381                 : 
     382                 :   // 24.4.2.2.1 back_insert_iterator
     383                 :   /**
     384                 :    *  @brief  Turns assignment into insertion.
     385                 :    *
     386                 :    *  These are output iterators, constructed from a container-of-T.
     387                 :    *  Assigning a T to the iterator appends it to the container using
     388                 :    *  push_back.
     389                 :    *
     390                 :    *  Tip:  Using the back_inserter function to create these iterators can
     391                 :    *  save typing.
     392                 :   */
     393                 :   template<typename _Container>
     394                 :     class back_insert_iterator
     395                 :     : public iterator<output_iterator_tag, void, void, void, void>
     396                 :     {
     397                 :     protected:
     398                 :       _Container* container;
     399                 : 
     400                 :     public:
     401                 :       /// A nested typedef for the type of whatever container you used.
     402                 :       typedef _Container          container_type;
     403                 : 
     404                 :       /// The only way to create this %iterator is with a container.
     405                 :       explicit
     406               0 :       back_insert_iterator(_Container& __x) : container(&__x) { }
     407                 : 
     408                 :       /**
     409                 :        *  @param  value  An instance of whatever type
     410                 :        *                 container_type::const_reference is; presumably a
     411                 :        *                 reference-to-const T for container<T>.
     412                 :        *  @return  This %iterator, for chained operations.
     413                 :        *
     414                 :        *  This kind of %iterator doesn't really have a @a position in the
     415                 :        *  container (you can think of the position as being permanently at
     416                 :        *  the end, if you like).  Assigning a value to the %iterator will
     417                 :        *  always append the value to the end of the container.
     418                 :       */
     419                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
     420                 :       back_insert_iterator&
     421                 :       operator=(typename _Container::const_reference __value)
     422                 :       {
     423                 :         container->push_back(__value);
     424                 :         return *this;
     425                 :       }
     426                 : #else
     427                 :       back_insert_iterator&
     428               0 :       operator=(const typename _Container::value_type& __value)
     429                 :       {
     430               0 :         container->push_back(__value);
     431               0 :         return *this;
     432                 :       }
     433                 : 
     434                 :       back_insert_iterator&
     435                 :       operator=(typename _Container::value_type&& __value)
     436                 :       {
     437                 :         container->push_back(std::move(__value));
     438                 :         return *this;
     439                 :       }
     440                 : #endif
     441                 : 
     442                 :       /// Simply returns *this.
     443                 :       back_insert_iterator&
     444               0 :       operator*()
     445               0 :       { return *this; }
     446                 : 
     447                 :       /// Simply returns *this.  (This %iterator does not @a move.)
     448                 :       back_insert_iterator&
     449               0 :       operator++()
     450               0 :       { return *this; }
     451                 : 
     452                 :       /// Simply returns *this.  (This %iterator does not @a move.)
     453                 :       back_insert_iterator
     454                 :       operator++(int)
     455                 :       { return *this; }
     456                 :     };
     457                 : 
     458                 :   /**
     459                 :    *  @param  x  A container of arbitrary type.
     460                 :    *  @return  An instance of back_insert_iterator working on @p x.
     461                 :    *
     462                 :    *  This wrapper function helps in creating back_insert_iterator instances.
     463                 :    *  Typing the name of the %iterator requires knowing the precise full
     464                 :    *  type of the container, which can be tedious and impedes generic
     465                 :    *  programming.  Using this function lets you take advantage of automatic
     466                 :    *  template parameter deduction, making the compiler match the correct
     467                 :    *  types for you.
     468                 :   */
     469                 :   template<typename _Container>
     470                 :     inline back_insert_iterator<_Container>
     471               0 :     back_inserter(_Container& __x)
     472               0 :     { return back_insert_iterator<_Container>(__x); }
     473                 : 
     474                 :   /**
     475                 :    *  @brief  Turns assignment into insertion.
     476                 :    *
     477                 :    *  These are output iterators, constructed from a container-of-T.
     478                 :    *  Assigning a T to the iterator prepends it to the container using
     479                 :    *  push_front.
     480                 :    *
     481                 :    *  Tip:  Using the front_inserter function to create these iterators can
     482                 :    *  save typing.
     483                 :   */
     484                 :   template<typename _Container>
     485                 :     class front_insert_iterator
     486                 :     : public iterator<output_iterator_tag, void, void, void, void>
     487                 :     {
     488                 :     protected:
     489                 :       _Container* container;
     490                 : 
     491                 :     public:
     492                 :       /// A nested typedef for the type of whatever container you used.
     493                 :       typedef _Container          container_type;
     494                 : 
     495                 :       /// The only way to create this %iterator is with a container.
     496                 :       explicit front_insert_iterator(_Container& __x) : container(&__x) { }
     497                 : 
     498                 :       /**
     499                 :        *  @param  value  An instance of whatever type
     500                 :        *                 container_type::const_reference is; presumably a
     501                 :        *                 reference-to-const T for container<T>.
     502                 :        *  @return  This %iterator, for chained operations.
     503                 :        *
     504                 :        *  This kind of %iterator doesn't really have a @a position in the
     505                 :        *  container (you can think of the position as being permanently at
     506                 :        *  the front, if you like).  Assigning a value to the %iterator will
     507                 :        *  always prepend the value to the front of the container.
     508                 :       */
     509                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
     510                 :       front_insert_iterator&
     511                 :       operator=(typename _Container::const_reference __value)
     512                 :       {
     513                 :         container->push_front(__value);
     514                 :         return *this;
     515                 :       }
     516                 : #else
     517                 :       front_insert_iterator&
     518                 :       operator=(const typename _Container::value_type& __value)
     519                 :       {
     520                 :         container->push_front(__value);
     521                 :         return *this;
     522                 :       }
     523                 : 
     524                 :       front_insert_iterator&
     525                 :       operator=(typename _Container::value_type&& __value)
     526                 :       {
     527                 :         container->push_front(std::move(__value));
     528                 :         return *this;
     529                 :       }
     530                 : #endif
     531                 : 
     532                 :       /// Simply returns *this.
     533                 :       front_insert_iterator&
     534                 :       operator*()
     535                 :       { return *this; }
     536                 : 
     537                 :       /// Simply returns *this.  (This %iterator does not @a move.)
     538                 :       front_insert_iterator&
     539                 :       operator++()
     540                 :       { return *this; }
     541                 : 
     542                 :       /// Simply returns *this.  (This %iterator does not @a move.)
     543                 :       front_insert_iterator
     544                 :       operator++(int)
     545                 :       { return *this; }
     546                 :     };
     547                 : 
     548                 :   /**
     549                 :    *  @param  x  A container of arbitrary type.
     550                 :    *  @return  An instance of front_insert_iterator working on @p x.
     551                 :    *
     552                 :    *  This wrapper function helps in creating front_insert_iterator instances.
     553                 :    *  Typing the name of the %iterator requires knowing the precise full
     554                 :    *  type of the container, which can be tedious and impedes generic
     555                 :    *  programming.  Using this function lets you take advantage of automatic
     556                 :    *  template parameter deduction, making the compiler match the correct
     557                 :    *  types for you.
     558                 :   */
     559                 :   template<typename _Container>
     560                 :     inline front_insert_iterator<_Container>
     561                 :     front_inserter(_Container& __x)
     562                 :     { return front_insert_iterator<_Container>(__x); }
     563                 : 
     564                 :   /**
     565                 :    *  @brief  Turns assignment into insertion.
     566                 :    *
     567                 :    *  These are output iterators, constructed from a container-of-T.
     568                 :    *  Assigning a T to the iterator inserts it in the container at the
     569                 :    *  %iterator's position, rather than overwriting the value at that
     570                 :    *  position.
     571                 :    *
     572                 :    *  (Sequences will actually insert a @e copy of the value before the
     573                 :    *  %iterator's position.)
     574                 :    *
     575                 :    *  Tip:  Using the inserter function to create these iterators can
     576                 :    *  save typing.
     577                 :   */
     578                 :   template<typename _Container>
     579                 :     class insert_iterator
     580                 :     : public iterator<output_iterator_tag, void, void, void, void>
     581                 :     {
     582                 :     protected:
     583                 :       _Container* container;
     584                 :       typename _Container::iterator iter;
     585                 : 
     586                 :     public:
     587                 :       /// A nested typedef for the type of whatever container you used.
     588                 :       typedef _Container          container_type;
     589                 : 
     590                 :       /**
     591                 :        *  The only way to create this %iterator is with a container and an
     592                 :        *  initial position (a normal %iterator into the container).
     593                 :       */
     594                 :       insert_iterator(_Container& __x, typename _Container::iterator __i)
     595                 :       : container(&__x), iter(__i) {}
     596                 : 
     597                 :       /**
     598                 :        *  @param  value  An instance of whatever type
     599                 :        *                 container_type::const_reference is; presumably a
     600                 :        *                 reference-to-const T for container<T>.
     601                 :        *  @return  This %iterator, for chained operations.
     602                 :        *
     603                 :        *  This kind of %iterator maintains its own position in the
     604                 :        *  container.  Assigning a value to the %iterator will insert the
     605                 :        *  value into the container at the place before the %iterator.
     606                 :        *
     607                 :        *  The position is maintained such that subsequent assignments will
     608                 :        *  insert values immediately after one another.  For example,
     609                 :        *  @code
     610                 :        *     // vector v contains A and Z
     611                 :        *
     612                 :        *     insert_iterator i (v, ++v.begin());
     613                 :        *     i = 1;
     614                 :        *     i = 2;
     615                 :        *     i = 3;
     616                 :        *
     617                 :        *     // vector v contains A, 1, 2, 3, and Z
     618                 :        *  @endcode
     619                 :       */
     620                 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
     621                 :       insert_iterator&
     622                 :       operator=(typename _Container::const_reference __value)
     623                 :       {
     624                 :         iter = container->insert(iter, __value);
     625                 :         ++iter;
     626                 :         return *this;
     627                 :       }
     628                 : #else
     629                 :       insert_iterator&
     630                 :       operator=(const typename _Container::value_type& __value)
     631                 :       {
     632                 :         iter = container->insert(iter, __value);
     633                 :         ++iter;
     634                 :         return *this;
     635                 :       }
     636                 : 
     637                 :       insert_iterator&
     638                 :       operator=(typename _Container::value_type&& __value)
     639                 :       {
     640                 :         iter = container->insert(iter, std::move(__value));
     641                 :         ++iter;
     642                 :         return *this;
     643                 :       }
     644                 : #endif
     645                 : 
     646                 :       /// Simply returns *this.
     647                 :       insert_iterator&
     648                 :       operator*()
     649                 :       { return *this; }
     650                 : 
     651                 :       /// Simply returns *this.  (This %iterator does not @a move.)
     652                 :       insert_iterator&
     653                 :       operator++()
     654                 :       { return *this; }
     655                 : 
     656                 :       /// Simply returns *this.  (This %iterator does not @a move.)
     657                 :       insert_iterator&
     658                 :       operator++(int)
     659                 :       { return *this; }
     660                 :     };
     661                 : 
     662                 :   /**
     663                 :    *  @param  x  A container of arbitrary type.
     664                 :    *  @return  An instance of insert_iterator working on @p x.
     665                 :    *
     666                 :    *  This wrapper function helps in creating insert_iterator instances.
     667                 :    *  Typing the name of the %iterator requires knowing the precise full
     668                 :    *  type of the container, which can be tedious and impedes generic
     669                 :    *  programming.  Using this function lets you take advantage of automatic
     670                 :    *  template parameter deduction, making the compiler match the correct
     671                 :    *  types for you.
     672                 :   */
     673                 :   template<typename _Container, typename _Iterator>
     674                 :     inline insert_iterator<_Container>
     675                 :     inserter(_Container& __x, _Iterator __i)
     676                 :     {
     677                 :       return insert_iterator<_Container>(__x,
     678                 :                                          typename _Container::iterator(__i));
     679                 :     }
     680                 : 
     681                 :   // @} group iterators
     682                 : 
     683                 : _GLIBCXX_END_NAMESPACE
     684                 : 
     685                 : _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
     686                 : 
     687                 :   // This iterator adapter is @a normal in the sense that it does not
     688                 :   // change the semantics of any of the operators of its iterator
     689                 :   // parameter.  Its primary purpose is to convert an iterator that is
     690                 :   // not a class, e.g. a pointer, into an iterator that is a class.
     691                 :   // The _Container parameter exists solely so that different containers
     692                 :   // using this template can instantiate different types, even if the
     693                 :   // _Iterator parameter is the same.
     694                 :   using std::iterator_traits;
     695                 :   using std::iterator;
     696                 :   template<typename _Iterator, typename _Container>
     697                 :     class __normal_iterator
     698                 :     {
     699                 :     protected:
     700                 :       _Iterator _M_current;
     701                 : 
     702                 :       typedef iterator_traits<_Iterator>          __traits_type;
     703                 : 
     704                 :     public:
     705                 :       typedef _Iterator                                 iterator_type;
     706                 :       typedef typename __traits_type::iterator_category iterator_category;
     707                 :       typedef typename __traits_type::value_type        value_type;
     708                 :       typedef typename __traits_type::difference_type   difference_type;
     709                 :       typedef typename __traits_type::reference         reference;
     710                 :       typedef typename __traits_type::pointer           pointer;
     711                 : 
     712             124 :       __normal_iterator() : _M_current(_Iterator()) { }
     713                 : 
     714                 :       explicit
     715        75833971 :       __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
     716                 : 
     717                 :       // Allow iterator to const_iterator conversion
     718                 :       template<typename _Iter>
     719            4849 :         __normal_iterator(const __normal_iterator<_Iter,
     720                 :                           typename __enable_if<
     721                 :                (std::__are_same<_Iter, typename _Container::pointer>::__value),
     722                 :                       _Container>::__type>& __i)
     723            4849 :         : _M_current(__i.base()) { }
     724                 : 
     725                 :       // Forward iterator requirements
     726                 :       reference
     727       166637173 :       operator*() const
     728       166637173 :       { return *_M_current; }
     729                 : 
     730                 :       pointer
     731        26711589 :       operator->() const
     732        26711589 :       { return _M_current; }
     733                 : 
     734                 :       __normal_iterator&
     735        49513815 :       operator++()
     736                 :       {
     737        49513815 :         ++_M_current;
     738        49513815 :         return *this;
     739                 :       }
     740                 : 
     741                 :       __normal_iterator
     742        12261827 :       operator++(int)
     743        12261827 :       { return __normal_iterator(_M_current++); }
     744                 : 
     745                 :       // Bidirectional iterator requirements
     746                 :       __normal_iterator&
     747        27257792 :       operator--()
     748                 :       {
     749        27257792 :         --_M_current;
     750        27257792 :         return *this;
     751                 :       }
     752                 : 
     753                 :       __normal_iterator
     754                 :       operator--(int)
     755                 :       { return __normal_iterator(_M_current--); }
     756                 : 
     757                 :       // Random access iterator requirements
     758                 :       reference
     759               0 :       operator[](const difference_type& __n) const
     760               0 :       { return _M_current[__n]; }
     761                 : 
     762                 :       __normal_iterator&
     763               0 :       operator+=(const difference_type& __n)
     764               0 :       { _M_current += __n; return *this; }
     765                 : 
     766                 :       __normal_iterator
     767        25341767 :       operator+(const difference_type& __n) const
     768        25341767 :       { return __normal_iterator(_M_current + __n); }
     769                 : 
     770                 :       __normal_iterator&
     771                 :       operator-=(const difference_type& __n)
     772                 :       { _M_current -= __n; return *this; }
     773                 : 
     774                 :       __normal_iterator
     775          611075 :       operator-(const difference_type& __n) const
     776          611075 :       { return __normal_iterator(_M_current - __n); }
     777                 : 
     778                 :       const _Iterator&
     779       101853495 :       base() const
     780       101853495 :       { return _M_current; }
     781                 :     };
     782                 : 
     783                 :   // Note: In what follows, the left- and right-hand-side iterators are
     784                 :   // allowed to vary in types (conceptually in cv-qualification) so that
     785                 :   // comparison between cv-qualified and non-cv-qualified iterators be
     786                 :   // valid.  However, the greedy and unfriendly operators in std::rel_ops
     787                 :   // will make overload resolution ambiguous (when in scope) if we don't
     788                 :   // provide overloads whose operands are of the same type.  Can someone
     789                 :   // remind me what generic programming is about? -- Gaby
     790                 : 
     791                 :   // Forward iterator requirements
     792                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     793                 :     inline bool
     794                 :     operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
     795                 :                const __normal_iterator<_IteratorR, _Container>& __rhs)
     796                 :     { return __lhs.base() == __rhs.base(); }
     797                 : 
     798                 :   template<typename _Iterator, typename _Container>
     799                 :     inline bool
     800           24846 :     operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
     801                 :                const __normal_iterator<_Iterator, _Container>& __rhs)
     802           24846 :     { return __lhs.base() == __rhs.base(); }
     803                 : 
     804                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     805                 :     inline bool
     806        13628461 :     operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
     807                 :                const __normal_iterator<_IteratorR, _Container>& __rhs)
     808        13628461 :     { return __lhs.base() != __rhs.base(); }
     809                 : 
     810                 :   template<typename _Iterator, typename _Container>
     811                 :     inline bool
     812        22912092 :     operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
     813                 :                const __normal_iterator<_Iterator, _Container>& __rhs)
     814        22912092 :     { return __lhs.base() != __rhs.base(); }
     815                 : 
     816                 :   // Random access iterator requirements
     817                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     818                 :     inline bool
     819                 :     operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     820                 :               const __normal_iterator<_IteratorR, _Container>& __rhs)
     821                 :     { return __lhs.base() < __rhs.base(); }
     822                 : 
     823                 :   template<typename _Iterator, typename _Container>
     824                 :     inline bool
     825         6032259 :     operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
     826                 :               const __normal_iterator<_Iterator, _Container>& __rhs)
     827         6032259 :     { return __lhs.base() < __rhs.base(); }
     828                 : 
     829                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     830                 :     inline bool
     831                 :     operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     832                 :               const __normal_iterator<_IteratorR, _Container>& __rhs)
     833                 :     { return __lhs.base() > __rhs.base(); }
     834                 : 
     835                 :   template<typename _Iterator, typename _Container>
     836                 :     inline bool
     837                 :     operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     838                 :               const __normal_iterator<_Iterator, _Container>& __rhs)
     839                 :     { return __lhs.base() > __rhs.base(); }
     840                 : 
     841                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     842                 :     inline bool
     843                 :     operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
     844                 :                const __normal_iterator<_IteratorR, _Container>& __rhs)
     845                 :     { return __lhs.base() <= __rhs.base(); }
     846                 : 
     847                 :   template<typename _Iterator, typename _Container>
     848                 :     inline bool
     849                 :     operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
     850                 :                const __normal_iterator<_Iterator, _Container>& __rhs)
     851                 :     { return __lhs.base() <= __rhs.base(); }
     852                 : 
     853                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     854                 :     inline bool
     855                 :     operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
     856                 :                const __normal_iterator<_IteratorR, _Container>& __rhs)
     857                 :     { return __lhs.base() >= __rhs.base(); }
     858                 : 
     859                 :   template<typename _Iterator, typename _Container>
     860                 :     inline bool
     861                 :     operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
     862                 :                const __normal_iterator<_Iterator, _Container>& __rhs)
     863                 :     { return __lhs.base() >= __rhs.base(); }
     864                 : 
     865                 :   // _GLIBCXX_RESOLVE_LIB_DEFECTS
     866                 :   // According to the resolution of DR179 not only the various comparison
     867                 :   // operators but also operator- must accept mixed iterator/const_iterator
     868                 :   // parameters.
     869                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     870                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     871                 :     // DR 685.
     872                 :     inline auto
     873                 :     operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     874                 :               const __normal_iterator<_IteratorR, _Container>& __rhs)
     875                 :     -> decltype(__lhs.base() - __rhs.base())
     876                 : #else
     877                 :     inline typename __normal_iterator<_IteratorL, _Container>::difference_type
     878                 :     operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     879                 :               const __normal_iterator<_IteratorR, _Container>& __rhs)
     880                 : #endif
     881                 :     { return __lhs.base() - __rhs.base(); }
     882                 : 
     883                 :   template<typename _Iterator, typename _Container>
     884                 :     inline typename __normal_iterator<_Iterator, _Container>::difference_type
     885         6032173 :     operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
     886                 :               const __normal_iterator<_Iterator, _Container>& __rhs)
     887         6032173 :     { return __lhs.base() - __rhs.base(); }
     888                 : 
     889                 :   template<typename _Iterator, typename _Container>
     890                 :     inline __normal_iterator<_Iterator, _Container>
     891                 :     operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
     892                 :               __n, const __normal_iterator<_Iterator, _Container>& __i)
     893                 :     { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
     894                 : 
     895                 : _GLIBCXX_END_NAMESPACE
     896                 : 
     897                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     898                 : 
     899                 : _GLIBCXX_BEGIN_NAMESPACE(std)
     900                 : 
     901                 :   /**
     902                 :    * @addtogroup iterators
     903                 :    * @{
     904                 :    */
     905                 : 
     906                 :   // 24.4.3  Move iterators
     907                 :   /**
     908                 :    *  Class template move_iterator is an iterator adapter with the same
     909                 :    *  behavior as the underlying iterator except that its dereference
     910                 :    *  operator implicitly converts the value returned by the underlying
     911                 :    *  iterator's dereference operator to an rvalue reference.  Some
     912                 :    *  generic algorithms can be called with move iterators to replace
     913                 :    *  copying with moving.
     914                 :    */
     915                 :   template<typename _Iterator>
     916                 :     class move_iterator
     917                 :     {
     918                 :     protected:
     919                 :       _Iterator _M_current;
     920                 : 
     921                 :       typedef iterator_traits<_Iterator>          __traits_type;
     922                 : 
     923                 :     public:
     924                 :       typedef _Iterator                                 iterator_type;
     925                 :       typedef typename __traits_type::iterator_category iterator_category;
     926                 :       typedef typename __traits_type::value_type        value_type;
     927                 :       typedef typename __traits_type::difference_type   difference_type;
     928                 :       // NB: DR 680.
     929                 :       typedef _Iterator                                 pointer;
     930                 :       typedef value_type&&                              reference;
     931                 : 
     932                 :       move_iterator()
     933                 :       : _M_current() { }
     934                 : 
     935                 :       explicit
     936         9055368 :       move_iterator(iterator_type __i)
     937         9055368 :       : _M_current(__i) { }
     938                 : 
     939                 :       template<typename _Iter>
     940                 :         move_iterator(const move_iterator<_Iter>& __i)
     941                 :         : _M_current(__i.base()) { }
     942                 : 
     943                 :       iterator_type
     944        10370190 :       base() const
     945        10370190 :       { return _M_current; }
     946                 : 
     947                 :       reference
     948          657411 :       operator*() const
     949          657411 :       { return std::move(*_M_current); }
     950                 : 
     951                 :       pointer
     952                 :       operator->() const
     953                 :       { return _M_current; }
     954                 : 
     955                 :       move_iterator&
     956          657411 :       operator++()
     957                 :       {
     958          657411 :         ++_M_current;
     959          657411 :         return *this;
     960                 :       }
     961                 : 
     962                 :       move_iterator
     963                 :       operator++(int)
     964                 :       {
     965                 :         move_iterator __tmp = *this;
     966                 :         ++_M_current;
     967                 :         return __tmp;
     968                 :       }
     969                 : 
     970                 :       move_iterator&
     971               0 :       operator--()
     972                 :       {
     973               0 :         --_M_current;
     974               0 :         return *this;
     975                 :       }
     976                 : 
     977                 :       move_iterator
     978                 :       operator--(int)
     979                 :       {
     980                 :         move_iterator __tmp = *this;
     981                 :         --_M_current;
     982                 :         return __tmp;
     983                 :       }
     984                 : 
     985                 :       move_iterator
     986                 :       operator+(difference_type __n) const
     987                 :       { return move_iterator(_M_current + __n); }
     988                 : 
     989                 :       move_iterator&
     990                 :       operator+=(difference_type __n)
     991                 :       {
     992                 :         _M_current += __n;
     993                 :         return *this;
     994                 :       }
     995                 : 
     996                 :       move_iterator
     997                 :       operator-(difference_type __n) const
     998                 :       { return move_iterator(_M_current - __n); }
     999                 :     
    1000                 :       move_iterator&
    1001                 :       operator-=(difference_type __n)
    1002                 :       { 
    1003                 :         _M_current -= __n;
    1004                 :         return *this;
    1005                 :       }
    1006                 : 
    1007                 :       reference
    1008                 :       operator[](difference_type __n) const
    1009                 :       { return std::move(_M_current[__n]); }
    1010                 :     };
    1011                 : 
    1012                 :   template<typename _IteratorL, typename _IteratorR>
    1013                 :     inline bool
    1014          673615 :     operator==(const move_iterator<_IteratorL>& __x,
    1015                 :                const move_iterator<_IteratorR>& __y)
    1016          673615 :     { return __x.base() == __y.base(); }
    1017                 : 
    1018                 :   template<typename _IteratorL, typename _IteratorR>
    1019                 :     inline bool
    1020          673615 :     operator!=(const move_iterator<_IteratorL>& __x,
    1021                 :                const move_iterator<_IteratorR>& __y)
    1022          673615 :     { return !(__x == __y); }
    1023                 : 
    1024                 :   template<typename _IteratorL, typename _IteratorR>
    1025                 :     inline bool
    1026                 :     operator<(const move_iterator<_IteratorL>& __x,
    1027                 :               const move_iterator<_IteratorR>& __y)
    1028                 :     { return __x.base() < __y.base(); }
    1029                 : 
    1030                 :   template<typename _IteratorL, typename _IteratorR>
    1031                 :     inline bool
    1032                 :     operator<=(const move_iterator<_IteratorL>& __x,
    1033                 :                const move_iterator<_IteratorR>& __y)
    1034                 :     { return !(__y < __x); }
    1035                 : 
    1036                 :   template<typename _IteratorL, typename _IteratorR>
    1037                 :     inline bool
    1038                 :     operator>(const move_iterator<_IteratorL>& __x,
    1039                 :               const move_iterator<_IteratorR>& __y)
    1040                 :     { return __y < __x; }
    1041                 : 
    1042                 :   template<typename _IteratorL, typename _IteratorR>
    1043                 :     inline bool
    1044                 :     operator>=(const move_iterator<_IteratorL>& __x,
    1045                 :                const move_iterator<_IteratorR>& __y)
    1046                 :     { return !(__x < __y); }
    1047                 : 
    1048                 :   // DR 685.
    1049                 :   template<typename _IteratorL, typename _IteratorR>
    1050                 :     inline auto
    1051                 :     operator-(const move_iterator<_IteratorL>& __x,
    1052                 :               const move_iterator<_IteratorR>& __y)
    1053                 :     -> decltype(__x.base() - __y.base())
    1054                 :     { return __x.base() - __y.base(); }
    1055                 : 
    1056                 :   template<typename _Iterator>
    1057                 :     inline move_iterator<_Iterator>
    1058                 :     operator+(typename move_iterator<_Iterator>::difference_type __n,
    1059                 :               const move_iterator<_Iterator>& __x)
    1060                 :     { return __x + __n; }
    1061                 : 
    1062                 :   template<typename _Iterator>
    1063                 :     inline move_iterator<_Iterator>
    1064         9055368 :     make_move_iterator(const _Iterator& __i)
    1065         9055368 :     { return move_iterator<_Iterator>(__i); }
    1066                 : 
    1067                 :   // @} group iterators
    1068                 : 
    1069                 : _GLIBCXX_END_NAMESPACE
    1070                 : 
    1071                 : #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
    1072                 : #else
    1073                 : #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
    1074                 : #endif // __GXX_EXPERIMENTAL_CXX0X__
    1075                 : 
    1076                 : #endif

Generated by: LCOV version 1.7