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