[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

iteratorfacade.hxx
1/************************************************************************/
2/* */
3/* Copyright 2014 by Thorsten Beier */
4/* */
5/* This file is part of the VIGRA computer vision library. */
6/* The VIGRA Website is */
7/* http://hci.iwr.uni-heidelberg.de/vigra/ */
8/* Please direct questions, bug reports, and contributions to */
9/* ullrich.koethe@iwr.uni-heidelberg.de or */
10/* vigra@informatik.uni-hamburg.de */
11/* */
12/* Permission is hereby granted, free of charge, to any person */
13/* obtaining a copy of this software and associated documentation */
14/* files (the "Software"), to deal in the Software without */
15/* restriction, including without limitation the rights to use, */
16/* copy, modify, merge, publish, distribute, sublicense, and/or */
17/* sell copies of the Software, and to permit persons to whom the */
18/* Software is furnished to do so, subject to the following */
19/* conditions: */
20/* */
21/* The above copyright notice and this permission notice shall be */
22/* included in all copies or substantial portions of the */
23/* Software. */
24/* */
25/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27/* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28/* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29/* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30/* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31/* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32/* OTHER DEALINGS IN THE SOFTWARE. */
33/* */
34/************************************************************************/
35#ifndef VIGRA_ITERATORFACADE_HXX
36#define VIGRA_ITERATORFACADE_HXX
37
38/*std*/
39#include <iterator>
40
41/*vigra*/
42#include "metaprogramming.hxx"
43
44namespace vigra {
45
46// facade needs to make this class
47// a friend class
48class IteratorFacadeCoreAccess{
49public:
50 template<class F>
51 static bool equal(const F & fa,const F & fb){
52 return fa.equal(fb);
53 }
54
55 template<class F,class REFERENCE>
56 static REFERENCE dereference(const F & f){
57 return f.dereference();
58 }
59
60 template<class F>
61 static void increment(F & f){
62 f.increment();
63 }
64};
65
66
67// see boost iterator facade
68template<class FACADE,class VALUE_TYPE,bool IS_CONST = true>
69class ForwardIteratorFacade{
70private:
71
72public:
73
74 typedef std::forward_iterator_tag iterator_category;
75 typedef typename UnqualifiedType<VALUE_TYPE>::type value_type;
76 typedef typename IfBool<IS_CONST, value_type const * , value_type *>::type pointer;
77 typedef typename IfBool<IS_CONST, const value_type & , value_type &>::type reference;
78 typedef std::ptrdiff_t difference_type;
79
80
81 FACADE & operator++()
82 {
83 IteratorFacadeCoreAccess::increment(getF());
84 return getF();
85 }
86
87 FACADE operator++(int)
88 {
89 FACADE res(getF());
90 IteratorFacadeCoreAccess::increment(getF());
91 return res;
92 }
93
94 bool operator ==(const FACADE & f)const{
95 return IteratorFacadeCoreAccess::equal(getF(),f);
96 }
97 bool operator !=(const FACADE & f)const{
98 return !IteratorFacadeCoreAccess::equal(getF(),f);
99 }
100
101 reference operator*()const{
102 return IteratorFacadeCoreAccess:: template dereference<FACADE,reference>(getF());
103 }
104
105 pointer operator->()const{
106 return &IteratorFacadeCoreAccess:: template dereference<FACADE,reference>(getF());
107 }
108
109private:
110
111
112 const FACADE & getF()const{
113 return *static_cast<FACADE const *>(this);
114 }
115 FACADE & getF(){
116 return *static_cast<FACADE *>(this);
117 }
118};
119
120template<class MAP>
121class MapKeyIterator
122 : public ForwardIteratorFacade<MapKeyIterator<MAP>,typename MAP::key_type,true>
123{
124
125public:
126 typedef ForwardIteratorFacade<MapKeyIterator<MAP>,typename MAP::key_type,true> BaseType;
127 typedef typename MAP::const_iterator InternalIterator;
128 typedef typename BaseType::value_type value_type;
129 typedef typename BaseType::reference reference;
130 typedef typename BaseType::pointer pointer;
131
132 MapKeyIterator(InternalIterator i)
133 : iter_(i)
134 {}
135
136 private:
137
138 friend class IteratorFacadeCoreAccess;
139
140 bool equal(const MapKeyIterator & other) const{
141 return iter_ == other.iter_;
142 }
143
144 void increment(){
145 ++iter_;
146 }
147
148 reference dereference()const{
149 return iter_->first;
150 }
151
152 InternalIterator iter_;
153};
154
155template <class MAP>
156inline MapKeyIterator<MAP>
157key_begin(MAP const & m)
158{
159 return MapKeyIterator<MAP>(m.begin());
160
161}
162
163template <class MAP>
164inline MapKeyIterator<MAP>
165key_end(MAP const & m)
166{
167 return MapKeyIterator<MAP>(m.end());
168
169}
170
171} // namespace vigra
172
173
174#endif /* VIGRA_ITERATORFACADE_HXX */
Base::value_type value_type
Definition rgbvalue.hxx:141

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.12.2