Merge pull request boostorg#763 from lakshayg/static_assert

add static asserts for device iterators

Author: jszuppe

include/boost/compute/algorithm/accumulate.hpp

@@ -11,6 +11,7 @@
 #ifndef BOOST_COMPUTE_ALGORITHM_ACCUMULATE_HPP
 #define BOOST_COMPUTE_ALGORITHM_ACCUMULATE_HPP
 
+#include <boost/static_assert.hpp>
 #include <boost/preprocessor/seq/for_each.hpp>
 
 #include <boost/compute/system.hpp>
@@ -20,6 +21,7 @@
 #include <boost/compute/algorithm/detail/serial_accumulate.hpp>
 #include <boost/compute/container/array.hpp>
 #include <boost/compute/container/vector.hpp>
+#include <boost/compute/type_traits/is_device_iterator.hpp>
 #include <boost/compute/detail/iterator_range_size.hpp>
 
 namespace boost {
@@ -167,6 +169,8 @@ inline T accumulate(InputIterator first,
                     BinaryFunction function,
                     command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
+
     return detail::dispatch_accumulate(first, last, init, function, queue);
 }
 
@@ -177,6 +181,7 @@ inline T accumulate(InputIterator first,
                     T init,
                     command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
     typedef typename std::iterator_traits<InputIterator>::value_type IT;
 
     return detail::dispatch_accumulate(first, last, init, plus<IT>(), queue);

include/boost/compute/algorithm/adjacent_difference.hpp

@@ -13,12 +13,15 @@
 
 #include <iterator>
 
+#include <boost/static_assert.hpp>
+
 #include <boost/compute/system.hpp>
 #include <boost/compute/command_queue.hpp>
 #include <boost/compute/detail/meta_kernel.hpp>
 #include <boost/compute/detail/iterator_range_size.hpp>
 #include <boost/compute/functional/operator.hpp>
 #include <boost/compute/container/vector.hpp>
+#include <boost/compute/type_traits/is_device_iterator.hpp>
 
 namespace boost {
 namespace compute {
@@ -76,6 +79,8 @@ adjacent_difference(InputIterator first,
                     BinaryFunction op,
                     command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
+    BOOST_STATIC_ASSERT(is_device_iterator<OutputIterator>::value);
     typedef typename std::iterator_traits<InputIterator>::value_type value_type;
 
     if(first == last) {
@@ -106,6 +111,8 @@ adjacent_difference(InputIterator first,
                     OutputIterator result,
                     command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
+    BOOST_STATIC_ASSERT(is_device_iterator<OutputIterator>::value);
     typedef typename std::iterator_traits<InputIterator>::value_type value_type;
 
     return ::boost::compute::adjacent_difference(

include/boost/compute/algorithm/adjacent_find.hpp

@@ -13,6 +13,8 @@
 
 #include <iterator>
 
+#include <boost/static_assert.hpp>
+
 #include <boost/compute/command_queue.hpp>
 #include <boost/compute/lambda.hpp>
 #include <boost/compute/system.hpp>
@@ -21,6 +23,7 @@
 #include <boost/compute/detail/meta_kernel.hpp>
 #include <boost/compute/functional/operator.hpp>
 #include <boost/compute/type_traits/vector_size.hpp>
+#include <boost/compute/type_traits/is_device_iterator.hpp>
 
 namespace boost {
 namespace compute {
@@ -124,6 +127,7 @@ adjacent_find(InputIterator first,
               Compare compare,
               command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
     size_t count = detail::iterator_range_size(first, last);
     if(count < 32){
         return detail::serial_adjacent_find(first, last, compare, queue);
@@ -140,6 +144,7 @@ adjacent_find(InputIterator first,
               InputIterator last,
               command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
     typedef typename std::iterator_traits<InputIterator>::value_type value_type;
 
     using ::boost::compute::lambda::_1;

include/boost/compute/algorithm/all_of.hpp

@@ -11,8 +11,11 @@
 #ifndef BOOST_COMPUTE_ALGORITHM_ALL_OF_HPP
 #define BOOST_COMPUTE_ALGORITHM_ALL_OF_HPP
 
+#include <boost/static_assert.hpp>
+
 #include <boost/compute/system.hpp>
 #include <boost/compute/algorithm/find_if_not.hpp>
+#include <boost/compute/type_traits/is_device_iterator.hpp>
 
 namespace boost {
 namespace compute {
@@ -29,6 +32,7 @@ inline bool all_of(InputIterator first,
                    UnaryPredicate predicate,
                    command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
     return ::boost::compute::find_if_not(first, last, predicate, queue) == last;
 }
 

include/boost/compute/algorithm/any_of.hpp

@@ -11,8 +11,11 @@
 #ifndef BOOST_COMPUTE_ALGORITHM_ANY_OF_HPP
 #define BOOST_COMPUTE_ALGORITHM_ANY_OF_HPP
 
+#include <boost/static_assert.hpp>
+
 #include <boost/compute/system.hpp>
 #include <boost/compute/algorithm/find_if.hpp>
+#include <boost/compute/type_traits/is_device_iterator.hpp>
 
 namespace boost {
 namespace compute {
@@ -33,6 +36,7 @@ inline bool any_of(InputIterator first,
                    UnaryPredicate predicate,
                    command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
     return ::boost::compute::find_if(first, last, predicate, queue) != last;
 }
 

include/boost/compute/algorithm/binary_search.hpp

@@ -11,9 +11,12 @@
 #ifndef BOOST_COMPUTE_ALGORITHM_BINARY_SEARCH_HPP
 #define BOOST_COMPUTE_ALGORITHM_BINARY_SEARCH_HPP
 
+#include <boost/static_assert.hpp>
+
 #include <boost/compute/system.hpp>
 #include <boost/compute/command_queue.hpp>
 #include <boost/compute/algorithm/lower_bound.hpp>
+#include <boost/compute/type_traits/is_device_iterator.hpp>
 
 namespace boost {
 namespace compute {
@@ -28,6 +31,7 @@ inline bool binary_search(InputIterator first,
                           const T &value,
                           command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
     InputIterator position = lower_bound(first, last, value, queue);
 
     return position != last && position.read(queue) == value;

include/boost/compute/algorithm/copy_if.hpp

@@ -11,8 +11,11 @@
 #ifndef BOOST_COMPUTE_ALGORITHM_COPY_IF_HPP
 #define BOOST_COMPUTE_ALGORITHM_COPY_IF_HPP
 
+#include <boost/static_assert.hpp>
+
 #include <boost/compute/algorithm/transform_if.hpp>
 #include <boost/compute/functional/identity.hpp>
+#include <boost/compute/type_traits/is_device_iterator.hpp>
 
 namespace boost {
 namespace compute {
@@ -27,6 +30,8 @@ inline OutputIterator copy_index_if(InputIterator first,
                                     Predicate predicate,
                                     command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
+    BOOST_STATIC_ASSERT(is_device_iterator<OutputIterator>::value);
     typedef typename std::iterator_traits<InputIterator>::value_type T;
 
     return detail::transform_if_impl(
@@ -47,6 +52,8 @@ inline OutputIterator copy_if(InputIterator first,
                               Predicate predicate,
                               command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
+    BOOST_STATIC_ASSERT(is_device_iterator<OutputIterator>::value);
     typedef typename std::iterator_traits<InputIterator>::value_type T;
 
     return ::boost::compute::transform_if(

include/boost/compute/algorithm/count.hpp

@@ -11,11 +11,14 @@
 #ifndef BOOST_COMPUTE_ALGORITHM_COUNT_HPP
 #define BOOST_COMPUTE_ALGORITHM_COUNT_HPP
 
+#include <boost/static_assert.hpp>
+
 #include <boost/compute/lambda.hpp>
 #include <boost/compute/system.hpp>
 #include <boost/compute/command_queue.hpp>
 #include <boost/compute/algorithm/count_if.hpp>
 #include <boost/compute/type_traits/vector_size.hpp>
+#include <boost/compute/type_traits/is_device_iterator.hpp>
 
 namespace boost {
 namespace compute {
@@ -33,6 +36,7 @@ inline size_t count(InputIterator first,
                     const T &value,
                     command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
     typedef typename std::iterator_traits<InputIterator>::value_type value_type;
 
     using ::boost::compute::_1;

include/boost/compute/algorithm/count_if.hpp

@@ -11,6 +11,8 @@
 #ifndef BOOST_COMPUTE_ALGORITHM_COUNT_IF_HPP
 #define BOOST_COMPUTE_ALGORITHM_COUNT_IF_HPP
 
+#include <boost/static_assert.hpp>
+
 #include <boost/compute/device.hpp>
 #include <boost/compute/system.hpp>
 #include <boost/compute/command_queue.hpp>
@@ -19,6 +21,7 @@
 #include <boost/compute/algorithm/detail/count_if_with_threads.hpp>
 #include <boost/compute/algorithm/detail/serial_count_if.hpp>
 #include <boost/compute/detail/iterator_range_size.hpp>
+#include <boost/compute/type_traits/is_device_iterator.hpp>
 
 namespace boost {
 namespace compute {
@@ -34,6 +37,7 @@ inline size_t count_if(InputIterator first,
                        Predicate predicate,
                        command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator>::value);
     const device &device = queue.get_device();
 
     size_t input_size = detail::iterator_range_size(first, last);

include/boost/compute/algorithm/equal.hpp

@@ -11,9 +11,12 @@
 #ifndef BOOST_COMPUTE_ALGORITHM_EQUAL_HPP
 #define BOOST_COMPUTE_ALGORITHM_EQUAL_HPP
 
+#include <boost/static_assert.hpp>
+
 #include <boost/compute/system.hpp>
 #include <boost/compute/command_queue.hpp>
 #include <boost/compute/algorithm/mismatch.hpp>
+#include <boost/compute/type_traits/is_device_iterator.hpp>
 
 namespace boost {
 namespace compute {
@@ -28,6 +31,8 @@ inline bool equal(InputIterator1 first1,
                   InputIterator2 first2,
                   command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator1>::value);
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator2>::value);
     return ::boost::compute::mismatch(first1,
                                       last1,
                                       first2,
@@ -42,6 +47,8 @@ inline bool equal(InputIterator1 first1,
                   InputIterator2 last2,
                   command_queue &queue = system::default_queue())
 {
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator1>::value);
+    BOOST_STATIC_ASSERT(is_device_iterator<InputIterator2>::value);
     if(std::distance(first1, last1) != std::distance(first2, last2)){
         return false;
     }