boost/boost/multi_array/iterator.hpp

   1 #ifndef ITERATOR_RG071801_HPP
   2 #define ITERATOR_RG071801_HPP
   3
   4 //
   5 // iterator.hpp - implementation of iterators for the
   6 // multi-dimensional array class
   7 //
   8
   9 #include "boost/multi_array/base.hpp"
  10 #include "boost/multi_array/iterator_adaptors.hpp"
  11 #include "boost/iterator_adaptors.hpp"
  12 #include <cstddef>
  13 #include <iterator>
  14
  15 namespace boost {
  16 namespace detail {
  17 namespace multi_array {
  18
  19 /////////////////////////////////////////////////////////////////////////
  20 // iterator components
  21 /////////////////////////////////////////////////////////////////////////
  22
  23 template <typename T, typename TPtr>
  24 struct iterator_base : private multi_array_base {
  25   typedef multi_array_base super_type;
  26   typedef super_type::index index;
  27   typedef super_type::size_type size_type;
  28
  29   index idx_;
  30   TPtr base_;
  31   const size_type* extents_;
  32   const index* strides_;
  33   const index* index_base_;
  34
  35   iterator_base(int idx, TPtr base, const size_type* extents,
  36                 const index* strides,
  37                 const index* index_base) :
  38     idx_(idx), base_(base), extents_(extents),
  39     strides_(strides), index_base_(index_base) {
  40   }
  41
  42   template <typename OPtr>
  43   iterator_base(const iterator_base<T,OPtr>& rhs) :
  44     idx_(rhs.idx_), base_(rhs.base_), extents_(rhs.extents_),
  45     strides_(rhs.strides_), index_base_(rhs.index_base_) {
  46   }
  47
  48   // default constructor required
  49   iterator_base() {}
  50 };
  51
  52 template<typename T, std::size_t NumDims>
  53 struct iterator_policies :
  54   public boost::detail::multi_array::default_iterator_policies,
  55   private value_accessor_generator<T,NumDims>::type {
  56 private:
  57   typedef typename value_accessor_generator<T,NumDims>::type super_type;
  58 public:
  59   template <class IteratorAdaptor>
  60   typename IteratorAdaptor::reference
  61   dereference(const IteratorAdaptor& iter) const {
  62     typedef typename IteratorAdaptor::reference reference;
  63     return super_type::access(boost::type<reference>(),
  64                               iter.base().idx_,
  65                               iter.base().base_,
  66                               iter.base().extents_,
  67                               iter.base().strides_,
  68                               iter.base().index_base_);
  69   }
  70
  71   template <class IteratorAdaptor>
  72   static void increment(IteratorAdaptor& x) { ++x.base().idx_; }
  73
  74   template <class IteratorAdaptor>
  75   static void decrement(IteratorAdaptor& x) { --x.base().idx_; }
  76
  77   template <class IteratorAdaptor1, class IteratorAdaptor2>
  78   bool equal(IteratorAdaptor1& lhs, IteratorAdaptor2& rhs) const {
  79     return (lhs.base().idx_ == rhs.base().idx_) &&
  80       (lhs.base().base_ == rhs.base().base_) &&
  81       (lhs.base().extents_ == rhs.base().extents_) &&
  82       (lhs.base().strides_ == rhs.base().strides_) &&
  83       (lhs.base().index_base_ == rhs.base().index_base_);
  84   }
  85
  86   template <class IteratorAdaptor, class DifferenceType>
  87   static void advance(IteratorAdaptor& x, DifferenceType n) {
  88     x.idx_ += n;
  89   }
  90
  91   template <class IteratorAdaptor1, class IteratorAdaptor2>
  92   typename IteratorAdaptor1::difference_type
  93   distance(IteratorAdaptor1& lhs, IteratorAdaptor2& rhs) const {
  94     return rhs.base().idx_ - lhs.base().idx_;
  95   }
  96 };
  97
  98
  99 template <typename T, typename base_type,
 100   std::size_t NumDims, typename value_type,
 101   typename reference_type, typename tag, typename difference_type>
 102 struct iterator_gen_helper {
 103 private:
 104   typedef iterator_policies<T,NumDims> policies;
 105   typedef value_type* pointer_type;
 106   typedef tag category;
 107 public:
 108   typedef boost::detail::multi_array::iterator_adaptor<base_type,policies,value_type,
 109     reference_type,pointer_type,category,difference_type> type;
 110 };
 111
 112
 113 template <typename T, std::size_t NumDims, typename value_type,
 114   typename reference_type, typename tag, typename difference_type>
 115 struct iterator_generator {
 116 private:
 117   typedef iterator_base<T,T*> base_type;
 118 public:
 119   typedef typename iterator_gen_helper<T,base_type,NumDims,value_type,
 120     reference_type,tag,difference_type>::type type;
 121 };
 122
 123 template <typename T,  std::size_t NumDims, typename value_type,
 124   typename reference_type, typename tag, typename difference_type>
 125 struct const_iterator_generator {
 126 private:
 127   typedef iterator_base<T,const T*> base_type;
 128 public:
 129   typedef typename iterator_gen_helper<T,base_type,NumDims,value_type,
 130     reference_type,tag,difference_type>::type type;
 131 };
 132
 133 template <typename T, std::size_t NumDims, typename value_type,
 134   typename reference_type, typename tag, typename difference_type>
 135 struct reverse_iterator_generator {
 136 private:
 137   typedef iterator_base<T,T*> base_type;
 138   typedef typename iterator_gen_helper<T,base_type,NumDims,value_type,
 139     reference_type,tag,difference_type>::type it_type;
 140 public:
 141   typedef typename boost::reverse_iterator_generator<it_type>::type type;
 142 };
 143
 144 template <typename T,  std::size_t NumDims, typename value_type,
 145   typename reference_type, typename tag, typename difference_type>
 146 struct const_reverse_iterator_generator {
 147 private:
 148   typedef iterator_base<T,const T*> base_type;
 149   typedef typename iterator_gen_helper<T,base_type,NumDims,value_type,
 150     reference_type,tag,difference_type>::type it_type;
 151 public:
 152   typedef typename boost::reverse_iterator_generator<it_type>::type type;
 153 };
 154
 155 } // namespace multi_array
 156 } // namespace detail
 157 } // namespace boost
 158
 159 #endif // ITERATOR_RG071801_HPP