Ticket #6889: multi_array_accept_initial_value.diff

boost/multi_array.hpp

@@ -33 +33 @@
 #include <functional>
 #include <numeric>
 #include <vector>
+#include <memory>
 
 
-
 namespace boost {
   namespace detail {
     namespace multi_array {
@@ -140 +140 @@
   explicit multi_array() :
     super_type((T*)initial_base_,c_storage_order(),
                /*index_bases=*/0, /*extents=*/0) {
-    allocate_space(); 
+    default_initialize(); 
   }
 
   template <class ExtentList>
@@ -155 +155 @@
     super_type((T*)initial_base_,extents) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<ExtentList> >();
-    allocate_space();
+    default_initialize();
   }
 
+  template <class ExtentList>
+  explicit multi_array(
+      ExtentList const& extents,
+      const T& value
+      ) :
+    super_type((T*)initial_base_,extents) {
+    boost::function_requires<
+      detail::multi_array::CollectionConcept<ExtentList> >();
+    default_initialize(value);
+  }
     
   template <class ExtentList>
   explicit multi_array(ExtentList const& extents,
@@ -165 +175 @@
     super_type((T*)initial_base_,extents,so) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<ExtentList> >();
-    allocate_space();
+    default_initialize();
   }
 
   template <class ExtentList>
@@ -175 +185 @@
     super_type((T*)initial_base_,extents,so), allocator_(alloc) {
     boost::function_requires<
       detail::multi_array::CollectionConcept<ExtentList> >();
-    allocate_space();
+    default_initialize();
   }
 
-
   explicit multi_array(const detail::multi_array
                        ::extent_gen<NumDims>& ranges) :
     super_type((T*)initial_base_,ranges) {
 
-    allocate_space();
+    default_initialize();
   }
 
+  explicit multi_array(const detail::multi_array
+                       ::extent_gen<NumDims>& ranges,
+                       const T& value) :
+    super_type((T*)initial_base_,ranges) {
 
+    default_initialize(value);
+  }
+
+
   explicit multi_array(const detail::multi_array
                        ::extent_gen<NumDims>& ranges,
                        const general_storage_order<NumDims>& so) :
     super_type((T*)initial_base_,ranges,so) {
 
-    allocate_space();
+    default_initialize();
   }
 
 
@@ -202 +219 @@
                        Allocator const& alloc) :
     super_type((T*)initial_base_,ranges,so), allocator_(alloc) {
 
-    allocate_space();
+    default_initialize();
   }
 
   multi_array(const multi_array& rhs) :
   super_type(rhs), allocator_(rhs.allocator_) {
-    allocate_space();
-    boost::detail::multi_array::copy_n(rhs.base_,rhs.num_elements(),base_);
+    copy_initialize(rhs);
   }
 
 
@@ -226 +242 @@
               const general_storage_order<NumDims>& so = c_storage_order())
     : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     // Warning! storage order may change, hence the following copy technique.
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
@@ -237 +253 @@
               const general_storage_order<NumDims>& so = c_storage_order())
     : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
 
@@ -248 +264 @@
               const general_storage_order<NumDims>& so = c_storage_order())
     : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
 
@@ -259 +275 @@
   multi_array(const const_multi_array_ref<T,NumDims>& rhs)
     : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     // Warning! storage order may change, hence the following copy technique.
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
@@ -268 +284 @@
               const general_storage_order<NumDims>& so)
     : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     // Warning! storage order may change, hence the following copy technique.
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
@@ -277 +293 @@
               const_sub_array<T,NumDims>& rhs)
     : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
 
@@ -286 +302 @@
               const general_storage_order<NumDims>& so)
     : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
 
@@ -295 +311 @@
               const_multi_array_view<T,NumDims>& rhs)
     : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
 
@@ -304 +320 @@
               const general_storage_order<NumDims>& so)
     : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
 
@@ -314 +330 @@
   multi_array(const multi_array_ref<T,NumDims>& rhs)
     : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     // Warning! storage order may change, hence the following copy technique.
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
@@ -323 +339 @@
               const general_storage_order<NumDims>& so)
     : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     // Warning! storage order may change, hence the following copy technique.
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
@@ -333 +349 @@
               sub_array<T,NumDims>& rhs)
     : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
 
@@ -342 +358 @@
               const general_storage_order<NumDims>& so)
     : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
 
@@ -351 +367 @@
               multi_array_view<T,NumDims>& rhs)
     : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
     
@@ -360 +376 @@
               const general_storage_order<NumDims>& so)
     : super_type(0,so,rhs.index_bases(),rhs.shape()) 
   {
-    allocate_space();
+    default_initialize();
     std::copy(rhs.begin(),rhs.end(),this->begin());
   }
     
@@ -469 +485 @@
   }
 
 private:
+
   void allocate_space() {
     typename Allocator::const_pointer no_hint=0;
     base_ = allocator_.allocate(this->num_elements(),no_hint);
     this->set_base_ptr(base_);
     allocated_elements_ = this->num_elements();
-    std::uninitialized_fill_n(base_,allocated_elements_,T());
   }
 
+  void default_initialize(const T& value = T()) {
+    this->allocate_space();
+    std::uninitialized_fill_n(base_,allocated_elements_,value);
+  }
+
+  void copy_initialize(const multi_array<T,NumDims,Allocator>& rhs) {
+    this->allocate_space();
+    std::uninitialized_copy(rhs.base_,rhs.base_ + rhs.num_elements(),base_);
+  }
+
   void deallocate_space() {
     if(base_) {
       for(T* i = base_; i != base_+allocated_elements_; ++i)

libs/multi_array/test/constructors.cpp

@@ -21 +21 @@
 #include <algorithm>
 #include <list>
 
+
+struct no_default
+{
+    explicit no_default(int i) {}
+};
+
 void check_shape(const double&, std::size_t*, int*, unsigned int)
 {}
 
+void check_shape(const no_default&, std::size_t*, int*, unsigned int)
+{}
+
 template <class Array>
 void check_shape(const Array& A,
                  std::size_t* sizes,
@@ -37 +46 @@
   check_shape(A[0], ++sizes, ++strides, num_elements / A.size());
 }
 
-
 bool equal(const double& a, const double& b)
 {
   return a == b;
@@ -82 +90 @@
     check_shape(C, &sizes[0], strides, num_elements);
   }
 
+  // Constructor 1, initialise with default value
+  {
+      boost::multi_array<no_default, 3> A(sizes, no_default(10));
+      check_shape(A, &sizes[0], strides, num_elements);
+  }
+
   // Constructor 1, fortran storage order and user-supplied allocator
   {
     typedef boost::multi_array<double, 3,