PageRenderTime 31ms CodeModel.GetById 10ms app.highlight 18ms RepoModel.GetById 1ms app.codeStats 0ms

/Src/Dependencies/Boost/boost/graph/detail/shadow_iterator.hpp

http://hadesmem.googlecode.com/
C++ Header | 139 lines | 112 code | 17 blank | 10 comment | 2 complexity | a706f003ee51a4af093f1dbc983c2e95 MD5 | raw file
  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
 12namespace 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
128namespace 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