Attempt to represent the S^2->S^3 header reorganisation as a series of "hg rename" operations
1 /* Copyright 2003-2005 Joaquín M López Muñoz.
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)
6 * See http://www.boost.org/libs/multi_index for library home page.
9 #ifndef BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
10 #define BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
12 #if defined(_MSC_VER)&&(_MSC_VER>=1200)
16 #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
17 #include <boost/mpl/apply.hpp>
18 #include <boost/multi_index/detail/prevent_eti.hpp>
19 #include <boost/operators.hpp>
23 namespace multi_index{
27 /* Poor man's version of boost::iterator_adaptor. Used instead of the
28 * original as compile times for the latter are significantly higher.
29 * The interface is not replicated exactly, only to the extent necessary
30 * for internal consumption.
33 class iter_adaptor_access
37 static typename Class::reference dereference(const Class& x)
39 return x.dereference();
43 static bool equal(const Class& x,const Class& y)
49 static void increment(Class& x)
55 static void decrement(Class& x)
61 static void advance(Class& x,typename Class::difference_type n)
67 static typename Class::difference_type distance_to(
68 const Class& x,const Class& y)
70 return x.distance_to(y);
74 template<typename Category>
75 struct iter_adaptor_selector;
77 template<class Derived,class Base>
78 class forward_iter_adaptor_base:
79 public forward_iterator_helper<
81 typename Base::value_type,
82 typename Base::difference_type,
83 typename Base::pointer,
84 typename Base::reference>
87 typedef typename Base::reference reference;
89 reference operator*()const
91 return iter_adaptor_access::dereference(final());
94 friend bool operator==(const Derived& x,const Derived& y)
96 return iter_adaptor_access::equal(x,y);
101 iter_adaptor_access::increment(final());
106 Derived& final(){return *static_cast<Derived*>(this);}
107 const Derived& final()const{return *static_cast<const Derived*>(this);}
111 struct iter_adaptor_selector<std::forward_iterator_tag>
113 template<class Derived,class Base>
116 typedef forward_iter_adaptor_base<Derived,Base> type;
120 template<class Derived,class Base>
121 class bidirectional_iter_adaptor_base:
122 public bidirectional_iterator_helper<
124 typename Base::value_type,
125 typename Base::difference_type,
126 typename Base::pointer,
127 typename Base::reference>
130 typedef typename Base::reference reference;
132 reference operator*()const
134 return iter_adaptor_access::dereference(final());
137 friend bool operator==(const Derived& x,const Derived& y)
139 return iter_adaptor_access::equal(x,y);
142 Derived& operator++()
144 iter_adaptor_access::increment(final());
148 Derived& operator--()
150 iter_adaptor_access::decrement(final());
155 Derived& final(){return *static_cast<Derived*>(this);}
156 const Derived& final()const{return *static_cast<const Derived*>(this);}
160 struct iter_adaptor_selector<std::bidirectional_iterator_tag>
162 template<class Derived,class Base>
165 typedef bidirectional_iter_adaptor_base<Derived,Base> type;
169 template<class Derived,class Base>
170 class random_access_iter_adaptor_base:
171 public random_access_iterator_helper<
173 typename Base::value_type,
174 typename Base::difference_type,
175 typename Base::pointer,
176 typename Base::reference>
179 typedef typename Base::reference reference;
180 typedef typename Base::difference_type difference_type;
182 reference operator*()const
184 return iter_adaptor_access::dereference(final());
187 friend bool operator==(const Derived& x,const Derived& y)
189 return iter_adaptor_access::equal(x,y);
192 friend bool operator<(const Derived& x,const Derived& y)
194 return iter_adaptor_access::distance_to(x,y)>0;
197 Derived& operator++()
199 iter_adaptor_access::increment(final());
203 Derived& operator--()
205 iter_adaptor_access::decrement(final());
209 Derived& operator+=(difference_type n)
211 iter_adaptor_access::advance(final(),n);
215 Derived& operator-=(difference_type n)
217 iter_adaptor_access::advance(final(),-n);
221 friend difference_type operator-(const Derived& x,const Derived& y)
223 return iter_adaptor_access::distance_to(y,x);
227 Derived& final(){return *static_cast<Derived*>(this);}
228 const Derived& final()const{return *static_cast<const Derived*>(this);}
232 struct iter_adaptor_selector<std::random_access_iterator_tag>
234 template<class Derived,class Base>
237 typedef random_access_iter_adaptor_base<Derived,Base> type;
241 template<class Derived,class Base>
242 struct iter_adaptor_base
244 typedef iter_adaptor_selector<
245 typename Base::iterator_category> selector;
246 typedef typename prevent_eti<
248 typename mpl::apply2<
249 selector,Derived,Base>::type
253 template<class Derived,class Base>
254 class iter_adaptor:public iter_adaptor_base<Derived,Base>::type
258 explicit iter_adaptor(const Base& b_):b(b_){}
260 const Base& base_reference()const{return b;}
261 Base& base_reference(){return b;}
267 } /* namespace multi_index::detail */
269 } /* namespace multi_index */
271 } /* namespace boost */