1/* Copyright 2003-2013 Joaquin M Lopez Munoz.
2 * Distributed under the Boost Software License, Version 1.0.
3 * (See accompanying file LICENSE_1_0.txt or copy at
4 * http://www.boost.org/LICENSE_1_0.txt)
5 *
6 * See http://www.boost.org/libs/multi_index for library home page.
7 */
8
9#ifndef BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
10#define BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
11
12#if defined(_MSC_VER)
13#pragma once
14#endif
15
16#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
17#include <boost/mpl/apply.hpp>
18#include <boost/operators.hpp>
19
20namespace boost{
21
22namespace multi_index{
23
24namespace detail{
25
26/* Poor man's version of boost::iterator_adaptor. Used instead of the
27 * original as compile times for the latter are significantly higher.
28 * The interface is not replicated exactly, only to the extent necessary
29 * for internal consumption.
30 */
31
32/* NB. The purpose of the (non-inclass) global operators ==, < and - defined
33 * above is to partially alleviate a problem of MSVC++ 6.0 by * which
34 * friend-injected operators on T are not visible if T is instantiated only
35 * in template code where T is a dependent type.
36 */
37
38class iter_adaptor_access
39{
40public:
41 template<class Class>
42 static typename Class::reference dereference(const Class& x)
43 {
44 return x.dereference();
45 }
46
47 template<class Class>
48 static bool equal(const Class& x,const Class& y)
49 {
50 return x.equal(y);
51 }
52
53 template<class Class>
54 static void increment(Class& x)
55 {
56 x.increment();
57 }
58
59 template<class Class>
60 static void decrement(Class& x)
61 {
62 x.decrement();
63 }
64
65 template<class Class>
66 static void advance(Class& x,typename Class::difference_type n)
67 {
68 x.advance(n);
69 }
70
71 template<class Class>
72 static typename Class::difference_type distance_to(
73 const Class& x,const Class& y)
74 {
75 return x.distance_to(y);
76 }
77};
78
79template<typename Category>
80struct iter_adaptor_selector;
81
82template<class Derived,class Base>
83class forward_iter_adaptor_base:
84 public forward_iterator_helper<
85 Derived,
86 typename Base::value_type,
87 typename Base::difference_type,
88 typename Base::pointer,
89 typename Base::reference>
90{
91public:
92 typedef typename Base::reference reference;
93
94 reference operator*()const
95 {
96 return iter_adaptor_access::dereference(final());
97 }
98
99 friend bool operator==(const Derived& x,const Derived& y)
100 {
101 return iter_adaptor_access::equal(x,y);
102 }
103
104 Derived& operator++()
105 {
106 iter_adaptor_access::increment(final());
107 return final();
108 }
109
110private:
111 Derived& final(){return *static_cast<Derived*>(this);}
112 const Derived& final()const{return *static_cast<const Derived*>(this);}
113};
114
115template<class Derived,class Base>
116bool operator==(
117 const forward_iter_adaptor_base<Derived,Base>& x,
118 const forward_iter_adaptor_base<Derived,Base>& y)
119{
120 return iter_adaptor_access::equal(
121 static_cast<const Derived&>(x),static_cast<const Derived&>(y));
122}
123
124template<>
125struct iter_adaptor_selector<std::forward_iterator_tag>
126{
127 template<class Derived,class Base>
128 struct apply
129 {
130 typedef forward_iter_adaptor_base<Derived,Base> type;
131 };
132};
133
134template<class Derived,class Base>
135class bidirectional_iter_adaptor_base:
136 public bidirectional_iterator_helper<
137 Derived,
138 typename Base::value_type,
139 typename Base::difference_type,
140 typename Base::pointer,
141 typename Base::reference>
142{
143public:
144 typedef typename Base::reference reference;
145
146 reference operator*()const
147 {
148 return iter_adaptor_access::dereference(final());
149 }
150
151 friend bool operator==(const Derived& x,const Derived& y)
152 {
153 return iter_adaptor_access::equal(x,y);
154 }
155
156 Derived& operator++()
157 {
158 iter_adaptor_access::increment(final());
159 return final();
160 }
161
162 Derived& operator--()
163 {
164 iter_adaptor_access::decrement(final());
165 return final();
166 }
167
168private:
169 Derived& final(){return *static_cast<Derived*>(this);}
170 const Derived& final()const{return *static_cast<const Derived*>(this);}
171};
172
173template<class Derived,class Base>
174bool operator==(
175 const bidirectional_iter_adaptor_base<Derived,Base>& x,
176 const bidirectional_iter_adaptor_base<Derived,Base>& y)
177{
178 return iter_adaptor_access::equal(
179 static_cast<const Derived&>(x),static_cast<const Derived&>(y));
180}
181
182template<>
183struct iter_adaptor_selector<std::bidirectional_iterator_tag>
184{
185 template<class Derived,class Base>
186 struct apply
187 {
188 typedef bidirectional_iter_adaptor_base<Derived,Base> type;
189 };
190};
191
192template<class Derived,class Base>
193class random_access_iter_adaptor_base:
194 public random_access_iterator_helper<
195 Derived,
196 typename Base::value_type,
197 typename Base::difference_type,
198 typename Base::pointer,
199 typename Base::reference>
200{
201public:
202 typedef typename Base::reference reference;
203 typedef typename Base::difference_type difference_type;
204
205 reference operator*()const
206 {
207 return iter_adaptor_access::dereference(final());
208 }
209
210 friend bool operator==(const Derived& x,const Derived& y)
211 {
212 return iter_adaptor_access::equal(x,y);
213 }
214
215 friend bool operator<(const Derived& x,const Derived& y)
216 {
217 return iter_adaptor_access::distance_to(x,y)>0;
218 }
219
220 Derived& operator++()
221 {
222 iter_adaptor_access::increment(final());
223 return final();
224 }
225
226 Derived& operator--()
227 {
228 iter_adaptor_access::decrement(final());
229 return final();
230 }
231
232 Derived& operator+=(difference_type n)
233 {
234 iter_adaptor_access::advance(final(),n);
235 return final();
236 }
237
238 Derived& operator-=(difference_type n)
239 {
240 iter_adaptor_access::advance(final(),-n);
241 return final();
242 }
243
244 friend difference_type operator-(const Derived& x,const Derived& y)
245 {
246 return iter_adaptor_access::distance_to(y,x);
247 }
248
249private:
250 Derived& final(){return *static_cast<Derived*>(this);}
251 const Derived& final()const{return *static_cast<const Derived*>(this);}
252};
253
254template<class Derived,class Base>
255bool operator==(
256 const random_access_iter_adaptor_base<Derived,Base>& x,
257 const random_access_iter_adaptor_base<Derived,Base>& y)
258{
259 return iter_adaptor_access::equal(
260 static_cast<const Derived&>(x),static_cast<const Derived&>(y));
261}
262
263template<class Derived,class Base>
264bool operator<(
265 const random_access_iter_adaptor_base<Derived,Base>& x,
266 const random_access_iter_adaptor_base<Derived,Base>& y)
267{
268 return iter_adaptor_access::distance_to(
269 static_cast<const Derived&>(x),static_cast<const Derived&>(y))>0;
270}
271
272template<class Derived,class Base>
273typename random_access_iter_adaptor_base<Derived,Base>::difference_type
274operator-(
275 const random_access_iter_adaptor_base<Derived,Base>& x,
276 const random_access_iter_adaptor_base<Derived,Base>& y)
277{
278 return iter_adaptor_access::distance_to(
279 static_cast<const Derived&>(y),static_cast<const Derived&>(x));
280}
281
282template<>
283struct iter_adaptor_selector<std::random_access_iterator_tag>
284{
285 template<class Derived,class Base>
286 struct apply
287 {
288 typedef random_access_iter_adaptor_base<Derived,Base> type;
289 };
290};
291
292template<class Derived,class Base>
293struct iter_adaptor_base
294{
295 typedef iter_adaptor_selector<
296 typename Base::iterator_category> selector;
297 typedef typename mpl::apply2<
298 selector,Derived,Base>::type type;
299};
300
301template<class Derived,class Base>
302class iter_adaptor:public iter_adaptor_base<Derived,Base>::type
303{
304protected:
305 iter_adaptor(){}
306 explicit iter_adaptor(const Base& b_):b(b_){}
307
308 const Base& base_reference()const{return b;}
309 Base& base_reference(){return b;}
310
311private:
312 Base b;
313};
314
315} /* namespace multi_index::detail */
316
317} /* namespace multi_index */
318
319} /* namespace boost */
320
321#endif
322

source code of boost/libs/multi_index/include/boost/multi_index/detail/iter_adaptor.hpp