boost/boost/multi_array/iterator.hpp

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