--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ossrv_pub/boost_apis/boost/graph/detail/shadow_iterator.hpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,139 @@
+// (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