Line data Source code
1 : #ifndef VSET_VTREE_VTREE_ITERATOR_HPP
2 : #define VSET_VTREE_VTREE_ITERATOR_HPP
3 :
4 : namespace vset{ namespace vtree{
5 :
6 : template<typename T>
7 : struct mapped_type_helper
8 : {
9 : typedef typename T::value_type value_type;
10 : };
11 :
12 : template<typename T>
13 : struct mapped_type_helper<T*>
14 : {
15 : typedef T value_type;
16 : };
17 :
18 : template<typename SourceIterator, typename ValueType>
19 : class vtree_iterator
20 : {
21 : public:
22 : typedef vtree_iterator<SourceIterator, ValueType> self;
23 : typedef SourceIterator source_iterator;
24 : typedef typename source_iterator::value_type source_value_type;
25 : typedef typename source_value_type::first_type source_key_type;
26 : typedef typename source_value_type::second_type source_mapped_type;
27 :
28 : typedef typename mapped_type_helper<source_mapped_type>::value_type array_type;
29 :
30 : typedef typename array_type::value_type array_value_type;
31 : typedef typename array_type::size_type size_type;
32 :
33 : typedef typename std::iterator_traits<array_value_type*>::iterator_category iterator_category;
34 : typedef typename std::iterator_traits<ValueType*>::value_type value_type;
35 : typedef typename std::iterator_traits<ValueType*>::difference_type difference_type;
36 : typedef typename std::iterator_traits<ValueType*>::pointer pointer;
37 : typedef typename std::iterator_traits<ValueType*>::reference reference;
38 :
39 1 : vtree_iterator()
40 : : _itr()
41 1 : , _pos(0)
42 : {
43 :
44 1 : }
45 :
46 : // cctor
47 344280 : vtree_iterator(const self& slf)
48 : : _itr(slf._itr )
49 344280 : , _pos(slf._pos )
50 : {
51 344280 : }
52 :
53 16866 : vtree_iterator& operator=(const self& slf)
54 : {
55 16866 : _itr = slf._itr;
56 16866 : _pos = slf._pos;
57 16866 : return *this;
58 : }
59 :
60 179152 : vtree_iterator(const source_iterator& itr, difference_type pos)
61 : : _itr(itr)
62 179152 : , _pos(pos)
63 : {
64 179152 : }
65 :
66 :
67 : template<typename TI, typename VT>
68 50562 : /*explicit*/ vtree_iterator(const vtree_iterator<TI, VT>& oth)
69 : : _itr( oth.get_source_iterator() )
70 50562 : , _pos( oth.get_position() )
71 : {
72 50562 : }
73 :
74 : template<typename TI, typename VT>
75 : vtree_iterator& operator=(const vtree_iterator<TI, VT>& oth)
76 : {
77 : _itr = oth.get_source_iterator();
78 : _pos = oth.get_position();
79 : return *this;
80 : }
81 :
82 :
83 19285 : reference operator*() const
84 : {
85 19285 : return _itr->second->at( static_cast<size_type>(_pos) );
86 : }
87 :
88 12 : pointer operator->() const
89 : {
90 12 : return &*(_itr->second->begin() + _pos);
91 : }
92 :
93 14557 : self& operator++()
94 : {
95 14557 : ++_pos;
96 14557 : if ( _itr->second->size() == static_cast<size_t>(_pos))
97 : {
98 13286 : ++_itr;
99 13286 : _pos = 0;
100 : }
101 14557 : return *this;
102 : }
103 :
104 : self operator++(int)
105 : {
106 : self ans = *this;
107 : this->operator++();
108 : return ans;
109 : }
110 :
111 918 : self& operator--()
112 : {
113 918 : if ( _pos == 0 )
114 : {
115 14 : --_itr;
116 14 : _pos = static_cast<difference_type>( _itr->second->size() ) - 1;
117 : }
118 : else
119 : {
120 904 : --_pos;
121 : }
122 918 : return *this;
123 : }
124 :
125 : self operator--(int)
126 : {
127 : self ans = *this;
128 : this->operator--();
129 : return ans;
130 : }
131 :
132 206 : self& operator += (difference_type n )
133 : {
134 206 : if ( n >= static_cast<difference_type>( _itr->second->size() ) - _pos )
135 : {
136 2 : n -= static_cast<difference_type>(_itr->second->size()) - _pos;
137 2 : ++_itr;
138 2 : _pos = 0;
139 :
140 4 : while ( n >= static_cast<difference_type>( _itr->second->size() ) )
141 : {
142 0 : n -= static_cast<difference_type>( _itr->second->size() );
143 0 : ++_itr;
144 0 : _pos = 0;
145 : }
146 : }
147 206 : _pos += n;
148 206 : return *this;
149 : }
150 :
151 : self& operator -= (difference_type n )
152 : {
153 : if ( n > _pos )
154 : {
155 : n -= _pos;
156 : --_itr;
157 : _pos = _itr->second->size() - 1;
158 :
159 : while ( n >= static_cast<difference_type>( _itr->second->size() ) )
160 : {
161 : n -= _itr->second->size();
162 : --_itr;
163 : _pos = _itr->second->size() - 1;
164 : }
165 : }
166 : _pos -= n;
167 : return *this;
168 : }
169 :
170 47895 : bool operator == (const self& r ) const
171 : {
172 47895 : return _pos == r._pos && _itr == r._itr;
173 : }
174 :
175 994 : bool operator != (const self& r ) const
176 : {
177 994 : return !this->operator == (r);
178 : }
179 :
180 : bool operator < (const self& r ) const
181 : {
182 : if ( _itr < r._itr ) return true;
183 : return _pos < r._pos;
184 : }
185 :
186 : bool operator > (const self& r ) const
187 : {
188 : if ( _itr > r._itr ) return true;
189 : return _pos > r._pos;
190 : }
191 :
192 : bool operator <= (const self& r ) const
193 : {
194 : return !this->operator >( r );
195 : }
196 :
197 : bool operator >= (const self& r ) const
198 : {
199 : return !this->operator < ( r );
200 : }
201 :
202 : reference operator[] ( difference_type n ) const
203 : {
204 : self ans = *this;
205 : ans += n;
206 : return *ans;
207 : }
208 :
209 : template<typename TI, typename VT>
210 : friend typename vtree_iterator<TI, VT>::difference_type operator - ( vtree_iterator<TI, VT> r1, vtree_iterator<TI, VT> r2 );
211 :
212 101125 : source_iterator get_source_iterator() const
213 : {
214 101125 : return this->_itr;
215 : }
216 :
217 67418 : difference_type get_position() const
218 : {
219 67418 : return this->_pos;
220 : }
221 :
222 : private:
223 : source_iterator _itr;
224 : difference_type _pos;
225 : };
226 :
227 : template<typename TI, typename VT, typename Dist>
228 205 : inline vtree_iterator<TI, VT> operator +
229 : (
230 : vtree_iterator<TI, VT> r,
231 : Dist n
232 : )
233 : {
234 205 : return r+=n;
235 : }
236 :
237 : template<typename TI, typename VT, typename Dist>
238 : inline vtree_iterator<TI, VT> operator +
239 : (
240 : Dist n,
241 : vtree_iterator<TI, VT> r
242 : )
243 : {
244 : return r+= n;
245 : }
246 :
247 : template<typename TI, typename VT, typename Dist>
248 : inline vtree_iterator<TI, VT> operator -
249 : (
250 : vtree_iterator<TI, VT> r,
251 : Dist n
252 : )
253 : {
254 : return r-= n;
255 : }
256 :
257 : template<typename TI, typename VT, typename Dist>
258 : inline vtree_iterator<TI, VT> operator -
259 : (
260 : Dist n,
261 : vtree_iterator<TI, VT> r
262 : )
263 : {
264 : return r -= n;
265 : }
266 :
267 : template<typename TI, typename VT>
268 43944 : inline typename vtree_iterator<TI, VT>::difference_type operator -
269 : (
270 : vtree_iterator<TI, VT> r1,
271 : vtree_iterator<TI, VT> r2
272 : )
273 : {
274 : typedef typename vtree_iterator<TI, VT>::difference_type difference_type;
275 43944 : if ( r1._itr == r2._itr )
276 : {
277 23860 : return r1._pos - r2._pos;
278 : }
279 :
280 20084 : typename vtree_iterator<TI, VT>::source_iterator titr = r2._itr;
281 20084 : difference_type result = static_cast<difference_type>(titr->second->size()) - r2._pos;
282 :
283 20089 : for ( ++titr; titr != r1._itr; ++titr )
284 : {
285 5 : result += static_cast<difference_type>( titr->second->size() );
286 : }
287 :
288 20084 : result += r1._pos;
289 20084 : return result;
290 : }
291 :
292 : }}
293 :
294 : #endif
295 :
|
