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_CONSTANT_ITERATOR_HPP
12 #define BOOST_COMPUTE_ITERATOR_CONSTANT_ITERATOR_HPP
13
14 #include <string>
15 #include <cstddef>
16 #include <iterator>
17
18 #include <boost/config.hpp>
19 #include <boost/iterator/iterator_facade.hpp>
20
21 #include <boost/compute/detail/meta_kernel.hpp>
22 #include <boost/compute/type_traits/is_device_iterator.hpp>
23
24 namespace boost {
25 namespace compute {
26
27 // forward declaration for constant_iterator<T>
28 template<class T> class constant_iterator;
29
30 namespace detail {
31
32 // helper class which defines the iterator_facade super-class
33 // type for constant_iterator<T>
34 template<class T>
35 class constant_iterator_base
36 {
37 public:
38 typedef ::boost::iterator_facade<
39 ::boost::compute::constant_iterator<T>,
40 T,
41 ::std::random_access_iterator_tag
42 > type;
43 };
44
45 } // end detail namespace
46
47 /// \class constant_iterator
48 /// \brief An iterator with a constant value.
49 ///
50 /// The constant_iterator class provides an iterator which returns a constant
51 /// value when dereferenced.
52 ///
53 /// For example, this could be used to implement the fill() algorithm in terms
54 /// of the copy() algorithm by copying from a range of constant iterators:
55 ///
56 /// \snippet test/test_constant_iterator.cpp fill_with_copy
57 ///
58 /// \see make_constant_iterator()
59 template<class T>
60 class constant_iterator : public detail::constant_iterator_base<T>::type
61 {
62 public:
63 typedef typename detail::constant_iterator_base<T>::type super_type;
64 typedef typename super_type::reference reference;
65 typedef typename super_type::difference_type difference_type;
66
constant_iterator(const T & value,size_t index=0)67 constant_iterator(const T &value, size_t index = 0)
68 : m_value(value),
69 m_index(index)
70 {
71 }
72
constant_iterator(const constant_iterator<T> & other)73 constant_iterator(const constant_iterator<T> &other)
74 : m_value(other.m_value),
75 m_index(other.m_index)
76 {
77 }
78
operator =(const constant_iterator<T> & other)79 constant_iterator<T>& operator=(const constant_iterator<T> &other)
80 {
81 if(this != &other){
82 m_value = other.m_value;
83 m_index = other.m_index;
84 }
85
86 return *this;
87 }
88
~constant_iterator()89 ~constant_iterator()
90 {
91 }
92
get_index() const93 size_t get_index() const
94 {
95 return m_index;
96 }
97
98 /// \internal_
99 template<class Expr>
operator [](const Expr & expr) const100 detail::meta_kernel_literal<T> operator[](const Expr &expr) const
101 {
102 (void) expr;
103
104 return detail::meta_kernel::make_lit<T>(m_value);
105 }
106
107 private:
108 friend class ::boost::iterator_core_access;
109
110 /// \internal_
dereference() const111 reference dereference() const
112 {
113 return m_value;
114 }
115
116 /// \internal_
equal(const constant_iterator<T> & other) const117 bool equal(const constant_iterator<T> &other) const
118 {
119 return m_value == other.m_value && m_index == other.m_index;
120 }
121
122 /// \internal_
increment()123 void increment()
124 {
125 m_index++;
126 }
127
128 /// \internal_
decrement()129 void decrement()
130 {
131 m_index--;
132 }
133
134 /// \internal_
advance(difference_type n)135 void advance(difference_type n)
136 {
137 m_index = static_cast<size_t>(static_cast<difference_type>(m_index) + n);
138 }
139
140 /// \internal_
distance_to(const constant_iterator<T> & other) const141 difference_type distance_to(const constant_iterator<T> &other) const
142 {
143 return static_cast<difference_type>(other.m_index - m_index);
144 }
145
146 private:
147 T m_value;
148 size_t m_index;
149 };
150
151 /// Returns a new constant_iterator with \p value at \p index.
152 ///
153 /// \param value the constant value
154 /// \param index the iterators index
155 ///
156 /// \return a \c constant_iterator with \p value
157 template<class T>
158 inline constant_iterator<T>
make_constant_iterator(const T & value,size_t index=0)159 make_constant_iterator(const T &value, size_t index = 0)
160 {
161 return constant_iterator<T>(value, index);
162 }
163
164 /// \internal_ (is_device_iterator specialization for constant_iterator)
165 template<class T>
166 struct is_device_iterator<constant_iterator<T> > : boost::true_type {};
167
168 } // end compute namespace
169 } // end boost namespace
170
171 #endif // BOOST_COMPUTE_ITERATOR_CONSTANT_ITERATOR_HPP
172