// (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 |