00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 
00025 
00026 
00027 
00028 
00029 
00030 
00031 
00032 
00033 
00034 
00035 
00036 
00037 
00038 
00039 
00040 
00041 
00042 
00043 
00044 
00045 
00046 
00047 
00048 
00049 
00050 
00051 
00052 
00053 
00054 
00055 
00065 #ifndef __GLIBCPP_INTERNAL_ITERATOR_H
00066 #define __GLIBCPP_INTERNAL_ITERATOR_H
00067 
00068 namespace std
00069 {
00070   
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   
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 } 
00552 
00553 namespace __gnu_cxx
00554 {  
00555   
00556   
00557   
00558   
00559   
00560   
00561   
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       
00587       template<typename _Iter>
00588       inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
00589     : _M_current(__i.base()) { }
00590 
00591       
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       
00605       __normal_iterator&
00606       operator--() { --_M_current; return *this; }
00607       
00608       __normal_iterator
00609       operator--(int) { return __normal_iterator(_M_current--); }
00610       
00611       
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   
00641   
00642   
00643   
00644   
00645   
00646   
00647   
00648   
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   
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 } 
00728 
00729 #endif 
00730 
00731 
00732 
00733