Add more ctor, assignment operators to distributed::vector

However, they are not testes yet.

Author: jszuppe

include/boost/compute/distributed/vector.hpp

@@ -131,10 +131,10 @@ class vector
         : m_queue(context),
           m_size(0)
     {
+        // TODO lazy allocation?
         for(size_t i = 0; i < m_queue.size(); i++)
         {
             m_allocators.push_back(Alloc(context.get(i)));
-            // TODO lazy allocation?
             m_data.push_back(
                 m_allocators.back()
                     .allocate(_minimum_capacity())
@@ -211,90 +211,125 @@ class vector
     }
 
     /// Creates a new vector and copies the values from \p other.
-    vector(const vector &other)
+    vector(const vector &other, bool blocking = false)
         : m_queue(other.m_queue),
           m_size(other.m_size)
     {
         allocate_memory(m_size);
-        copy(other, m_queue);
+        copy(other, m_queue, blocking);
     }
 
     /// Creates a new vector and copies the values from \p other
     /// with \p queue.
-    vector(const vector &other, command_queue &queue)
+    vector(const vector &other, command_queue &queue, bool blocking = false)
         : m_queue(queue),
           m_size(other.m_size)
     {
         allocate_memory(m_size);
         if(m_queue == other.m_queue) {
-            copy(other, m_queue);
+            copy(other, m_queue, blocking);
         }
         else {
-            copy(other, other.get_queue(), m_queue);
+            copy(other, other.get_queue(), m_queue, blocking);
         }
     }
 
-//    /// Creates a new vector and copies the values from \p other.
-//    template<class OtherAlloc>
-//    vector(const vector<T, OtherAlloc> &other, command_queue &queue)
-//        : m_size(other.size())
-//    {
-//    }
-//
-//    /// Creates a new vector and copies the values from \p vector.
-//    template<class OtherAlloc>
-//    vector(const std::vector<T, OtherAlloc> &vector, command_queue &queue)
-//        : m_size(vector.size())
-//    {
-//
-//    }
-//
-//    vector& operator=(const vector &other)
-//    {
-//        if(this != &other){
-//
-//        }
-//        return *this;
-//    }
-//
-//    template<class OtherAlloc>
-//    vector& operator=(const vector<T, OtherAlloc> &other)
-//    {
-//        return *this;
-//    }
-//
-//    template<class OtherAlloc>
-//    vector& operator=(const std::vector<T, OtherAlloc> &vector)
-//    {
-//        return *this;
-//    }
-//
-//    #ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES
-//    /// Move-constructs a new vector from \p other.
-//    vector(vector&& other)
-//        : m_data(std::move(other.m_data)),
-//          m_size(other.m_size),
-//          m_allocator(std::move(other.m_allocator))
-//    {
-//        other.m_size = 0;
-//    }
-//
-//    /// Move-assigns the data from \p other to \c *this.
-//    vector& operator=(vector&& other)
-//    {
-//        if(m_size){
-//            m_allocator.deallocate(m_data, m_size);
-//        }
-//
-//        m_data = std::move(other.m_data);
-//        m_size = other.m_size;
-//        m_allocator = std::move(other.m_allocator);
-//
-//        other.m_size = 0;
-//
-//        return *this;
-//    }
-//    #endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES
+    /// Creates a new vector and copies the values from \p other.
+    template<class OtherAlloc>
+    vector(const vector<T, weight, OtherAlloc> &other,
+           command_queue &queue,
+           bool blocking = false)
+        : m_queue(queue),
+          m_size(other.m_size)
+    {
+        allocate_memory(m_size);
+        if(m_queue == other.m_queue) {
+            copy(other, m_queue, blocking);
+        }
+        else {
+            copy(other, other.get_queue(), m_queue, blocking);
+        }
+    }
+
+    /// Creates a new vector and copies the values from \p vector.
+    template<class OtherAlloc>
+    vector(const std::vector<T, OtherAlloc> &vector,
+           command_queue &queue,
+           bool blocking = false)
+        : m_queue(queue),
+          m_size(vector.size())
+    {
+        allocate_memory(m_size);
+        copy(vector.begin(), vector.end(), m_queue, blocking);
+    }
+
+    /// Copy assignment. This operation is always non-blocking.
+    vector& operator=(const vector &other)
+    {
+        if(this != &other){
+            m_queue = other.m_queue;
+            m_size = other.m_size;
+            allocate_memory(m_size);
+            copy(other, m_queue, false);
+        }
+        return *this;
+    }
+
+    /// Copy assignment. This operation is always non-blocking.
+    template<class OtherAlloc>
+    vector& operator=(const vector<T, weight, OtherAlloc> &other)
+    {
+        m_queue = other.m_queue;
+        m_size = other.m_size;
+        allocate_memory(m_size);
+        copy(other, m_queue, false);
+        return *this;
+    }
+
+    /// Copy assignment. This operation is always non-blocking.
+    template<class OtherAlloc>
+    vector& operator=(const std::vector<T, OtherAlloc> &vector)
+    {
+        m_size = vector.size();
+        allocate_memory(m_size);
+        copy(vector.begin(), vector.end(), m_queue, false);
+        return *this;
+    }
+
+    #ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES
+    /// Move-constructs a new vector from \p other.
+    vector(vector&& other)
+        : m_queue(std::move(m_queue)),
+          m_size(other.m_size),
+          m_data(std::move(other.m_data)),
+          m_data_sizes(std::move(other.m_data_sizes)),
+          m_data_indices(std::move(other.m_data_indices)),
+          m_allocators(std::move(other.m_allocators))
+    {
+        other.m_size = 0;
+    }
+
+    /// Move-assigns the data from \p other to \c *this.
+    vector& operator=(vector&& other)
+    {
+        if(m_size) {
+            for(size_t i = 0; i < m_allocators.size(); i++) {
+                m_allocators[i].deallocate(m_data[i], m_data_sizes[i]);
+            }
+        }
+
+        m_queue = std::move(other.m_queue);
+        m_size = other.m_size;
+        m_data = std::move(other.m_data);
+        m_data_sizes = std::move(other.m_data_sizes);
+        m_data_indices = std::move(other.m_data_indices);
+        m_allocators = std::move(other.m_allocators);
+
+        other.m_size = 0;
+
+        return *this;
+    }
+    #endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES
 
     /// Destroys the vector object.
     ~vector()