Boost GIL


step_iterator.hpp
1 //
2 // Copyright 2005-2007 Adobe Systems Incorporated
3 //
4 // Distributed under the Boost Software License, Version 1.0
5 // See accompanying file LICENSE_1_0.txt or copy at
6 // http://www.boost.org/LICENSE_1_0.txt
7 //
8 #ifndef BOOST_GIL_STEP_ITERATOR_HPP
9 #define BOOST_GIL_STEP_ITERATOR_HPP
10 
11 #include <boost/gil/pixel_iterator.hpp>
12 #include <boost/gil/pixel_iterator_adaptor.hpp>
13 #include <boost/gil/utilities.hpp>
14 
15 #include <boost/iterator/iterator_facade.hpp>
16 
17 #include <cstddef>
18 #include <iterator>
19 
20 namespace boost { namespace gil {
21 
25 
26 namespace detail {
27 
34 
35 template <typename Derived, // type of the derived class
36  typename Iterator, // Models Iterator
37  typename SFn> // A policy object that can compute the distance between two iterators of type Iterator
38  // and can advance an iterator of type Iterator a given number of Iterator's units
39 class step_iterator_adaptor : public iterator_adaptor<Derived, Iterator, use_default, use_default, use_default, typename SFn::difference_type> {
40 public:
41  typedef iterator_adaptor<Derived, Iterator, use_default, use_default, use_default, typename SFn::difference_type> parent_t;
42  typedef typename std::iterator_traits<Iterator>::difference_type base_difference_type;
43  typedef typename SFn::difference_type difference_type;
44  typedef typename std::iterator_traits<Iterator>::reference reference;
45 
47  step_iterator_adaptor(const Iterator& it, SFn step_fn=SFn()) : parent_t(it), _step_fn(step_fn) {}
48 
49  difference_type step() const { return _step_fn.step(); }
50 
51 protected:
52  SFn _step_fn;
53 private:
54  friend class boost::iterator_core_access;
55 
56  void increment() { _step_fn.advance(this->base_reference(),1); }
57  void decrement() { _step_fn.advance(this->base_reference(),-1); }
58  void advance(base_difference_type d) { _step_fn.advance(this->base_reference(),d); }
59  difference_type distance_to(const step_iterator_adaptor& it) const { return _step_fn.difference(this->base_reference(),it.base_reference()); }
60 };
61 
62 // although iterator_adaptor defines these, the default implementation computes distance and compares for zero.
63 // it is often faster to just apply the relation operator to the base
64 template <typename D,typename Iterator,typename SFn> inline
66  return p1.step()>0 ? p1.base()> p2.base() : p1.base()< p2.base();
67 }
68 
69 template <typename D,typename Iterator,typename SFn> inline
70 bool operator<(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) {
71  return p1.step()>0 ? p1.base()< p2.base() : p1.base()> p2.base();
72 }
73 
74 template <typename D,typename Iterator,typename SFn> inline
75 bool operator>=(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) {
76  return p1.step()>0 ? p1.base()>=p2.base() : p1.base()<=p2.base();
77 }
78 
79 template <typename D,typename Iterator,typename SFn> inline
80 bool operator<=(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) {
81  return p1.step()>0 ? p1.base()<=p2.base() : p1.base()>=p2.base();
82 }
83 
84 template <typename D,typename Iterator,typename SFn> inline
85 bool operator==(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) {
86  return p1.base()==p2.base();
87 }
88 
89 template <typename D,typename Iterator,typename SFn> inline
90 bool operator!=(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) {
91  return p1.base()!=p2.base();
92 }
93 
94 } // namespace detail
95 
99 
115 
118 template <typename Iterator>
120  typedef std::ptrdiff_t difference_type;
121 
122  memunit_step_fn(difference_type step=memunit_step(Iterator())) : _step(step) {}
123 
124  difference_type difference(const Iterator& it1, const Iterator& it2) const { return memunit_distance(it1,it2)/_step; }
125  void advance(Iterator& it, difference_type d) const { memunit_advance(it,d*_step); }
126  difference_type step() const { return _step; }
127 
128  void set_step(std::ptrdiff_t step) { _step=step; }
129 private:
130  GIL_CLASS_REQUIRE(Iterator, boost::gil, MemoryBasedIteratorConcept)
131  difference_type _step;
132 };
133 
134 template <typename Iterator>
135 class memory_based_step_iterator : public detail::step_iterator_adaptor<memory_based_step_iterator<Iterator>,
136  Iterator,
137  memunit_step_fn<Iterator> > {
138  GIL_CLASS_REQUIRE(Iterator, boost::gil, MemoryBasedIteratorConcept)
139 public:
140  typedef detail::step_iterator_adaptor<memory_based_step_iterator<Iterator>,
141  Iterator,
142  memunit_step_fn<Iterator> > parent_t;
143  typedef typename parent_t::reference reference;
144  typedef typename parent_t::difference_type difference_type;
145  typedef Iterator x_iterator;
146 
147  memory_based_step_iterator() : parent_t(Iterator()) {}
148  memory_based_step_iterator(Iterator it, std::ptrdiff_t memunit_step) : parent_t(it, memunit_step_fn<Iterator>(memunit_step)) {}
149  template <typename I2>
150  memory_based_step_iterator(const memory_based_step_iterator<I2>& it)
151  : parent_t(it.base(), memunit_step_fn<Iterator>(it.step())) {}
152 
155  reference operator[](difference_type d) const { return *(*this+d); }
156 
157  void set_step(std::ptrdiff_t memunit_step) { this->_step_fn.set_step(memunit_step); }
158 
159  x_iterator& base() { return parent_t::base_reference(); }
160  x_iterator const& base() const { return parent_t::base_reference(); }
161 };
162 
163 template <typename Iterator>
164 struct const_iterator_type<memory_based_step_iterator<Iterator> > {
165  typedef memory_based_step_iterator<typename const_iterator_type<Iterator>::type> type;
166 };
167 
168 template <typename Iterator>
169 struct iterator_is_mutable<memory_based_step_iterator<Iterator> > : public iterator_is_mutable<Iterator> {};
170 
171 
173 // IteratorAdaptorConcept
175 
176 template <typename Iterator>
177 struct is_iterator_adaptor<memory_based_step_iterator<Iterator> > : public mpl::true_{};
178 
179 template <typename Iterator>
180 struct iterator_adaptor_get_base<memory_based_step_iterator<Iterator> > {
181  typedef Iterator type;
182 };
183 
184 template <typename Iterator, typename NewBaseIterator>
185 struct iterator_adaptor_rebind<memory_based_step_iterator<Iterator>,NewBaseIterator> {
186  typedef memory_based_step_iterator<NewBaseIterator> type;
187 };
188 
190 // PixelBasedConcept
192 
193 template <typename Iterator>
194 struct color_space_type<memory_based_step_iterator<Iterator> > : public color_space_type<Iterator> {};
195 
196 template <typename Iterator>
197 struct channel_mapping_type<memory_based_step_iterator<Iterator> > : public channel_mapping_type<Iterator> {};
198 
199 template <typename Iterator>
200 struct is_planar<memory_based_step_iterator<Iterator> > : public is_planar<Iterator> {};
201 
202 template <typename Iterator>
203 struct channel_type<memory_based_step_iterator<Iterator> > : public channel_type<Iterator> {};
204 
206 // MemoryBasedIteratorConcept
208 template <typename Iterator>
209 struct byte_to_memunit<memory_based_step_iterator<Iterator> > : public byte_to_memunit<Iterator> {};
210 
211 template <typename Iterator>
212 inline std::ptrdiff_t memunit_step(const memory_based_step_iterator<Iterator>& p) { return p.step(); }
213 
214 template <typename Iterator>
215 inline std::ptrdiff_t memunit_distance(const memory_based_step_iterator<Iterator>& p1,
216  const memory_based_step_iterator<Iterator>& p2) {
217  return memunit_distance(p1.base(),p2.base());
218 }
219 
220 template <typename Iterator>
221 inline void memunit_advance(memory_based_step_iterator<Iterator>& p,
222  std::ptrdiff_t diff) {
223  memunit_advance(p.base(), diff);
224 }
225 
226 template <typename Iterator>
227 inline memory_based_step_iterator<Iterator>
228 memunit_advanced(const memory_based_step_iterator<Iterator>& p,
229  std::ptrdiff_t diff) {
230  return memory_based_step_iterator<Iterator>(memunit_advanced(p.base(), diff),p.step());
231 }
232 
233 template <typename Iterator>
234 inline typename std::iterator_traits<Iterator>::reference
235 memunit_advanced_ref(const memory_based_step_iterator<Iterator>& p,
236  std::ptrdiff_t diff) {
237  return memunit_advanced_ref(p.base(), diff);
238 }
239 
241 // HasDynamicXStepTypeConcept
243 
244 template <typename Iterator>
245 struct dynamic_x_step_type<memory_based_step_iterator<Iterator> > {
246  typedef memory_based_step_iterator<Iterator> type;
247 };
248 
249 // For step iterators, pass the function object to the base
250 template <typename Iterator, typename Deref>
251 struct iterator_add_deref<memory_based_step_iterator<Iterator>,Deref> {
252  GIL_CLASS_REQUIRE(Deref, boost::gil, PixelDereferenceAdaptorConcept)
253 
254  typedef memory_based_step_iterator<typename iterator_add_deref<Iterator, Deref>::type> type;
255 
256  static type make(const memory_based_step_iterator<Iterator>& it, const Deref& d) { return type(iterator_add_deref<Iterator, Deref>::make(it.base(),d),it.step()); }
257 };
258 
262 
263 template <typename I> typename dynamic_x_step_type<I>::type make_step_iterator(const I& it, std::ptrdiff_t step);
264 
265 namespace detail {
266 
267 // if the iterator is a plain base iterator (non-adaptor), wraps it in memory_based_step_iterator
268 template <typename I>
269 typename dynamic_x_step_type<I>::type make_step_iterator_impl(const I& it, std::ptrdiff_t step, mpl::false_) {
270  return memory_based_step_iterator<I>(it, step);
271 }
272 
273 // If the iterator is compound, put the step in its base
274 template <typename I>
275 typename dynamic_x_step_type<I>::type make_step_iterator_impl(const I& it, std::ptrdiff_t step, mpl::true_) {
276  return make_step_iterator(it.base(), step);
277 }
278 
279 // If the iterator is memory_based_step_iterator, change the step
280 template <typename BaseIt>
281 memory_based_step_iterator<BaseIt> make_step_iterator_impl(const memory_based_step_iterator<BaseIt>& it, std::ptrdiff_t step, mpl::true_) {
282  return memory_based_step_iterator<BaseIt>(it.base(), step);
283 }
284 }
285 
299 template <typename I> // Models MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept
300 typename dynamic_x_step_type<I>::type make_step_iterator(const I& it, std::ptrdiff_t step) {
301  return detail::make_step_iterator_impl(it, step, typename is_iterator_adaptor<I>::type());
302 }
303 
304 }} // namespace boost::gil
305 
306 #endif
Concept of a random-access iterator that can be advanced in memory units (bytes or bits) ...
Definition: concepts.hpp:1284
reference operator[](difference_type d) const
Definition: step_iterator.hpp:155
function object that returns the memory unit distance between two iterators and advances a given iter...
Definition: step_iterator.hpp:119
An adaptor over an existing iterator that changes the step unit.
Definition: step_iterator.hpp:39
MEMORY-BASED STEP ITERATOR.
Definition: algorithm.hpp:36