| // (C) Copyright Jeremy Siek 2001. |
| // Distributed under the Boost Software License, Version 1.0. (See |
| // accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| |
| #ifndef BOOST_SHADOW_ITERATOR_HPP |
| #define BOOST_SHADOW_ITERATOR_HPP |
| |
| #include <boost/iterator_adaptors.hpp> |
| #include <boost/operators.hpp> |
| |
| namespace boost { |
| |
| namespace detail { |
| |
| template <class A, class B, class D> |
| class shadow_proxy |
| : boost::operators< shadow_proxy<A,B,D> > |
| { |
| typedef shadow_proxy self; |
| public: |
| inline shadow_proxy(A aa, B bb) : a(aa), b(bb) { } |
| inline shadow_proxy(const self& x) : a(x.a), b(x.b) { } |
| template <class Self> |
| inline shadow_proxy(Self x) : a(x.a), b(x.b) { } |
| inline self& operator=(const self& x) { a = x.a; b = x.b; return *this; } |
| inline self& operator++() { ++a; return *this; } |
| inline self& operator--() { --a; return *this; } |
| inline self& operator+=(const self& x) { a += x.a; return *this; } |
| inline self& operator-=(const self& x) { a -= x.a; return *this; } |
| inline self& operator*=(const self& x) { a *= x.a; return *this; } |
| inline self& operator/=(const self& x) { a /= x.a; return *this; } |
| inline self& operator%=(const self& x) { return *this; } // JGS |
| inline self& operator&=(const self& x) { return *this; } // JGS |
| inline self& operator|=(const self& x) { return *this; } // JGS |
| inline self& operator^=(const self& x) { return *this; } // JGS |
| inline friend D operator-(const self& x, const self& y) { |
| return x.a - y.a; |
| } |
| inline bool operator==(const self& x) const { return a == x.a; } |
| inline bool operator<(const self& x) const { return a < x.a; } |
| // protected: |
| A a; |
| B b; |
| }; |
| |
| struct shadow_iterator_policies |
| { |
| template <typename iter_pair> |
| void initialize(const iter_pair&) { } |
| |
| template <typename Iter> |
| typename Iter::reference dereference(const Iter& i) const { |
| typedef typename Iter::reference R; |
| return R(*i.base().first, *i.base().second); |
| } |
| template <typename Iter> |
| bool equal(const Iter& p1, const Iter& p2) const { |
| return p1.base().first == p2.base().first; |
| } |
| template <typename Iter> |
| void increment(Iter& i) { ++i.base().first; ++i.base().second; } |
| |
| template <typename Iter> |
| void decrement(Iter& i) { --i.base().first; --i.base().second; } |
| |
| template <typename Iter> |
| bool less(const Iter& x, const Iter& y) const { |
| return x.base().first < y.base().first; |
| } |
| template <typename Iter> |
| typename Iter::difference_type |
| distance(const Iter& x, const Iter& y) const { |
| return y.base().first - x.base().first; |
| } |
| template <typename D, typename Iter> |
| void advance(Iter& p, D n) { p.base().first += n; p.base().second += n; } |
| }; |
| |
| } // namespace detail |
| |
| template <typename IterA, typename IterB> |
| struct shadow_iterator_generator { |
| |
| // To use the iterator_adaptor we can't derive from |
| // random_access_iterator because we don't have a real reference. |
| // However, we want the STL algorithms to treat the shadow |
| // iterator like a random access iterator. |
| struct shadow_iterator_tag : public std::input_iterator_tag { |
| operator std::random_access_iterator_tag() { |
| return std::random_access_iterator_tag(); |
| }; |
| }; |
| typedef typename std::iterator_traits<IterA>::value_type Aval; |
| typedef typename std::iterator_traits<IterB>::value_type Bval; |
| typedef typename std::iterator_traits<IterA>::reference Aref; |
| typedef typename std::iterator_traits<IterB>::reference Bref; |
| typedef typename std::iterator_traits<IterA>::difference_type D; |
| typedef detail::shadow_proxy<Aval,Bval,Aval> V; |
| typedef detail::shadow_proxy<Aref,Bref,Aval> R; |
| typedef iterator_adaptor< std::pair<IterA, IterB>, |
| detail::shadow_iterator_policies, |
| V, R, V*, shadow_iterator_tag, |
| D> type; |
| }; |
| |
| // short cut for creating a shadow iterator |
| template <class IterA, class IterB> |
| inline typename shadow_iterator_generator<IterA,IterB>::type |
| make_shadow_iter(IterA a, IterB b) { |
| typedef typename shadow_iterator_generator<IterA,IterB>::type Iter; |
| return Iter(std::make_pair(a,b)); |
| } |
| |
| template <class Cmp> |
| struct shadow_cmp { |
| inline shadow_cmp(const Cmp& c) : cmp(c) { } |
| template <class ShadowProxy1, class ShadowProxy2> |
| inline bool operator()(const ShadowProxy1& x, const ShadowProxy2& y) const |
| { |
| return cmp(x.a, y.a); |
| } |
| Cmp cmp; |
| }; |
| |
| } // namespace boost |
| |
| namespace std { |
| template <class A1, class B1, class D1, |
| class A2, class B2, class D2> |
| void swap(boost::detail::shadow_proxy<A1&,B1&,D1> x, |
| boost::detail::shadow_proxy<A2&,B2&,D2> y) |
| { |
| std::swap(x.a, y.a); |
| std::swap(x.b, y.b); |
| } |
| } |
| |
| #endif // BOOST_SHADOW_ITERATOR_HPP |