LTP GCOV extension - code coverage report
Current view: directory - usr/include/c++/4.3/bits - stl_iterator.h
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 66
Code covered: 93.9 % Executed lines: 62

       1                 : // Iterators -*- 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-1998
      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_iterator.h
      58                 :  *  This is an internal header file, included by other library headers.
      59                 :  *  You should not attempt to use it directly.
      60                 :  *
      61                 :  *  This file implements reverse_iterator, back_insert_iterator,
      62                 :  *  front_insert_iterator, insert_iterator, __normal_iterator, and their
      63                 :  *  supporting functions and overloaded operators.
      64                 :  */
      65                 : 
      66                 : #ifndef _STL_ITERATOR_H
      67                 : #define _STL_ITERATOR_H 1
      68                 : 
      69                 : #include <bits/cpp_type_traits.h>
      70                 : #include <ext/type_traits.h>
      71                 : #include <bits/stl_move.h>
      72                 : 
      73                 : _GLIBCXX_BEGIN_NAMESPACE(std)
      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                 :    *  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." [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                 :     public:
     106                 :       typedef _Iterator                                        iterator_type;
     107                 :       typedef typename iterator_traits<_Iterator>::difference_type
     108                 :                                                                difference_type;
     109                 :       typedef typename iterator_traits<_Iterator>::reference   reference;
     110                 :       typedef typename iterator_traits<_Iterator>::pointer     pointer;
     111                 : 
     112                 :     public:
     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                 :       reverse_iterator() : current() { }
     120                 : 
     121                 :       /**
     122                 :        *  This %iterator will move in the opposite direction that @p x does.
     123                 :       */
     124                 :       explicit
     125              34 :       reverse_iterator(iterator_type __x) : current(__x) { }
     126                 : 
     127                 :       /**
     128                 :        *  The copy constructor is normal.
     129                 :       */
     130                 :       reverse_iterator(const reverse_iterator& __x)
     131                 :       : 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                 :       base() const
     146                 :       { return current; }
     147                 : 
     148                 :       /**
     149                 :        *  @return  TODO
     150                 :        *
     151                 :        *  @doctodo
     152                 :       */
     153                 :       reference
     154              34 :       operator*() const
     155                 :       {
     156              34 :         _Iterator __tmp = current;
     157              34 :         return *--__tmp;
     158                 :       }
     159                 : 
     160                 :       /**
     161                 :        *  @return  TODO
     162                 :        *
     163                 :        *  @doctodo
     164                 :       */
     165                 :       pointer
     166              32 :       operator->() const
     167              32 :       { return &(operator*()); }
     168                 : 
     169                 :       /**
     170                 :        *  @return  TODO
     171                 :        *
     172                 :        *  @doctodo
     173                 :       */
     174                 :       reverse_iterator&
     175                 :       operator++()
     176                 :       {
     177                 :         --current;
     178                 :         return *this;
     179                 :       }
     180                 : 
     181                 :       /**
     182                 :        *  @return  TODO
     183                 :        *
     184                 :        *  @doctodo
     185                 :       */
     186                 :       reverse_iterator
     187                 :       operator++(int)
     188                 :       {
     189                 :         reverse_iterator __tmp = *this;
     190                 :         --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                 :     operator==(const reverse_iterator<_Iterator>& __x,
     284                 :                const reverse_iterator<_Iterator>& __y)
     285                 :     { 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                 :     operator!=(const reverse_iterator<_Iterator>& __x,
     296                 :                const reverse_iterator<_Iterator>& __y)
     297                 :     { 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                 :     operator-(const reverse_iterator<_Iterator>& __x,
     320                 :               const reverse_iterator<_Iterator>& __y)
     321                 :     { 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                 :     inline typename reverse_iterator<_IteratorL>::difference_type
     369                 :     operator-(const reverse_iterator<_IteratorL>& __x,
     370                 :               const reverse_iterator<_IteratorR>& __y)
     371                 :     { return __y.base() - __x.base(); }
     372                 :   //@}
     373                 : 
     374                 :   // 24.4.2.2.1 back_insert_iterator
     375                 :   /**
     376                 :    *  @brief  Turns assignment into insertion.
     377                 :    *
     378                 :    *  These are output iterators, constructed from a container-of-T.
     379                 :    *  Assigning a T to the iterator appends it to the container using
     380                 :    *  push_back.
     381                 :    *
     382                 :    *  Tip:  Using the back_inserter function to create these iterators can
     383                 :    *  save typing.
     384                 :   */
     385                 :   template<typename _Container>
     386                 :     class back_insert_iterator
     387                 :     : public iterator<output_iterator_tag, void, void, void, void>
     388                 :     {
     389                 :     protected:
     390                 :       _Container* container;
     391                 : 
     392                 :     public:
     393                 :       /// A nested typedef for the type of whatever container you used.
     394                 :       typedef _Container          container_type;
     395                 : 
     396                 :       /// The only way to create this %iterator is with a container.
     397                 :       explicit
     398             946 :       back_insert_iterator(_Container& __x) : container(&__x) { }
     399                 : 
     400                 :       /**
     401                 :        *  @param  value  An instance of whatever type
     402                 :        *                 container_type::const_reference is; presumably a
     403                 :        *                 reference-to-const T for container<T>.
     404                 :        *  @return  This %iterator, for chained operations.
     405                 :        *
     406                 :        *  This kind of %iterator doesn't really have a "position" in the
     407                 :        *  container (you can think of the position as being permanently at
     408                 :        *  the end, if you like).  Assigning a value to the %iterator will
     409                 :        *  always append the value to the end of the container.
     410                 :       */
     411                 :       back_insert_iterator&
     412           17415 :       operator=(typename _Container::const_reference __value)
     413                 :       {
     414           17415 :         container->push_back(__value);
     415           17415 :         return *this;
     416                 :       }
     417                 : 
     418                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     419                 :       back_insert_iterator&
     420                 :       operator=(typename _Container::value_type&& __value)
     421                 :       {
     422                 :         container->push_back(std::move(__value));
     423                 :         return *this;
     424                 :       }
     425                 : #endif
     426                 : 
     427                 :       /// Simply returns *this.
     428                 :       back_insert_iterator&
     429           17419 :       operator*()
     430           17419 :       { return *this; }
     431                 : 
     432                 :       /// Simply returns *this.  (This %iterator does not "move".)
     433                 :       back_insert_iterator&
     434           17405 :       operator++()
     435           17405 :       { return *this; }
     436                 : 
     437                 :       /// Simply returns *this.  (This %iterator does not "move".)
     438                 :       back_insert_iterator
     439              10 :       operator++(int)
     440              10 :       { return *this; }
     441                 :     };
     442                 : 
     443                 :   /**
     444                 :    *  @param  x  A container of arbitrary type.
     445                 :    *  @return  An instance of back_insert_iterator working on @p x.
     446                 :    *
     447                 :    *  This wrapper function helps in creating back_insert_iterator instances.
     448                 :    *  Typing the name of the %iterator requires knowing the precise full
     449                 :    *  type of the container, which can be tedious and impedes generic
     450                 :    *  programming.  Using this function lets you take advantage of automatic
     451                 :    *  template parameter deduction, making the compiler match the correct
     452                 :    *  types for you.
     453                 :   */
     454                 :   template<typename _Container>
     455                 :     inline back_insert_iterator<_Container>
     456             946 :     back_inserter(_Container& __x)
     457             946 :     { return back_insert_iterator<_Container>(__x); }
     458                 : 
     459                 :   /**
     460                 :    *  @brief  Turns assignment into insertion.
     461                 :    *
     462                 :    *  These are output iterators, constructed from a container-of-T.
     463                 :    *  Assigning a T to the iterator prepends it to the container using
     464                 :    *  push_front.
     465                 :    *
     466                 :    *  Tip:  Using the front_inserter function to create these iterators can
     467                 :    *  save typing.
     468                 :   */
     469                 :   template<typename _Container>
     470                 :     class front_insert_iterator
     471                 :     : public iterator<output_iterator_tag, void, void, void, void>
     472                 :     {
     473                 :     protected:
     474                 :       _Container* container;
     475                 : 
     476                 :     public:
     477                 :       /// A nested typedef for the type of whatever container you used.
     478                 :       typedef _Container          container_type;
     479                 : 
     480                 :       /// The only way to create this %iterator is with a container.
     481                 :       explicit front_insert_iterator(_Container& __x) : container(&__x) { }
     482                 : 
     483                 :       /**
     484                 :        *  @param  value  An instance of whatever type
     485                 :        *                 container_type::const_reference is; presumably a
     486                 :        *                 reference-to-const T for container<T>.
     487                 :        *  @return  This %iterator, for chained operations.
     488                 :        *
     489                 :        *  This kind of %iterator doesn't really have a "position" in the
     490                 :        *  container (you can think of the position as being permanently at
     491                 :        *  the front, if you like).  Assigning a value to the %iterator will
     492                 :        *  always prepend the value to the front of the container.
     493                 :       */
     494                 :       front_insert_iterator&
     495                 :       operator=(typename _Container::const_reference __value)
     496                 :       {
     497                 :         container->push_front(__value);
     498                 :         return *this;
     499                 :       }
     500                 : 
     501                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     502                 :       front_insert_iterator&
     503                 :       operator=(typename _Container::value_type&& __value)
     504                 :       {
     505                 :         container->push_front(std::move(__value));
     506                 :         return *this;
     507                 :       }
     508                 : #endif
     509                 : 
     510                 :       /// Simply returns *this.
     511                 :       front_insert_iterator&
     512                 :       operator*()
     513                 :       { return *this; }
     514                 : 
     515                 :       /// Simply returns *this.  (This %iterator does not "move".)
     516                 :       front_insert_iterator&
     517                 :       operator++()
     518                 :       { return *this; }
     519                 : 
     520                 :       /// Simply returns *this.  (This %iterator does not "move".)
     521                 :       front_insert_iterator
     522                 :       operator++(int)
     523                 :       { return *this; }
     524                 :     };
     525                 : 
     526                 :   /**
     527                 :    *  @param  x  A container of arbitrary type.
     528                 :    *  @return  An instance of front_insert_iterator working on @p x.
     529                 :    *
     530                 :    *  This wrapper function helps in creating front_insert_iterator instances.
     531                 :    *  Typing the name of the %iterator requires knowing the precise full
     532                 :    *  type of the container, which can be tedious and impedes generic
     533                 :    *  programming.  Using this function lets you take advantage of automatic
     534                 :    *  template parameter deduction, making the compiler match the correct
     535                 :    *  types for you.
     536                 :   */
     537                 :   template<typename _Container>
     538                 :     inline front_insert_iterator<_Container>
     539                 :     front_inserter(_Container& __x)
     540                 :     { return front_insert_iterator<_Container>(__x); }
     541                 : 
     542                 :   /**
     543                 :    *  @brief  Turns assignment into insertion.
     544                 :    *
     545                 :    *  These are output iterators, constructed from a container-of-T.
     546                 :    *  Assigning a T to the iterator inserts it in the container at the
     547                 :    *  %iterator's position, rather than overwriting the value at that
     548                 :    *  position.
     549                 :    *
     550                 :    *  (Sequences will actually insert a @e copy of the value before the
     551                 :    *  %iterator's position.)
     552                 :    *
     553                 :    *  Tip:  Using the inserter function to create these iterators can
     554                 :    *  save typing.
     555                 :   */
     556                 :   template<typename _Container>
     557                 :     class insert_iterator
     558                 :     : public iterator<output_iterator_tag, void, void, void, void>
     559                 :     {
     560                 :     protected:
     561                 :       _Container* container;
     562                 :       typename _Container::iterator iter;
     563                 : 
     564                 :     public:
     565                 :       /// A nested typedef for the type of whatever container you used.
     566                 :       typedef _Container          container_type;
     567                 : 
     568                 :       /**
     569                 :        *  The only way to create this %iterator is with a container and an
     570                 :        *  initial position (a normal %iterator into the container).
     571                 :       */
     572           21203 :       insert_iterator(_Container& __x, typename _Container::iterator __i)
     573           21203 :       : container(&__x), iter(__i) {}
     574                 : 
     575                 :       /**
     576                 :        *  @param  value  An instance of whatever type
     577                 :        *                 container_type::const_reference is; presumably a
     578                 :        *                 reference-to-const T for container<T>.
     579                 :        *  @return  This %iterator, for chained operations.
     580                 :        *
     581                 :        *  This kind of %iterator maintains its own position in the
     582                 :        *  container.  Assigning a value to the %iterator will insert the
     583                 :        *  value into the container at the place before the %iterator.
     584                 :        *
     585                 :        *  The position is maintained such that subsequent assignments will
     586                 :        *  insert values immediately after one another.  For example,
     587                 :        *  @code
     588                 :        *     // vector v contains A and Z
     589                 :        *
     590                 :        *     insert_iterator i (v, ++v.begin());
     591                 :        *     i = 1;
     592                 :        *     i = 2;
     593                 :        *     i = 3;
     594                 :        *
     595                 :        *     // vector v contains A, 1, 2, 3, and Z
     596                 :        *  @endcode
     597                 :       */
     598                 :       insert_iterator&
     599          107622 :       operator=(typename _Container::const_reference __value)
     600                 :       {
     601          107622 :         iter = container->insert(iter, __value);
     602          107622 :         ++iter;
     603          107622 :         return *this;
     604                 :       }
     605                 : 
     606                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     607                 :       insert_iterator&
     608                 :       operator=(typename _Container::value_type&& __value)
     609                 :       {
     610                 :         iter = container->insert(iter, std::move(__value));
     611                 :         ++iter;
     612                 :         return *this;
     613                 :       }
     614                 : #endif
     615                 : 
     616                 :       /// Simply returns *this.
     617                 :       insert_iterator&
     618          107650 :       operator*()
     619          107650 :       { return *this; }
     620                 : 
     621                 :       /// Simply returns *this.  (This %iterator does not "move".)
     622                 :       insert_iterator&
     623          107622 :       operator++()
     624          107622 :       { return *this; }
     625                 : 
     626                 :       /// Simply returns *this.  (This %iterator does not "move".)
     627                 :       insert_iterator&
     628               0 :       operator++(int)
     629               0 :       { return *this; }
     630                 :     };
     631                 : 
     632                 :   /**
     633                 :    *  @param  x  A container of arbitrary type.
     634                 :    *  @return  An instance of insert_iterator working on @p x.
     635                 :    *
     636                 :    *  This wrapper function helps in creating insert_iterator instances.
     637                 :    *  Typing the name of the %iterator requires knowing the precise full
     638                 :    *  type of the container, which can be tedious and impedes generic
     639                 :    *  programming.  Using this function lets you take advantage of automatic
     640                 :    *  template parameter deduction, making the compiler match the correct
     641                 :    *  types for you.
     642                 :   */
     643                 :   template<typename _Container, typename _Iterator>
     644                 :     inline insert_iterator<_Container>
     645           21203 :     inserter(_Container& __x, _Iterator __i)
     646                 :     {
     647                 :       return insert_iterator<_Container>(__x,
     648           21203 :                                          typename _Container::iterator(__i));
     649                 :     }
     650                 : 
     651                 : _GLIBCXX_END_NAMESPACE
     652                 : 
     653                 : _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
     654                 : 
     655                 :   // This iterator adapter is 'normal' in the sense that it does not
     656                 :   // change the semantics of any of the operators of its iterator
     657                 :   // parameter.  Its primary purpose is to convert an iterator that is
     658                 :   // not a class, e.g. a pointer, into an iterator that is a class.
     659                 :   // The _Container parameter exists solely so that different containers
     660                 :   // using this template can instantiate different types, even if the
     661                 :   // _Iterator parameter is the same.
     662                 :   using std::iterator_traits;
     663                 :   using std::iterator;
     664                 :   template<typename _Iterator, typename _Container>
     665                 :     class __normal_iterator
     666                 :     {
     667                 :     protected:
     668                 :       _Iterator _M_current;
     669                 : 
     670                 :     public:
     671                 :       typedef _Iterator                                      iterator_type;
     672                 :       typedef typename iterator_traits<_Iterator>::iterator_category
     673                 :                                                              iterator_category;
     674                 :       typedef typename iterator_traits<_Iterator>::value_type  value_type;
     675                 :       typedef typename iterator_traits<_Iterator>::difference_type
     676                 :                                                              difference_type;
     677                 :       typedef typename iterator_traits<_Iterator>::reference reference;
     678                 :       typedef typename iterator_traits<_Iterator>::pointer   pointer;
     679                 : 
     680               3 :       __normal_iterator() : _M_current(_Iterator()) { }
     681                 : 
     682                 :       explicit
     683          150393 :       __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
     684                 : 
     685                 :       // Allow iterator to const_iterator conversion
     686                 :       template<typename _Iter>
     687                 :         __normal_iterator(const __normal_iterator<_Iter,
     688                 :                           typename __enable_if<
     689                 :                (std::__are_same<_Iter, typename _Container::pointer>::__value),
     690              28 :                       _Container>::__type>& __i)
     691              28 :         : _M_current(__i.base()) { }
     692                 : 
     693                 :       // Forward iterator requirements
     694                 :       reference
     695          925025 :       operator*() const
     696          925025 :       { return *_M_current; }
     697                 : 
     698                 :       pointer
     699               3 :       operator->() const
     700               3 :       { return _M_current; }
     701                 : 
     702                 :       __normal_iterator&
     703           81617 :       operator++()
     704                 :       {
     705           81617 :         ++_M_current;
     706           81617 :         return *this;
     707                 :       }
     708                 : 
     709                 :       __normal_iterator
     710           54836 :       operator++(int)
     711           54836 :       { return __normal_iterator(_M_current++); }
     712                 : 
     713                 :       // Bidirectional iterator requirements
     714                 :       __normal_iterator&
     715          249605 :       operator--()
     716                 :       {
     717          249605 :         --_M_current;
     718          249605 :         return *this;
     719                 :       }
     720                 : 
     721                 :       __normal_iterator
     722               0 :       operator--(int)
     723               0 :       { return __normal_iterator(_M_current--); }
     724                 : 
     725                 :       // Random access iterator requirements
     726                 :       reference
     727                 :       operator[](const difference_type& __n) const
     728                 :       { return _M_current[__n]; }
     729                 : 
     730                 :       __normal_iterator&
     731                 :       operator+=(const difference_type& __n)
     732                 :       { _M_current += __n; return *this; }
     733                 : 
     734                 :       __normal_iterator
     735           13455 :       operator+(const difference_type& __n) const
     736           13455 :       { return __normal_iterator(_M_current + __n); }
     737                 : 
     738                 :       __normal_iterator&
     739                 :       operator-=(const difference_type& __n)
     740                 :       { _M_current -= __n; return *this; }
     741                 : 
     742                 :       __normal_iterator
     743             846 :       operator-(const difference_type& __n) const
     744             846 :       { return __normal_iterator(_M_current - __n); }
     745                 : 
     746                 :       const _Iterator&
     747          455202 :       base() const
     748          455202 :       { return _M_current; }
     749                 :     };
     750                 : 
     751                 :   // Note: In what follows, the left- and right-hand-side iterators are
     752                 :   // allowed to vary in types (conceptually in cv-qualification) so that
     753                 :   // comparison between cv-qualified and non-cv-qualified iterators be
     754                 :   // valid.  However, the greedy and unfriendly operators in std::rel_ops
     755                 :   // will make overload resolution ambiguous (when in scope) if we don't
     756                 :   // provide overloads whose operands are of the same type.  Can someone
     757                 :   // remind me what generic programming is about? -- Gaby
     758                 : 
     759                 :   // Forward iterator requirements
     760                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     761                 :     inline bool
     762                 :     operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
     763                 :                const __normal_iterator<_IteratorR, _Container>& __rhs)
     764                 :     { return __lhs.base() == __rhs.base(); }
     765                 : 
     766                 :   template<typename _Iterator, typename _Container>
     767                 :     inline bool
     768                 :     operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
     769            4368 :                const __normal_iterator<_Iterator, _Container>& __rhs)
     770            4368 :     { return __lhs.base() == __rhs.base(); }
     771                 : 
     772                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     773                 :     inline bool
     774                 :     operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
     775              38 :                const __normal_iterator<_IteratorR, _Container>& __rhs)
     776              38 :     { return __lhs.base() != __rhs.base(); }
     777                 : 
     778                 :   template<typename _Iterator, typename _Container>
     779                 :     inline bool
     780                 :     operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
     781          123290 :                const __normal_iterator<_Iterator, _Container>& __rhs)
     782          123290 :     { return __lhs.base() != __rhs.base(); }
     783                 : 
     784                 :   // Random access iterator requirements
     785                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     786                 :     inline bool
     787                 :     operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     788                 :               const __normal_iterator<_IteratorR, _Container>& __rhs)
     789                 :     { return __lhs.base() < __rhs.base(); }
     790                 : 
     791                 :   template<typename _Iterator, typename _Container>
     792                 :     inline bool
     793                 :     operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
     794            7923 :               const __normal_iterator<_Iterator, _Container>& __rhs)
     795            7923 :     { return __lhs.base() < __rhs.base(); }
     796                 : 
     797                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     798                 :     inline bool
     799                 :     operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     800                 :               const __normal_iterator<_IteratorR, _Container>& __rhs)
     801                 :     { return __lhs.base() > __rhs.base(); }
     802                 : 
     803                 :   template<typename _Iterator, typename _Container>
     804                 :     inline bool
     805                 :     operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     806                 :               const __normal_iterator<_Iterator, _Container>& __rhs)
     807                 :     { return __lhs.base() > __rhs.base(); }
     808                 : 
     809                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     810                 :     inline bool
     811                 :     operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
     812                 :                const __normal_iterator<_IteratorR, _Container>& __rhs)
     813                 :     { return __lhs.base() <= __rhs.base(); }
     814                 : 
     815                 :   template<typename _Iterator, typename _Container>
     816                 :     inline bool
     817                 :     operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
     818                 :                const __normal_iterator<_Iterator, _Container>& __rhs)
     819                 :     { return __lhs.base() <= __rhs.base(); }
     820                 : 
     821                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     822                 :     inline bool
     823                 :     operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
     824                 :                const __normal_iterator<_IteratorR, _Container>& __rhs)
     825                 :     { return __lhs.base() >= __rhs.base(); }
     826                 : 
     827                 :   template<typename _Iterator, typename _Container>
     828                 :     inline bool
     829                 :     operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
     830                 :                const __normal_iterator<_Iterator, _Container>& __rhs)
     831                 :     { return __lhs.base() >= __rhs.base(); }
     832                 : 
     833                 :   // _GLIBCXX_RESOLVE_LIB_DEFECTS
     834                 :   // According to the resolution of DR179 not only the various comparison
     835                 :   // operators but also operator- must accept mixed iterator/const_iterator
     836                 :   // parameters.
     837                 :   template<typename _IteratorL, typename _IteratorR, typename _Container>
     838                 :     inline typename __normal_iterator<_IteratorL, _Container>::difference_type
     839                 :     operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     840                 :               const __normal_iterator<_IteratorR, _Container>& __rhs)
     841                 :     { return __lhs.base() - __rhs.base(); }
     842                 : 
     843                 :   template<typename _Iterator, typename _Container>
     844                 :     inline typename __normal_iterator<_Iterator, _Container>::difference_type
     845                 :     operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
     846           37193 :               const __normal_iterator<_Iterator, _Container>& __rhs)
     847           37193 :     { return __lhs.base() - __rhs.base(); }
     848                 : 
     849                 :   template<typename _Iterator, typename _Container>
     850                 :     inline __normal_iterator<_Iterator, _Container>
     851                 :     operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
     852                 :               __n, const __normal_iterator<_Iterator, _Container>& __i)
     853                 :     { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
     854                 : 
     855                 : _GLIBCXX_END_NAMESPACE
     856                 : 
     857                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     858                 : 
     859                 : _GLIBCXX_BEGIN_NAMESPACE(std)
     860                 : 
     861                 :   // 24.4.3  Move iterators
     862                 :   /**
     863                 :    *  Class template move_iterator is an iterator adapter with the same
     864                 :    *  behavior as the underlying iterator except that its dereference
     865                 :    *  operator implicitly converts the value returned by the underlying
     866                 :    *  iterator's dereference operator to an rvalue reference.  Some
     867                 :    *  generic algorithms can be called with move iterators to replace
     868                 :    *  copying with moving.
     869                 :    */
     870                 :   template<typename _Iterator>
     871                 :     class move_iterator
     872                 :     {
     873                 :     protected:
     874                 :       _Iterator _M_current;
     875                 : 
     876                 :     public:
     877                 :       typedef _Iterator                                        iterator_type;
     878                 :       typedef typename iterator_traits<_Iterator>::difference_type
     879                 :                                                                difference_type;
     880                 :       // NB: DR 680.
     881                 :       typedef _Iterator                                        pointer;
     882                 :       typedef typename iterator_traits<_Iterator>::value_type  value_type;
     883                 :       typedef typename iterator_traits<_Iterator>::iterator_category
     884                 :                                                                iterator_category;
     885                 :       typedef value_type&&                                     reference;
     886                 : 
     887                 :     public:
     888                 :       move_iterator()
     889                 :       : _M_current() { }
     890                 : 
     891                 :       explicit
     892                 :       move_iterator(iterator_type __i)
     893                 :       : _M_current(__i) { }
     894                 : 
     895                 :       template<typename _Iter>
     896                 :         move_iterator(const move_iterator<_Iter>& __i)
     897                 :         : _M_current(__i.base()) { }
     898                 : 
     899                 :       iterator_type
     900                 :       base() const
     901                 :       { return _M_current; }
     902                 : 
     903                 :       reference
     904                 :       operator*() const
     905                 :       { return *_M_current; }
     906                 : 
     907                 :       pointer
     908                 :       operator->() const
     909                 :       { return _M_current; }
     910                 : 
     911                 :       move_iterator&
     912                 :       operator++()
     913                 :       {
     914                 :         ++_M_current;
     915                 :         return *this;
     916                 :       }
     917                 : 
     918                 :       move_iterator
     919                 :       operator++(int)
     920                 :       {
     921                 :         move_iterator __tmp = *this;
     922                 :         ++_M_current;
     923                 :         return __tmp;
     924                 :       }
     925                 : 
     926                 :       move_iterator&
     927                 :       operator--()
     928                 :       {
     929                 :         --_M_current;
     930                 :         return *this;
     931                 :       }
     932                 : 
     933                 :       move_iterator
     934                 :       operator--(int)
     935                 :       {
     936                 :         move_iterator __tmp = *this;
     937                 :         --_M_current;
     938                 :         return __tmp;
     939                 :       }
     940                 : 
     941                 :       move_iterator
     942                 :       operator+(difference_type __n) const
     943                 :       { return move_iterator(_M_current + __n); }
     944                 : 
     945                 :       move_iterator&
     946                 :       operator+=(difference_type __n)
     947                 :       {
     948                 :         _M_current += __n;
     949                 :         return *this;
     950                 :       }
     951                 : 
     952                 :       move_iterator
     953                 :       operator-(difference_type __n) const
     954                 :       { return move_iterator(_M_current - __n); }
     955                 :     
     956                 :       move_iterator&
     957                 :       operator-=(difference_type __n)
     958                 :       { 
     959                 :         _M_current -= __n;
     960                 :         return *this;
     961                 :       }
     962                 : 
     963                 :       reference
     964                 :       operator[](difference_type __n) const
     965                 :       { return _M_current[__n]; }
     966                 :     };
     967                 : 
     968                 :   template<typename _IteratorL, typename _IteratorR>
     969                 :     inline bool
     970                 :     operator==(const move_iterator<_IteratorL>& __x,
     971                 :                const move_iterator<_IteratorR>& __y)
     972                 :     { return __x.base() == __y.base(); }
     973                 : 
     974                 :   template<typename _IteratorL, typename _IteratorR>
     975                 :     inline bool
     976                 :     operator!=(const move_iterator<_IteratorL>& __x,
     977                 :                const move_iterator<_IteratorR>& __y)
     978                 :     { return !(__x == __y); }
     979                 : 
     980                 :   template<typename _IteratorL, typename _IteratorR>
     981                 :     inline bool
     982                 :     operator<(const move_iterator<_IteratorL>& __x,
     983                 :               const move_iterator<_IteratorR>& __y)
     984                 :     { return __x.base() < __y.base(); }
     985                 : 
     986                 :   template<typename _IteratorL, typename _IteratorR>
     987                 :     inline bool
     988                 :     operator<=(const move_iterator<_IteratorL>& __x,
     989                 :                const move_iterator<_IteratorR>& __y)
     990                 :     { return !(__y < __x); }
     991                 : 
     992                 :   template<typename _IteratorL, typename _IteratorR>
     993                 :     inline bool
     994                 :     operator>(const move_iterator<_IteratorL>& __x,
     995                 :               const move_iterator<_IteratorR>& __y)
     996                 :     { return __y < __x; }
     997                 : 
     998                 :   template<typename _IteratorL, typename _IteratorR>
     999                 :     inline bool
    1000                 :     operator>=(const move_iterator<_IteratorL>& __x,
    1001                 :                const move_iterator<_IteratorR>& __y)
    1002                 :     { return !(__x < __y); }
    1003                 : 
    1004                 :   template<typename _IteratorL, typename _IteratorR>
    1005                 :     inline typename move_iterator<_IteratorL>::difference_type
    1006                 :     operator-(const move_iterator<_IteratorL>& __x,
    1007                 :               const move_iterator<_IteratorR>& __y)
    1008                 :     { return __x.base() - __y.base(); }
    1009                 : 
    1010                 :   template<typename _Iterator>
    1011                 :     inline move_iterator<_Iterator>
    1012                 :     operator+(typename move_iterator<_Iterator>::difference_type __n,
    1013                 :               const move_iterator<_Iterator>& __x)
    1014                 :     { return __x + __n; }
    1015                 : 
    1016                 :   template<typename _Iterator>
    1017                 :     inline move_iterator<_Iterator>
    1018                 :     make_move_iterator(const _Iterator& __i)
    1019                 :     { return move_iterator<_Iterator>(__i); }
    1020                 : 
    1021                 : _GLIBCXX_END_NAMESPACE
    1022                 : 
    1023                 : #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
    1024                 : #else
    1025                 : #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
    1026                 : #endif // __GXX_EXPERIMENTAL_CXX0X__
    1027                 : 
    1028                 : #endif

Generated by: LTP GCOV extension version 1.6