stl_iterator.h

Go to the documentation of this file.
00001 // Iterators -*- C++ -*-
00002 
00003 // Copyright (C) 2001, 2002 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the
00007 // terms of the GNU General Public License as published by the
00008 // Free Software Foundation; either version 2, or (at your option)
00009 // any later version.
00010 
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 
00016 // You should have received a copy of the GNU General Public License along
00017 // with this library; see the file COPYING.  If not, write to the Free
00018 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
00019 // USA.
00020 
00021 // As a special exception, you may use this file as part of a free software
00022 // library without restriction.  Specifically, if other files instantiate
00023 // templates or use macros or inline functions from this file, or you compile
00024 // this file and link it with other files to produce an executable, this
00025 // file does not by itself cause the resulting executable to be covered by
00026 // the GNU General Public License.  This exception does not however
00027 // invalidate any other reasons why the executable file might be covered by
00028 // the GNU General Public License.
00029 
00030 /*
00031  *
00032  * Copyright (c) 1994
00033  * Hewlett-Packard Company
00034  *
00035  * Permission to use, copy, modify, distribute and sell this software
00036  * and its documentation for any purpose is hereby granted without fee,
00037  * provided that the above copyright notice appear in all copies and
00038  * that both that copyright notice and this permission notice appear
00039  * in supporting documentation.  Hewlett-Packard Company makes no
00040  * representations about the suitability of this software for any
00041  * purpose.  It is provided "as is" without express or implied warranty.
00042  *
00043  *
00044  * Copyright (c) 1996-1998
00045  * Silicon Graphics Computer Systems, Inc.
00046  *
00047  * Permission to use, copy, modify, distribute and sell this software
00048  * and its documentation for any purpose is hereby granted without fee,
00049  * provided that the above copyright notice appear in all copies and
00050  * that both that copyright notice and this permission notice appear
00051  * in supporting documentation.  Silicon Graphics makes no
00052  * representations about the suitability of this software for any
00053  * purpose.  It is provided "as is" without express or implied warranty.
00054  */
00055 
00065 #ifndef __GLIBCPP_INTERNAL_ITERATOR_H
00066 #define __GLIBCPP_INTERNAL_ITERATOR_H
00067 
00068 namespace std
00069 {
00070   // 24.4.1 Reverse iterators
00089   template<typename _Iterator>
00090     class reverse_iterator 
00091     : public iterator<typename iterator_traits<_Iterator>::iterator_category,
00092               typename iterator_traits<_Iterator>::value_type,
00093               typename iterator_traits<_Iterator>::difference_type,
00094               typename iterator_traits<_Iterator>::pointer,
00095                       typename iterator_traits<_Iterator>::reference>
00096     {
00097     protected:
00098       _Iterator current;
00099 
00100     public:
00101       typedef _Iterator                        iterator_type;
00102       typedef typename iterator_traits<_Iterator>::difference_type  
00103                                        difference_type;
00104       typedef typename iterator_traits<_Iterator>::reference   reference;
00105       typedef typename iterator_traits<_Iterator>::pointer     pointer;
00106 
00107     public:
00111       reverse_iterator() { }
00112 
00116       explicit 
00117       reverse_iterator(iterator_type __x) : current(__x) { }
00118 
00122       reverse_iterator(const reverse_iterator& __x) 
00123       : current(__x.current) { }
00124 
00129       template<typename _Iter>
00130         reverse_iterator(const reverse_iterator<_Iter>& __x)
00131     : current(__x.base()) { }
00132     
00136       iterator_type 
00137       base() const { return current; }
00138 
00144       reference 
00145       operator*() const 
00146       {
00147     _Iterator __tmp = current;
00148     return *--__tmp;
00149       }
00150 
00156       pointer 
00157       operator->() const { return &(operator*()); }
00158 
00164       reverse_iterator& 
00165       operator++() 
00166       {
00167     --current;
00168     return *this;
00169       }
00170 
00176       reverse_iterator 
00177       operator++(int) 
00178       {
00179     reverse_iterator __tmp = *this;
00180     --current;
00181     return __tmp;
00182       }
00183 
00189       reverse_iterator& 
00190       operator--() 
00191       {
00192     ++current;
00193     return *this;
00194       }
00195 
00201       reverse_iterator operator--(int) 
00202       {
00203     reverse_iterator __tmp = *this;
00204     ++current;
00205     return __tmp;
00206       }
00207       
00213       reverse_iterator 
00214       operator+(difference_type __n) const 
00215       { return reverse_iterator(current - __n); }
00216 
00222       reverse_iterator& 
00223       operator+=(difference_type __n) 
00224       {
00225     current -= __n;
00226     return *this;
00227       }
00228 
00234       reverse_iterator 
00235       operator-(difference_type __n) const 
00236       { return reverse_iterator(current + __n); }
00237 
00243       reverse_iterator& 
00244       operator-=(difference_type __n) 
00245       {
00246     current += __n;
00247     return *this;
00248       }
00249 
00255       reference 
00256       operator[](difference_type __n) const { return *(*this + __n); }  
00257     }; 
00258  
00260 
00269   template<typename _Iterator>
00270     inline bool 
00271     operator==(const reverse_iterator<_Iterator>& __x, 
00272            const reverse_iterator<_Iterator>& __y) 
00273     { return __x.base() == __y.base(); }
00274 
00275   template<typename _Iterator>
00276     inline bool 
00277     operator<(const reverse_iterator<_Iterator>& __x, 
00278           const reverse_iterator<_Iterator>& __y) 
00279     { return __y.base() < __x.base(); }
00280 
00281   template<typename _Iterator>
00282     inline bool 
00283     operator!=(const reverse_iterator<_Iterator>& __x, 
00284            const reverse_iterator<_Iterator>& __y) 
00285     { return !(__x == __y); }
00286 
00287   template<typename _Iterator>
00288     inline bool 
00289     operator>(const reverse_iterator<_Iterator>& __x, 
00290           const reverse_iterator<_Iterator>& __y) 
00291     { return __y < __x; }
00292 
00293   template<typename _Iterator>
00294     inline bool 
00295     operator<=(const reverse_iterator<_Iterator>& __x, 
00296         const reverse_iterator<_Iterator>& __y) 
00297     { return !(__y < __x); }
00298 
00299   template<typename _Iterator>
00300     inline bool 
00301     operator>=(const reverse_iterator<_Iterator>& __x, 
00302            const reverse_iterator<_Iterator>& __y) 
00303     { return !(__x < __y); }
00304 
00305   template<typename _Iterator>
00306     inline typename reverse_iterator<_Iterator>::difference_type
00307     operator-(const reverse_iterator<_Iterator>& __x, 
00308           const reverse_iterator<_Iterator>& __y) 
00309     { return __y.base() - __x.base(); }
00310 
00311   template<typename _Iterator>
00312     inline reverse_iterator<_Iterator> 
00313     operator+(typename reverse_iterator<_Iterator>::difference_type __n,
00314           const reverse_iterator<_Iterator>& __x) 
00315     { return reverse_iterator<_Iterator>(__x.base() - __n); }
00317 
00318   // 24.4.2.2.1 back_insert_iterator
00327   template<typename _Container>
00328     class back_insert_iterator 
00329     : public iterator<output_iterator_tag, void, void, void, void>
00330     {
00331     protected:
00332       _Container* container;
00333 
00334     public:
00336       typedef _Container          container_type;
00337       
00339       explicit 
00340       back_insert_iterator(_Container& __x) : container(&__x) { }
00341 
00353       back_insert_iterator&
00354       operator=(typename _Container::const_reference __value) 
00355       { 
00356     container->push_back(__value);
00357     return *this;
00358       }
00359 
00361       back_insert_iterator& 
00362       operator*() { return *this; }
00363 
00365       back_insert_iterator& 
00366       operator++() { return *this; }
00367 
00369       back_insert_iterator
00370       operator++(int) { return *this; }
00371     };
00372 
00384   template<typename _Container>
00385     inline back_insert_iterator<_Container> 
00386     back_inserter(_Container& __x) 
00387     { return back_insert_iterator<_Container>(__x); }
00388 
00397   template<typename _Container>
00398     class front_insert_iterator 
00399     : public iterator<output_iterator_tag, void, void, void, void>
00400     {
00401     protected:
00402       _Container* container;
00403 
00404     public:
00406       typedef _Container          container_type;
00407 
00409       explicit front_insert_iterator(_Container& __x) : container(&__x) { }
00410 
00422       front_insert_iterator&
00423       operator=(typename _Container::const_reference __value) 
00424       { 
00425     container->push_front(__value);
00426     return *this;
00427       }
00428 
00430       front_insert_iterator& 
00431       operator*() { return *this; }
00432 
00434       front_insert_iterator& 
00435       operator++() { return *this; }
00436 
00438       front_insert_iterator 
00439       operator++(int) { return *this; }
00440     };
00441 
00453   template<typename _Container>
00454     inline front_insert_iterator<_Container> 
00455     front_inserter(_Container& __x) 
00456     { return front_insert_iterator<_Container>(__x); }
00457 
00470   template<typename _Container>
00471     class insert_iterator 
00472     : public iterator<output_iterator_tag, void, void, void, void>
00473     {
00474     protected:
00475       _Container* container;
00476       typename _Container::iterator iter;
00477 
00478     public:
00480       typedef _Container          container_type;
00481       
00486       insert_iterator(_Container& __x, typename _Container::iterator __i) 
00487       : container(&__x), iter(__i) {}
00488    
00512       insert_iterator&
00513       operator=(const typename _Container::const_reference __value) 
00514       { 
00515     iter = container->insert(iter, __value);
00516     ++iter;
00517     return *this;
00518       }
00519 
00521       insert_iterator& 
00522       operator*() { return *this; }
00523 
00525       insert_iterator& 
00526       operator++() { return *this; }
00527 
00529       insert_iterator& 
00530       operator++(int) { return *this; }
00531     };
00532   
00544   template<typename _Container, typename _Iterator>
00545     inline insert_iterator<_Container> 
00546     inserter(_Container& __x, _Iterator __i)
00547     {
00548       return insert_iterator<_Container>(__x, 
00549                      typename _Container::iterator(__i));
00550     }
00551 } // namespace std
00552 
00553 namespace __gnu_cxx
00554 {  
00555   // This iterator adapter is 'normal' in the sense that it does not
00556   // change the semantics of any of the operators of its iterator
00557   // parameter.  Its primary purpose is to convert an iterator that is
00558   // not a class, e.g. a pointer, into an iterator that is a class.
00559   // The _Container parameter exists solely so that different containers
00560   // using this template can instantiate different types, even if the
00561   // _Iterator parameter is the same.
00562   using std::iterator_traits;
00563   using std::iterator;
00564   template<typename _Iterator, typename _Container>
00565     class __normal_iterator
00566       : public iterator<typename iterator_traits<_Iterator>::iterator_category,
00567                         typename iterator_traits<_Iterator>::value_type,
00568                         typename iterator_traits<_Iterator>::difference_type,
00569                         typename iterator_traits<_Iterator>::pointer,
00570                         typename iterator_traits<_Iterator>::reference>
00571     {
00572     protected:
00573       _Iterator _M_current;
00574       
00575     public:
00576       typedef typename iterator_traits<_Iterator>::difference_type  
00577                                        difference_type;
00578       typedef typename iterator_traits<_Iterator>::reference   reference;
00579       typedef typename iterator_traits<_Iterator>::pointer     pointer;
00580 
00581       __normal_iterator() : _M_current(_Iterator()) { }
00582 
00583       explicit 
00584       __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
00585 
00586       // Allow iterator to const_iterator conversion
00587       template<typename _Iter>
00588       inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
00589     : _M_current(__i.base()) { }
00590 
00591       // Forward iterator requirements
00592       reference
00593       operator*() const { return *_M_current; }
00594       
00595       pointer
00596       operator->() const { return _M_current; }
00597       
00598       __normal_iterator&
00599       operator++() { ++_M_current; return *this; }
00600       
00601       __normal_iterator
00602       operator++(int) { return __normal_iterator(_M_current++); }
00603       
00604       // Bidirectional iterator requirements
00605       __normal_iterator&
00606       operator--() { --_M_current; return *this; }
00607       
00608       __normal_iterator
00609       operator--(int) { return __normal_iterator(_M_current--); }
00610       
00611       // Random access iterator requirements
00612       reference
00613       operator[](const difference_type& __n) const
00614       { return _M_current[__n]; }
00615       
00616       __normal_iterator&
00617       operator+=(const difference_type& __n)
00618       { _M_current += __n; return *this; }
00619 
00620       __normal_iterator
00621       operator+(const difference_type& __n) const
00622       { return __normal_iterator(_M_current + __n); }
00623       
00624       __normal_iterator&
00625       operator-=(const difference_type& __n)
00626       { _M_current -= __n; return *this; }
00627       
00628       __normal_iterator
00629       operator-(const difference_type& __n) const
00630       { return __normal_iterator(_M_current - __n); }
00631       
00632       difference_type
00633       operator-(const __normal_iterator& __i) const
00634       { return _M_current - __i._M_current; }
00635       
00636       const _Iterator& 
00637       base() const { return _M_current; }
00638     };
00639 
00640   // Note: In what follows, the left- and right-hand-side iterators are
00641   // allowed to vary in types (conceptually in cv-qualification) so that
00642   // comparaison between cv-qualified and non-cv-qualified iterators be
00643   // valid.  However, the greedy and unfriendly operators in std::rel_ops
00644   // will make overload resolution ambiguous (when in scope) if we don't
00645   // provide overloads whose operands are of the same type.  Can someone
00646   // remind me what generic programming is about? -- Gaby
00647   
00648   // Forward iterator requirements
00649   template<typename _IteratorL, typename _IteratorR, typename _Container>
00650   inline bool
00651   operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
00652          const __normal_iterator<_IteratorR, _Container>& __rhs)
00653   { return __lhs.base() == __rhs.base(); }
00654 
00655   template<typename _Iterator, typename _Container>
00656   inline bool
00657   operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
00658              const __normal_iterator<_Iterator, _Container>& __rhs)
00659   { return __lhs.base() == __rhs.base(); }
00660 
00661   template<typename _IteratorL, typename _IteratorR, typename _Container>
00662   inline bool
00663   operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
00664          const __normal_iterator<_IteratorR, _Container>& __rhs)
00665   { return __lhs.base() != __rhs.base(); }
00666 
00667   template<typename _Iterator, typename _Container>
00668   inline bool
00669   operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
00670              const __normal_iterator<_Iterator, _Container>& __rhs)
00671   { return __lhs.base() != __rhs.base(); }
00672 
00673   // Random access iterator requirements
00674   template<typename _IteratorL, typename _IteratorR, typename _Container>
00675   inline bool 
00676   operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
00677         const __normal_iterator<_IteratorR, _Container>& __rhs)
00678   { return __lhs.base() < __rhs.base(); }
00679 
00680   template<typename _Iterator, typename _Container>
00681   inline bool
00682   operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
00683              const __normal_iterator<_Iterator, _Container>& __rhs)
00684   { return __lhs.base() < __rhs.base(); }
00685 
00686   template<typename _IteratorL, typename _IteratorR, typename _Container>
00687   inline bool
00688   operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
00689         const __normal_iterator<_IteratorR, _Container>& __rhs)
00690   { return __lhs.base() > __rhs.base(); }
00691 
00692   template<typename _Iterator, typename _Container>
00693   inline bool
00694   operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
00695         const __normal_iterator<_Iterator, _Container>& __rhs)
00696   { return __lhs.base() > __rhs.base(); }
00697 
00698   template<typename _IteratorL, typename _IteratorR, typename _Container>
00699   inline bool
00700   operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
00701          const __normal_iterator<_IteratorR, _Container>& __rhs)
00702   { return __lhs.base() <= __rhs.base(); }
00703 
00704   template<typename _Iterator, typename _Container>
00705   inline bool
00706   operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
00707          const __normal_iterator<_Iterator, _Container>& __rhs)
00708   { return __lhs.base() <= __rhs.base(); }
00709 
00710   template<typename _IteratorL, typename _IteratorR, typename _Container>
00711   inline bool
00712   operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
00713          const __normal_iterator<_IteratorR, _Container>& __rhs)
00714   { return __lhs.base() >= __rhs.base(); }
00715 
00716   template<typename _Iterator, typename _Container>
00717   inline bool
00718   operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
00719          const __normal_iterator<_Iterator, _Container>& __rhs)
00720   { return __lhs.base() >= __rhs.base(); }
00721 
00722   template<typename _Iterator, typename _Container>
00723   inline __normal_iterator<_Iterator, _Container>
00724   operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
00725         const __normal_iterator<_Iterator, _Container>& __i)
00726   { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
00727 } // namespace __gnu_cxx
00728 
00729 #endif 
00730 
00731 // Local Variables:
00732 // mode:C++
00733 // End:

Generated on Wed May 1 19:19:36 2002 for libstdc++-v3 Source by doxygen1.2.15