[array] Overloaded function make_array() to create initialized arrays.

This is especially useful when an array is needed to initialize a class
member.

This uses a statement like

  array<T, 2> result = { t0, t1 };

to initialize the array.  This is correct and explicitly allowed by the
upcoming standard.  Unfortunately g++ warns about this with -Wmissing-braces
(which is implied by -Wall) because this relies on brace elision.  The report
<http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25137> has been filed more than
five years ago, but so far not much has happened.

[[Imported from SVN: r6328]]

dune/common/array.hh

@@ -164,6 +164,89 @@ namespace Dune
     return s;
   }
 
+#ifndef DOXYGEN
+  template<class T>
+  array<T, 1> make_array(const T &t0) {
+    array<T, 1> result = { t0 };
+    return result;
+  }
+
+  template<class T>
+  array<T, 2> make_array(const T &t0, const T &t1) {
+    array<T, 2> result = { t0, t1 };
+    return result;
+  }
+
+  template<class T>
+  array<T, 3> make_array(const T &t0, const T &t1, const T &t2) {
+    array<T, 3> result = { t0, t1, t2 };
+    return result;
+  }
+
+  template<class T>
+  array<T, 4> make_array(const T &t0, const T &t1, const T &t2, const T &t3) {
+    array<T, 4> result = { t0, t1, t2, t3 };
+    return result;
+  }
+
+  template<class T>
+  array<T, 5> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
+                         const T &t4)
+  {
+    array<T, 5> result = { t0, t1, t2, t3, t4 };
+    return result;
+  }
+
+  template<class T>
+  array<T, 6> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
+                         const T &t4, const T &t5)
+  {
+    array<T, 6> result = { t0, t1, t2, t3, t4, t5 };
+    return result;
+  }
+
+  template<class T>
+  array<T, 7> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
+                         const T &t4, const T &t5, const T &t6)
+  {
+    array<T, 7> result = { t0, t1, t2, t3, t4, t5, t6 };
+    return result;
+  }
+
+  template<class T>
+  array<T, 8> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
+                         const T &t4, const T &t5, const T &t6, const T &t7)
+  {
+    array<T, 8> result = { t0, t1, t2, t3, t4, t5, t6, t7 };
+    return result;
+  }
+
+  template<class T>
+  array<T, 9> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
+                         const T &t4, const T &t5, const T &t6, const T &t7,
+                         const T &t8)
+  {
+    array<T, 9> result = { t0, t1, t2, t3, t4, t5, t6, t7, t8 };
+    return result;
+  }
+#endif // !DOXYGEN
+
+  //! create an initialize an array
+  /**
+   * \note There are overloads for this method which take fewer arguments
+   *       (minimum 1).  The current maximum of 10 arguments is arbitrary and
+   *       can be raised on demand.
+   * \note This method is Dune-specific and not part of any C++-standard.
+   */
+  template<class T>
+  array<T, 10> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
+                          const T &t4, const T &t5, const T &t6, const T &t7,
+                          const T &t8, const T &t9)
+  {
+    array<T, 10> result = { t0, t1, t2, t3, t4, t5, t6, t7, t8, t9 };
+    return result;
+  }
+
   /** @} */
 
 } // end namespace Dune

dune/common/test/Makefile.am

@@ -3,6 +3,7 @@
 
 TESTPROGS = \
     arraylisttest \
+    arraytest \
     bigunsignedinttest \
     bitsetvectortest \
     conversiontest \
@@ -104,6 +105,8 @@ test_stack_SOURCES = test-stack.cc
 
 arraylisttest_SOURCES = arraylisttest.cc
 
+arraytest_SOURCES = arraytest.cc
+
 shared_ptrtest_config_SOURCES = shared_ptrtest.cc
 
 shared_ptrtest_dune_SOURCES = shared_ptrtest.cc

dune/common/test/arraytest.cc

+// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+// vi: set et ts=4 sw=2 sts=2:
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <cstddef>
+#include <iostream>
+#include <ostream>
+
+#include <dune/common/array.hh>
+#include <dune/common/classname.hh>
+#include <dune/common/fvector.hh>
+
+template<class T, std::size_t n>
+void f(const Dune::array<T, n> &a) {
+  std::cout << "Got a " << Dune::className(a) << " with elements";
+  for(std::size_t i = 0; i < n; ++i)
+    std::cout << " (" << a[i] << ")";
+  std::cout << std::endl;
+}
+
+int main() {
+  // check that make_array works
+  f(Dune::make_array(1, 2));
+
+  Dune::FieldVector<double, 2> x(0);
+  f(Dune::make_array(x, x));
+}