OgreIteratorWrapper.h
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4(Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2013 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE SOFTWARE.
26-----------------------------------------------------------------------------
27*/
28#ifndef __Ogre_Iterator_Wrapper_H__
29#define __Ogre_Iterator_Wrapper_H__
30
31#include "OgreHeaderPrefix.h"
32
33namespace Ogre{
34
46template <typename T, typename IteratorType, typename ValType>
48{
49
50 private:
53
54 protected:
55 IteratorType mBegin;
56 IteratorType mCurrent;
57 IteratorType mEnd;
58
59
60 public:
61
63 typedef ValType ValueType;
65 typedef ValType* PointerType;
66
74 typedef IteratorType iterator;
75
83 typedef IteratorType const_iterator;
84
85
90 IteratorWrapper ( IteratorType start, IteratorType last )
91 : mBegin( start ), mCurrent ( start ), mEnd ( last )
92 {
93 }
94
95
97 bool hasMoreElements ( ) const
98 {
99 return mCurrent != mEnd;
100 }
101
102
104 void moveNext ( )
105 {
106 ++mCurrent;
107 }
108
110 const IteratorType& begin() {return mBegin;}
111
112
114 IteratorType& current(){return mCurrent;}
115
117 const IteratorType& end() {return mEnd;}
118
119
120};
121
122
123
134template <typename T, typename IteratorType>
135class VectorIteratorWrapper : public IteratorWrapper<T, IteratorType, typename T::value_type>
136{
137
138 public:
141
142
151 VectorIteratorWrapper ( IteratorType start, IteratorType last )
152 : IteratorWrapper<T, IteratorType, typename T::value_type>( start, last )
153 {
154 }
155
156
159 {
160 return *(this->mCurrent);
161 }
162
164 PointerType peekNextPtr ( ) const
165 {
166 return &(*(this->mCurrent) );
167 }
168
170 ValueType getNext ( )
171 {
172 return *(this->mCurrent++);
173 }
174
175};
176
177
185template <typename T>
186class VectorIterator : public VectorIteratorWrapper<T, typename T::iterator>{
187 public:
192 VectorIterator( typename T::iterator start, typename T::iterator last )
193 : VectorIteratorWrapper<T, typename T::iterator>(start , last )
194 {
195 }
196
201 explicit VectorIterator( T& c )
202 : VectorIteratorWrapper<T, typename T::iterator> ( c.begin(), c.end() )
203 {
204 }
205
206};
207
216template <typename T>
217class ConstVectorIterator : public VectorIteratorWrapper<T, typename T::const_iterator>{
218 public:
223 ConstVectorIterator( typename T::const_iterator start, typename T::const_iterator last )
224 : VectorIteratorWrapper<T, typename T::const_iterator> (start , last )
225 {
226 }
227
232 explicit ConstVectorIterator ( const T& c )
233 : VectorIteratorWrapper<T, typename T::const_iterator> (c.begin() , c.end() )
234 {
235 }
236};
237
238
239
240
241
252template <typename T, typename IteratorType>
253class MapIteratorWrapper : public IteratorWrapper<T, IteratorType, typename T::mapped_type>
254{
255
256 public:
261
263 typedef typename T::value_type PairType ;
265 typedef typename T::key_type KeyType;
266
271 MapIteratorWrapper ( IteratorType start, IteratorType last )
272 : IteratorWrapper<T, IteratorType, typename T::mapped_type>( start, last )
273 {
274 }
275
278 {
279 return this->mCurrent->first;
280 }
281
282
284 ValueType peekNextValue ( ) const
285 {
286 return this->mCurrent->second;
287 }
288
289
292 const PointerType peekNextValuePtr ( ) const
293 {
294 return &(this->mCurrent->second);
295 }
296
297
299 ValueType getNext()
300 {
301 return ((this->mCurrent++)->second) ;
302 }
303
304
305};
306
307
308
309
318template <typename T>
319class MapIterator : public MapIteratorWrapper<T, typename T::iterator>{
320 public:
321
326 MapIterator( typename T::iterator start, typename T::iterator last )
327 : MapIteratorWrapper<T, typename T::iterator>(start , last )
328 {
329 }
330
335 explicit MapIterator( T& c )
336 : MapIteratorWrapper<T, typename T::iterator> ( c.begin(), c.end() )
337 {
338 }
339
340};
341
342
351template <typename T>
352class ConstMapIterator : public MapIteratorWrapper<T, typename T::const_iterator>{
353 public:
354
359 ConstMapIterator( typename T::const_iterator start, typename T::const_iterator last )
360 : MapIteratorWrapper<T, typename T::const_iterator> (start , last )
361 {
362 }
363
368 explicit ConstMapIterator ( const T& c )
369 : MapIteratorWrapper<T, typename T::const_iterator> (c.begin() , c.end() )
370 {
371 }
372};
373
374
375
376
377}
378
379#include "OgreHeaderSuffix.h"
380
381#endif
Concrete IteratorWrapper for const access to the underlying key-value container.
ConstMapIterator(typename T::const_iterator start, typename T::const_iterator last)
Constructor.
ConstMapIterator(const T &c)
Constructor.
Concrete IteratorWrapper for const access to the underlying container.
ConstVectorIterator(const T &c)
Constructor.
ConstVectorIterator(typename T::const_iterator start, typename T::const_iterator last)
Constructor.
Basefunctionality for IteratorWrappers.
IteratorType iterator
Typedef to fulfill container interface.
const IteratorType & begin()
Bookmark to the begin of the underlying collection.
IteratorType & current()
Full access to the current iterator.
IteratorType const_iterator
Typedef to fulfill container interface.
ValType * PointerType
Type you expect to get by funktions like peekNext(Value)Ptr.
ValType ValueType
Type you expect to get by funktions like peekNext(Value)
const IteratorType & end()
Bookmark to the end (one behind the last element) of the underlying collection.
IteratorWrapper()
Private constructor since only the parameterised constructor should be used.
IteratorWrapper(IteratorType start, IteratorType last)
Constructor.
void moveNext()
Moves the iterator on one element.
bool hasMoreElements() const
Returns true if there are more items in the collection.
Prepared IteratorWrapper for key-value container.
KeyType peekNextKey(void) const
Returns the next(=current) key element in the collection, without advancing to the next.
ValueType getNext()
Returns the next(=current) value element in the collection, and advances to the next.
MapIteratorWrapper(IteratorType start, IteratorType last)
Constructor.
IteratorWrapper< T, IteratorType, typenameT::mapped_type >::ValueType ValueType
Redefined ValueType for a map/set.
T::value_type PairType
Unused, just to make it clear that map/set::value_type is not a ValueType.
const PointerType peekNextValuePtr() const
Returns a pointer to the next/current value element in the collection, without advancing to the next ...
ValueType peekNextValue() const
Returns the next(=current) value element in the collection, without advancing to the next.
T::key_type KeyType
Type you expect to get by funktions like peekNextKey.
IteratorWrapper< T, IteratorType, typenameT::mapped_type >::PointerType PointerType
Redefined PointerType for a map/set.
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
MapIterator(typename T::iterator start, typename T::iterator last)
Constructor.
MapIterator(T &c)
Constructor.
Prepared IteratorWrapper for container like std::vector.
ValueType getNext()
Returns the next(=current) value element in the collection, and advances to the next.
IteratorWrapper< T, IteratorType, typenameT::value_type >::ValueType ValueType
VectorIteratorWrapper(IteratorType start, IteratorType last)
c'tor
IteratorWrapper< T, IteratorType, typenameT::value_type >::PointerType PointerType
PointerType peekNextPtr() const
Returns a pointer to the next(=current) element in the collection, without advancing to the next afte...
ValueType peekNext() const
Returns the next(=current) element in the collection, without advancing to the next.
Concrete IteratorWrapper for nonconst access to the underlying container.
VectorIterator(typename T::iterator start, typename T::iterator last)
Constructor.
VectorIterator(T &c)
Constructor.

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.