ceph/src/boost/boost/compute/iterator/transform_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_TRANSFORM_ITERATOR_HPP
  12 #define BOOST_COMPUTE_ITERATOR_TRANSFORM_ITERATOR_HPP
  13
  14 #include <cstddef>
  15 #include <iterator>
  16
  17 #include <boost/config.hpp>
  18 #include <boost/iterator/iterator_adaptor.hpp>
  19
  20 #include <boost/compute/functional.hpp>
  21 #include <boost/compute/detail/meta_kernel.hpp>
  22 #include <boost/compute/detail/is_buffer_iterator.hpp>
  23 #include <boost/compute/detail/read_write_single_value.hpp>
  24 #include <boost/compute/iterator/detail/get_base_iterator_buffer.hpp>
  25 #include <boost/compute/type_traits/is_device_iterator.hpp>
  26 #include <boost/compute/type_traits/result_of.hpp>
  27
  28 namespace boost {
  29 namespace compute {
  30
  31 // forward declaration for transform_iterator
  32 template<class InputIterator, class UnaryFunction>
  33 class transform_iterator;
  34
  35 namespace detail {
  36
  37 // meta-function returning the value_type for a transform_iterator
  38 template<class InputIterator, class UnaryFunction>
  39 struct make_transform_iterator_value_type
  40 {
  41     typedef typename std::iterator_traits<InputIterator>::value_type value_type;
  42
  43     typedef typename boost::compute::result_of<UnaryFunction(value_type)>::type type;
  44 };
  45
  46 // helper class which defines the iterator_adaptor super-class
  47 // type for transform_iterator
  48 template<class InputIterator, class UnaryFunction>
  49 class transform_iterator_base
  50 {
  51 public:
  52     typedef ::boost::iterator_adaptor<
  53         ::boost::compute::transform_iterator<InputIterator, UnaryFunction>,
  54         InputIterator,
  55         typename make_transform_iterator_value_type<InputIterator, UnaryFunction>::type,
  56         typename std::iterator_traits<InputIterator>::iterator_category,
  57         typename make_transform_iterator_value_type<InputIterator, UnaryFunction>::type
  58     > type;
  59 };
  60
  61 template<class InputIterator, class UnaryFunction, class IndexExpr>
  62 struct transform_iterator_index_expr
  63 {
  64     typedef typename
  65         make_transform_iterator_value_type<
  66             InputIterator,
  67             UnaryFunction
  68         >::type result_type;
  69
  70     transform_iterator_index_expr(const InputIterator &input_iter,
  71                                   const UnaryFunction &transform_expr,
  72                                   const IndexExpr &index_expr)
  73         : m_input_iter(input_iter),
  74           m_transform_expr(transform_expr),
  75           m_index_expr(index_expr)
  76     {
  77     }
  78
  79     const InputIterator m_input_iter;
  80     const UnaryFunction m_transform_expr;
  81     const IndexExpr m_index_expr;
  82 };
  83
  84 template<class InputIterator, class UnaryFunction, class IndexExpr>
  85 inline meta_kernel& operator<<(meta_kernel &kernel,
  86                                const transform_iterator_index_expr<InputIterator,
  87                                                                    UnaryFunction,
  88                                                                    IndexExpr> &expr)
  89 {
  90     return kernel << expr.m_transform_expr(expr.m_input_iter[expr.m_index_expr]);
  91 }
  92
  93 } // end detail namespace
  94
  95 /// \class transform_iterator
  96 /// \brief A transform iterator adaptor.
  97 ///
  98 /// The transform_iterator adaptor applies a unary function to each element
  99 /// produced from the underlying iterator when dereferenced.
 100 ///
 101 /// For example, to copy from an input range to an output range while taking
 102 /// the absolute value of each element:
 103 ///
 104 /// \snippet test/test_transform_iterator.cpp copy_abs
 105 ///
 106 /// \see buffer_iterator, make_transform_iterator()
 107 template<class InputIterator, class UnaryFunction>
 108 class transform_iterator :
 109     public detail::transform_iterator_base<InputIterator, UnaryFunction>::type
 110 {
 111 public:
 112     typedef typename
 113         detail::transform_iterator_base<InputIterator,
 114                                         UnaryFunction>::type super_type;
 115     typedef typename super_type::value_type value_type;
 116     typedef typename super_type::reference reference;
 117     typedef typename super_type::base_type base_type;
 118     typedef typename super_type::difference_type difference_type;
 119     typedef UnaryFunction unary_function;
 120
 121     transform_iterator(InputIterator iterator, UnaryFunction transform)
 122         : super_type(iterator),
 123           m_transform(transform)
 124     {
 125     }
 126
 127     transform_iterator(const transform_iterator<InputIterator,
 128                                                 UnaryFunction> &other)
 129         : super_type(other.base()),
 130           m_transform(other.m_transform)
 131     {
 132     }
 133
 134     transform_iterator<InputIterator, UnaryFunction>&
 135     operator=(const transform_iterator<InputIterator,
 136                                        UnaryFunction> &other)
 137     {
 138         if(this != &other){
 139             super_type::operator=(other);
 140
 141             m_transform = other.m_transform;
 142         }
 143
 144         return *this;
 145     }
 146
 147     ~transform_iterator()
 148     {
 149     }
 150
 151     size_t get_index() const
 152     {
 153         return super_type::base().get_index();
 154     }
 155
 156     const buffer& get_buffer() const
 157     {
 158         return detail::get_base_iterator_buffer(*this);
 159     }
 160
 161     template<class IndexExpression>
 162     detail::transform_iterator_index_expr<InputIterator, UnaryFunction, IndexExpression>
 163     operator[](const IndexExpression &expr) const
 164     {
 165         return detail::transform_iterator_index_expr<InputIterator,
 166                                                      UnaryFunction,
 167                                                      IndexExpression>(super_type::base(),
 168                                                                       m_transform,
 169                                                                       expr);
 170     }
 171
 172 private:
 173     friend class ::boost::iterator_core_access;
 174
 175     reference dereference() const
 176     {
 177         const context &context = super_type::base().get_buffer().get_context();
 178         command_queue queue(context, context.get_device());
 179
 180         detail::meta_kernel k("read");
 181         size_t output_arg = k.add_arg<value_type *>(memory_object::global_memory, "output");
 182         k << "*output = " << m_transform(super_type::base()[k.lit(0)]) << ";";
 183
 184         kernel kernel = k.compile(context);
 185
 186         buffer output_buffer(context, sizeof(value_type));
 187
 188         kernel.set_arg(output_arg, output_buffer);
 189
 190         queue.enqueue_task(kernel);
 191
 192         return detail::read_single_value<value_type>(output_buffer, queue);
 193     }
 194
 195 private:
 196     UnaryFunction m_transform;
 197 };
 198
 199 /// Returns a transform_iterator for \p iterator with \p transform.
 200 ///
 201 /// \param iterator the underlying iterator
 202 /// \param transform the unary transform function
 203 ///
 204 /// \return a \c transform_iterator for \p iterator with \p transform
 205 ///
 206 /// For example, to create an iterator which returns the square-root of each
 207 /// value in a \c vector<int>:
 208 /// \code
 209 /// auto sqrt_iterator = make_transform_iterator(vec.begin(), sqrt<int>());
 210 /// \endcode
 211 template<class InputIterator, class UnaryFunction>
 212 inline transform_iterator<InputIterator, UnaryFunction>
 213 make_transform_iterator(InputIterator iterator, UnaryFunction transform)
 214 {
 215     return transform_iterator<InputIterator,
 216                               UnaryFunction>(iterator, transform);
 217 }
 218
 219 /// \internal_ (is_device_iterator specialization for transform_iterator)
 220 template<class InputIterator, class UnaryFunction>
 221 struct is_device_iterator<
 222     transform_iterator<InputIterator, UnaryFunction> > : boost::true_type {};
 223
 224 } // end compute namespace
 225 } // end boost namespace
 226
 227 #endif // BOOST_COMPUTE_ITERATOR_TRANSFORM_ITERATOR_HPP