Added boost header

test/external/boost/graph/detail/shadow_iterator.hpp

@@ -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