http://www.ousob.com --- Legacy Redefined OuSob - File: /wwwroot/clipx/usr/include/boost/graph/detail/shadow_iterator.hpp

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