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