ceph/src/boost/boost/compute/iterator/detail/swizzle_iterator.hpp

   1 //---------------------------------------------------------------------------//
   2 // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
   3 //
   4 // Distributed under the Boost Software License, Version 1.0
   5 // See accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt
   7 //
   8 // See http://boostorg.github.com/compute for more information.
   9 //---------------------------------------------------------------------------//
  10
  11 #ifndef BOOST_COMPUTE_ITERATOR_DETAIL_SWIZZLE_ITERATOR_HPP
  12 #define BOOST_COMPUTE_ITERATOR_DETAIL_SWIZZLE_ITERATOR_HPP
  13
  14 #include <string>
  15 #include <cstddef>
  16 #include <iterator>
  17
  18 #include <boost/config.hpp>
  19 #include <boost/iterator/iterator_adaptor.hpp>
  20
  21 #include <boost/compute/functional.hpp>
  22 #include <boost/compute/detail/meta_kernel.hpp>
  23 #include <boost/compute/type_traits/make_vector_type.hpp>
  24 #include <boost/compute/detail/is_buffer_iterator.hpp>
  25 #include <boost/compute/detail/read_write_single_value.hpp>
  26 #include <boost/compute/iterator/detail/get_base_iterator_buffer.hpp>
  27 #include <boost/compute/type_traits/is_device_iterator.hpp>
  28
  29 namespace boost {
  30 namespace compute {
  31 namespace detail {
  32
  33 // forward declaration for swizzle_iterator
  34 template<class InputIterator, size_t Size>
  35 class swizzle_iterator;
  36
  37 // meta-function returing the value_type for a swizzle_iterator
  38 template<class InputIterator, size_t Size>
  39 struct make_swizzle_iterator_value_type
  40 {
  41     typedef
  42         typename make_vector_type<
  43             typename scalar_type<
  44                 typename std::iterator_traits<InputIterator>::value_type
  45             >::type,
  46             Size
  47         >::type type;
  48 };
  49
  50 // helper class which defines the iterator_adaptor super-class
  51 // type for swizzle_iterator
  52 template<class InputIterator, size_t Size>
  53 class swizzle_iterator_base
  54 {
  55 public:
  56     typedef ::boost::iterator_adaptor<
  57         swizzle_iterator<InputIterator, Size>,
  58         InputIterator,
  59         typename make_swizzle_iterator_value_type<InputIterator, Size>::type,
  60         typename std::iterator_traits<InputIterator>::iterator_category,
  61         typename make_swizzle_iterator_value_type<InputIterator, Size>::type
  62     > type;
  63 };
  64
  65 template<class InputIterator, size_t Size, class IndexExpr>
  66 struct swizzle_iterator_index_expr
  67 {
  68     typedef typename make_swizzle_iterator_value_type<InputIterator, Size>::type result_type;
  69
  70     swizzle_iterator_index_expr(const InputIterator &input_iter,
  71                                 const IndexExpr &index_expr,
  72                                 const std::string &components)
  73         : m_input_iter(input_iter),
  74           m_index_expr(index_expr),
  75           m_components(components)
  76     {
  77     }
  78
  79     InputIterator m_input_iter;
  80     IndexExpr m_index_expr;
  81     std::string m_components;
  82 };
  83
  84 template<class InputIterator, size_t Size, class IndexExpr>
  85 inline meta_kernel& operator<<(meta_kernel &kernel,
  86                                const swizzle_iterator_index_expr<InputIterator,
  87                                                                  Size,
  88                                                                  IndexExpr> &expr)
  89 {
  90     return kernel << expr.m_input_iter[expr.m_index_expr]
  91                   << "." << expr.m_components;
  92 }
  93
  94 template<class InputIterator, size_t Size>
  95 class swizzle_iterator :
  96     public swizzle_iterator_base<InputIterator, Size>::type
  97 {
  98 public:
  99     typedef typename
 100         swizzle_iterator_base<InputIterator, Size>::type
 101         super_type;
 102     typedef typename super_type::value_type value_type;
 103     typedef typename super_type::reference reference;
 104     typedef typename super_type::base_type base_type;
 105     typedef typename super_type::difference_type difference_type;
 106
 107     BOOST_STATIC_CONSTANT(size_t, vector_size = Size);
 108
 109     swizzle_iterator(InputIterator iterator, const std::string &components)
 110         : super_type(iterator),
 111           m_components(components)
 112     {
 113         BOOST_ASSERT(components.size() == Size);
 114     }
 115
 116     swizzle_iterator(const swizzle_iterator<InputIterator, Size> &other)
 117         : super_type(other.base()),
 118           m_components(other.m_components)
 119     {
 120         BOOST_ASSERT(m_components.size() == Size);
 121     }
 122
 123     swizzle_iterator<InputIterator, Size>&
 124     operator=(const swizzle_iterator<InputIterator, Size> &other)
 125     {
 126         if(this != &other){
 127             super_type::operator=(other);
 128
 129             m_components = other.m_components;
 130         }
 131
 132         return *this;
 133     }
 134
 135     ~swizzle_iterator()
 136     {
 137     }
 138
 139     size_t get_index() const
 140     {
 141         return super_type::base().get_index();
 142     }
 143
 144     const buffer& get_buffer() const
 145     {
 146         return get_base_iterator_buffer(*this);
 147     }
 148
 149     template<class IndexExpression>
 150     swizzle_iterator_index_expr<InputIterator, Size, IndexExpression>
 151     operator[](const IndexExpression &expr) const
 152     {
 153         return swizzle_iterator_index_expr<InputIterator,
 154                                            Size,
 155                                            IndexExpression>(super_type::base(),
 156                                                             expr,
 157                                                             m_components);
 158     }
 159
 160 private:
 161     friend class ::boost::iterator_core_access;
 162
 163     reference dereference() const
 164     {
 165         return reference();
 166     }
 167
 168 private:
 169     std::string m_components;
 170 };
 171
 172 template<size_t Size, class InputIterator>
 173 inline swizzle_iterator<InputIterator, Size>
 174 make_swizzle_iterator(InputIterator iterator, const std::string &components)
 175 {
 176     return swizzle_iterator<InputIterator, Size>(iterator, components);
 177 }
 178
 179 } // end detail namespace
 180
 181 // is_device_iterator specialization for swizzle_iterator
 182 template<size_t Size, class InputIterator>
 183 struct is_device_iterator<detail::swizzle_iterator<InputIterator, Size> > : boost::true_type {};
 184
 185 } // end compute namespace
 186 } // end boost namespace
 187
 188 #endif // BOOST_COMPUTE_ITERATOR_SWIZZLE_ITERATOR_HPP