Ugly, not-to-be-pushed sucking in of all of Boost to get windows to work.
[dyninst.git] / external / boost / graph / detail / shadow_iterator.hpp
1 // (C) Copyright Jeremy Siek 2001.
2 // Distributed under the Boost Software License, Version 1.0. (See
3 // accompanying file LICENSE_1_0.txt or copy at
4 // http://www.boost.org/LICENSE_1_0.txt)
5
6 #ifndef BOOST_SHADOW_ITERATOR_HPP
7 #define BOOST_SHADOW_ITERATOR_HPP
8
9 #include <boost/iterator_adaptors.hpp>
10 #include <boost/operators.hpp>
11
12 namespace boost {
13
14   namespace detail {
15
16     template <class A, class B, class D>
17     class shadow_proxy
18       : boost::operators< shadow_proxy<A,B,D> >
19     {
20       typedef shadow_proxy self;
21     public:
22       inline shadow_proxy(A aa, B bb) : a(aa), b(bb) { }
23       inline shadow_proxy(const self& x) : a(x.a), b(x.b) { }
24       template <class Self>
25       inline shadow_proxy(Self x) : a(x.a), b(x.b) { }
26       inline self& operator=(const self& x) { a = x.a; b = x.b; return *this; }
27       inline self& operator++() { ++a; return *this; }
28       inline self& operator--() { --a; return *this; }
29       inline self& operator+=(const self& x) { a += x.a; return *this; }
30       inline self& operator-=(const self& x) { a -= x.a; return *this; }
31       inline self& operator*=(const self& x) { a *= x.a; return *this; }
32       inline self& operator/=(const self& x) { a /= x.a; return *this; }
33       inline self& operator%=(const self& x) { return *this; } // JGS
34       inline self& operator&=(const self& x) { return *this; } // JGS
35       inline self& operator|=(const self& x) { return *this; } // JGS
36       inline self& operator^=(const self& x) { return *this; } // JGS
37       inline friend D operator-(const self& x, const self& y) {
38         return x.a - y.a;
39       } 
40       inline bool operator==(const self& x) const { return a == x.a;  }
41       inline bool operator<(const self& x) const { return a < x.a;  }
42       //  protected:
43       A a;
44       B b;
45     };
46
47     struct shadow_iterator_policies
48     {
49       template <typename iter_pair>
50       void initialize(const iter_pair&) { }
51
52       template <typename Iter>
53       typename Iter::reference dereference(const Iter& i) const { 
54         typedef typename Iter::reference R;
55         return R(*i.base().first, *i.base().second); 
56       }
57       template <typename Iter>
58       bool equal(const Iter& p1, const Iter& p2) const { 
59         return p1.base().first == p2.base().first;  
60       }
61       template <typename Iter>
62       void increment(Iter& i) { ++i.base().first; ++i.base().second; }
63
64       template <typename Iter>
65       void decrement(Iter& i) { --i.base().first; --i.base().second; }
66
67       template <typename Iter>
68       bool less(const Iter& x, const Iter& y) const { 
69         return x.base().first < y.base().first;  
70       }
71       template <typename Iter>
72       typename Iter::difference_type
73       distance(const Iter& x, const Iter& y) const { 
74         return y.base().first - x.base().first; 
75       }
76       template <typename D, typename Iter>
77       void advance(Iter& p, D n) { p.base().first += n; p.base().second += n; }
78     };
79
80   } // namespace detail
81
82   template <typename IterA, typename IterB>
83   struct shadow_iterator_generator {
84     
85     // To use the iterator_adaptor we can't derive from
86     // random_access_iterator because we don't have a real reference.
87     // However, we want the STL algorithms to treat the shadow
88     // iterator like a random access iterator.
89     struct shadow_iterator_tag : public std::input_iterator_tag {
90       operator std::random_access_iterator_tag() {
91         return std::random_access_iterator_tag();
92       };
93     };
94     typedef typename std::iterator_traits<IterA>::value_type Aval;
95     typedef typename std::iterator_traits<IterB>::value_type Bval;
96     typedef typename std::iterator_traits<IterA>::reference Aref;
97     typedef typename std::iterator_traits<IterB>::reference Bref;
98     typedef typename std::iterator_traits<IterA>::difference_type D;
99     typedef detail::shadow_proxy<Aval,Bval,Aval> V;
100     typedef detail::shadow_proxy<Aref,Bref,Aval> R;
101     typedef iterator_adaptor< std::pair<IterA, IterB>,
102                               detail::shadow_iterator_policies,
103                               V, R, V*, shadow_iterator_tag,
104                               D> type;
105   };
106
107   // short cut for creating a shadow iterator
108   template <class IterA, class IterB>
109   inline typename shadow_iterator_generator<IterA,IterB>::type
110   make_shadow_iter(IterA a, IterB b) {
111     typedef typename shadow_iterator_generator<IterA,IterB>::type Iter;
112     return Iter(std::make_pair(a,b)); 
113   }
114
115   template <class Cmp>
116   struct shadow_cmp {
117     inline shadow_cmp(const Cmp& c) : cmp(c) { }
118     template <class ShadowProxy1, class ShadowProxy2>
119     inline bool operator()(const ShadowProxy1& x, const ShadowProxy2& y) const
120     {
121       return cmp(x.a, y.a);
122     }
123     Cmp cmp;
124   };
125
126 } // namespace boost
127
128 namespace std {
129   template <class A1, class B1, class D1,
130             class A2, class B2, class D2>
131   void swap(boost::detail::shadow_proxy<A1&,B1&,D1> x,
132             boost::detail::shadow_proxy<A2&,B2&,D2> y)
133   {
134     std::swap(x.a, y.a);
135     std::swap(x.b, y.b);
136   }
137 }
138
139 #endif // BOOST_SHADOW_ITERATOR_HPP