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