OGRE  2.0
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
OgreIteratorWrapper.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2014 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __Ogre_Iterator_Wrapper_H__
29 #define __Ogre_Iterator_Wrapper_H__
30 
31 #include "OgreHeaderPrefix.h"
32 
33 namespace Ogre{
34 
46 template <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 
134 template <typename T, typename IteratorType>
135 class 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 
158  ValueType peekNext ( ) const
159  {
160  return *(this->mCurrent);
161  }
162 
165  {
166  return &(*(this->mCurrent) );
167  }
168 
171  {
172  return *(this->mCurrent++);
173  }
174 
175 };
176 
177 
185 template <typename T>
186 class 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 
216 template <typename T>
217 class 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 
252 template <typename T, typename IteratorType>
253 class 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 
277  KeyType peekNextKey(void) const
278  {
279  return this->mCurrent->first;
280  }
281 
282 
285  {
286  return this->mCurrent->second;
287  }
288 
289 
293  {
294  return &(this->mCurrent->second);
295  }
296 
297 
300  {
301  return ((this->mCurrent++)->second) ;
302  }
303 
304 
305 };
306 
307 
308 
309 
318 template <typename T>
319 class 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 
351 template <typename T>
352 class 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
Basefunctionality for IteratorWrappers.
ValueType getNext()
Returns the next(=current) value element in the collection, and advances to the next.
IteratorWrapper< T, IteratorType, typename T::mapped_type >::ValueType ValueType
Redefined ValueType for a map/set.
const IteratorType & begin()
Bookmark to the begin of the underlying collection.
const PointerType peekNextValuePtr() const
Returns a pointer to the next/current value element in the collection, without advancing to the next ...
T::value_type PairType
Unused, just to make it clear that map/set::value_type is not a ValueType.
IteratorType const_iterator
Typedef to fulfill container interface.
const IteratorType & end()
Bookmark to the end (one behind the last element) of the underlying collection.
IteratorWrapper< T, IteratorType, typename T::value_type >::PointerType PointerType
IteratorType iterator
Typedef to fulfill container interface.
ValueType peekNext() const
Returns the next(=current) element in the collection, without advancing to the next.
Prepared IteratorWrapper for container like std::vector.
IteratorWrapper()
Private constructor since only the parameterised constructor should be used.
IteratorWrapper< T, IteratorType, typename T::value_type >::ValueType ValueType
IteratorType & current()
Full access to the current iterator.
ConstVectorIterator(const T &c)
Constructor.
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
bool hasMoreElements() const
Returns true if there are more items in the collection.
PointerType peekNextPtr() const
Returns a pointer to the next(=current) element in the collection, without advancing to the next afte...
MapIteratorWrapper(IteratorType start, IteratorType last)
Constructor.
T::key_type KeyType
Type you expect to get by funktions like peekNextKey.
MapIterator(typename T::iterator start, typename T::iterator last)
Constructor.
IteratorWrapper(IteratorType start, IteratorType last)
Constructor.
KeyType peekNextKey(void) const
Returns the next(=current) key element in the collection, without advancing to the next...
Concrete IteratorWrapper for const access to the underlying container.
VectorIteratorWrapper(IteratorType start, IteratorType last)
c'tor
IteratorWrapper< T, IteratorType, typename T::mapped_type >::PointerType PointerType
Redefined PointerType for a map/set.
VectorIterator(typename T::iterator start, typename T::iterator last)
Constructor.
ValueType peekNextValue() const
Returns the next(=current) value element in the collection, without advancing to the next...
VectorIterator(T &c)
Constructor.
void moveNext()
Moves the iterator on one element.
Concrete IteratorWrapper for const access to the underlying key-value container.
ConstVectorIterator(typename T::const_iterator start, typename T::const_iterator last)
Constructor.
ValType * PointerType
Type you expect to get by funktions like peekNext(Value)Ptr.
ValueType getNext()
Returns the next(=current) value element in the collection, and advances to the next.
ValType ValueType
Type you expect to get by funktions like peekNext(Value)
Concrete IteratorWrapper for nonconst access to the underlying container.
ConstMapIterator(typename T::const_iterator start, typename T::const_iterator last)
Constructor.
Prepared IteratorWrapper for key-value container.
ConstMapIterator(const T &c)
Constructor.
MapIterator(T &c)
Constructor.