ListListIterator.h

Go to the documentation of this file.
00001 #ifndef LISTLIST_ITERATOR_H
00002 #define LISTLIST_ITERATOR_H
00003 
00004 #include "y2storage/AppUtil.h"
00005 #include "y2storage/IterPair.h"
00006 
00007 namespace storage
00008 {
00009 
00010 template< class PIter, class Iter > 
00011 class ListListIterator : public PIter
00012     {
00013     public:
00014         typedef typename PIter::value_type value_type;
00015         typedef typename PIter::reference reference;
00016         typedef typename PIter::pointer pointer;
00017         typedef typename PIter::difference_type difference_type;
00018         typedef typename PIter::iterator_category iterator_category;
00019 
00020         ListListIterator() { }
00021 
00022         ListListIterator( const Iter& begin, const Iter& end, bool setend=false ) : 
00023             m_lcur(begin)
00024             {
00025             initialize( begin, end, setend );
00026             }
00027 
00028         ListListIterator( const IterPair<Iter>& p, bool setend=false ) : 
00029             m_lcur(p.begin())
00030             {
00031             initialize( p.begin(), p.end(), setend );
00032             }
00033 
00034         ListListIterator( const ListListIterator& x ) 
00035             {
00036             copyMembers( x );
00037             }
00038 
00039         ListListIterator& operator=(const ListListIterator& x)
00040             { 
00041             copyMembers( x );
00042             return *this; 
00043             }
00044 
00045         ListListIterator& operator++()
00046             { 
00047             increment();
00048             return *this; 
00049             }
00050         ListListIterator operator++(int)
00051             {
00052             y2warning( "Expensive ++ ListListIterator" );
00053             ListListIterator tmp(*this); 
00054             increment();
00055             return tmp;
00056             }
00057 
00058         ListListIterator& operator--()
00059             { 
00060             decrement();
00061             return *this; 
00062             }
00063         ListListIterator operator--(int)
00064             {
00065             y2warning( "Expensive -- ListListIterator" );
00066             ListListIterator tmp(*this); 
00067             decrement();
00068             return tmp;
00069             }
00070 
00071         reference operator*() const 
00072             {
00073             return( *m_pcur );
00074             }
00075 
00076         pointer operator->() const 
00077             {
00078             return( &(*m_pcur) );
00079             }
00080         bool operator==(const ListListIterator& x) const
00081             {
00082             return( m_pcur == x.pcur() );
00083             }
00084         bool operator!=(const ListListIterator& x) const
00085             {
00086             return( m_pcur != x.pcur() );
00087             }
00088 
00089         PIter end() const {return m_end;}
00090         PIter begin() const {return m_begin;}
00091         PIter pcur() const {return m_pcur;}
00092         Iter cur() const {return m_lcur;}
00093 
00094     private:
00095         PIter m_begin;
00096         PIter m_end;
00097         Iter m_lcur;
00098         PIter m_pcur;
00099         static const PIter empty;
00100 
00101         void copyMembers( const ListListIterator& x ) 
00102             { 
00103             m_begin = x.begin();
00104             m_end = x.end();
00105             m_lcur = x.cur();
00106             m_pcur = x.pcur();
00107             }
00108 
00109         void increment() 
00110             {
00111             if( m_pcur != m_end ) 
00112                 {
00113                 ++m_pcur;
00114                 while( m_pcur!=m_end && m_pcur == m_lcur->end() )
00115                     {
00116                     ++m_lcur;
00117                     m_pcur = m_lcur->begin();
00118                     }
00119                 }
00120             };
00121 
00122         void decrement() 
00123             {
00124             if( m_pcur != m_begin ) 
00125                 {
00126                 if( m_pcur != m_lcur->begin() )
00127                     {
00128                     --m_pcur;
00129                     }
00130                 else 
00131                     {
00132                     do
00133                         {
00134                         --m_lcur;
00135                         m_pcur = --(m_lcur->end());
00136                         }
00137                     while( m_pcur!=m_begin && 
00138                            m_lcur->begin()==m_lcur->end() );
00139                     }
00140                 }
00141             };
00142 
00143         void initialize( const Iter& begin, const Iter& end, bool setend )
00144             {
00145             m_begin = m_end = m_pcur = empty;
00146             while( m_lcur != end && m_lcur->begin()==m_lcur->end() )
00147                 {
00148                 ++m_lcur;
00149                 }
00150             if( m_lcur != end )
00151                 m_begin = m_lcur->begin();
00152             if( begin != end )
00153                 {
00154                 Iter tmp = end;
00155                 --tmp;
00156                 while( tmp != begin && tmp->begin()==tmp->end() )
00157                     {
00158                     --tmp;
00159                     }
00160                 if( tmp != begin || begin->begin()!=begin->end())
00161                     {
00162                     m_end = tmp->end();
00163                     }
00164                 if( setend )
00165                     {
00166                     m_pcur = m_end;
00167                     m_lcur = tmp;
00168                     }
00169                 else
00170                     m_pcur = m_begin;
00171                 }
00172             }
00173 
00174     };
00175 
00176 template< typename PIter, typename Iter > const PIter ListListIterator<PIter,Iter>::empty = PIter();
00177 
00178 }
00179 
00180 #endif

Generated on Thu Jul 6 00:40:24 2006 for yast2-storage by  doxygen 1.4.6