Merge branch 'feature/tuplevector' into 'master'

Add the TupleVector class

The `TupleVector` class is a multitype container without
algebraic operations. It relates to `Dune::MultiTypeBlockVector`
like `std::vector` relates to `Dune::BlockVector`. This is achived
by augmenting `std::tuple` by the following:
* `operator[]` for `Dune::index_constant` arguments
* `static size()`
    
You can now write code like this which will work for multitype
and classic vector like containers:

```c++    
    using namespace Dune::Hybrid;
    forEach(integralRange(size(v)), [&](auto i) {
        v[i] = i;
    });
 ```

Notice that `TupleVector` was already present as implementation detail
of two tests in dune-common and that dune-functions and dune-solvers
also both contained their own variants

See merge request !134

dune/common/CMakeLists.txt

@@ -97,6 +97,7 @@ install(FILES
         timer.hh
         tuples.hh
         tupleutility.hh
+        tuplevector.hh
         typelist.hh
         typetraits.hh
         typeutilities.hh

dune/common/test/hybridutilitiestest.cc

@@ -9,50 +9,10 @@
 #include <vector>
 
 #include <dune/common/hybridutilities.hh>
+#include <dune/common/tuplevector.hh>
 #include <dune/common/test/testsuite.hh>
 
 
-/** \brief A std::tuple that allows access to its element via operator[]
- *
- * Since there is no heterogeneous container in dune-common that supports
- * operator[std::integralconstant<T,i>] we make our own for the test.
- */
-template<class... T>
-class TupleVector : public std::tuple<T...>
-{
-  using Base = std::tuple<T...>;
-public:
-
-  using Base::Base;
-
-  /** \brief Array-style access to the tuple elements */
-  template<std::size_t i>
-  decltype(auto) operator[](const Dune::index_constant<i>&)
-  {
-    return std::get<i>(*this);
-  }
-
-  template<std::size_t i>
-  constexpr decltype(auto) operator[](const Dune::index_constant<i>&) const
-  {
-    return std::get<i>(*this);
-  }
-
-  static constexpr auto size()
-  {
-    return std::tuple_size<Base>::value;
-  }
-};
-
-template<class... T>
-constexpr auto makeTupleVector(T&&... t)
-{
-  // The std::decay_t<T> is is a slight simplification,
-  // because std::reference_wrapper needs special care.
-  return TupleVector<std::decay_t<T>...>(std::forward<T>(t)...);
-}
-
-
 
 template<class C>
 auto incrementAll(C&& c)
@@ -91,7 +51,7 @@ auto incAndAppendToFirst(C&& c)
 int main()
 {
   auto vector = std::vector<int>{1, 2, 3};
-  auto numberTuple = makeTupleVector(0.1, 2, 3);
+  auto numberTuple = Dune::makeTupleVector(0.1, 2, 3);
 
   Dune::TestSuite test;
 
@@ -100,7 +60,7 @@ int main()
     << "Incrementing vector entries with Hybrid::forEach failed.";
 
   incrementAll(numberTuple);
-  test.check(numberTuple == makeTupleVector(1.1, 3, 4))
+  test.check(numberTuple == Dune::makeTupleVector(1.1, 3, 4))
     << "Incrementing tuple entries with Hybrid::forEach failed.";
 
   addIndex(vector);
@@ -108,13 +68,13 @@ int main()
     << "Adding indices to vector entries with Hybrid::forEach failed.";
 
   addIndex(numberTuple);
-  test.check(numberTuple == makeTupleVector(1.1, 4, 6))
+  test.check(numberTuple == Dune::makeTupleVector(1.1, 4, 6))
     << "Adding indices to vector entries with Hybrid::forEach failed.";
 
 
-  auto mixedTuple = makeTupleVector(std::string("1"), 2, 3);
+  auto mixedTuple = Dune::makeTupleVector(std::string("1"), 2, 3);
   incAndAppendToFirst(mixedTuple);
-  test.check(mixedTuple == makeTupleVector(std::string("1+1"), 3, 4))
+  test.check(mixedTuple == Dune::makeTupleVector(std::string("1+1"), 3, 4))
     << "Adding indices to vector entries with Hybrid::forEach failed.";
 
   return test.exit();

dune/common/test/indicestest.cc

@@ -7,25 +7,10 @@
 #include <tuple>
 
 #include <dune/common/indices.hh>
+#include <dune/common/tuplevector.hh>
 
 using namespace Dune;
 
-/** \brief A std::tuple that allows access to its element via operator[]
- *
- * Helper class to test the static indices with
- */
-template<class... T>
-struct TupleVector : public std::tuple<T...>
-{
-  /** \brief Array-style access to the tuple elements */
-  template<std::size_t i>
-  auto operator[](const index_constant<i>&)
-    ->decltype(std::get<i>(*this))
-  {
-    return std::get<i>(*this);
-  }
-};
-
 
 
 int main()
@@ -33,7 +18,7 @@ int main()
   using namespace Dune::Indices;
 
   // Test whether indices can be used to index a data structure
-  TupleVector<int,double,float> v;
+  Dune::TupleVector<int,double,float> v;
   v[_0] = 42;
   v[_1] = 3.14;
   v[_2] = 2.7;

dune/common/tuplevector.hh

+// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+// vi: set et ts=4 sw=2 sts=2:
+#ifndef DUNE_COMMON_TUPLEVECTOR_HH
+#define DUNE_COMMON_TUPLEVECTOR_HH
+
+#include <tuple>
+#include <utility>
+
+#include <dune/common/indices.hh>
+
+
+
+/**
+ * \file
+ * \brief Provides the TupleVector class that augments std::tuple by operator[]
+ * \author Carsten Gräser
+ */
+
+namespace Dune
+{
+
+
+
+/**
+ * \brief A class augmenting std::tuple by element access via operator[]
+ *
+ * \ingroup Utilities
+ */
+template<class... T>
+class TupleVector : public std::tuple<T...>
+{
+  using Base = std::tuple<T...>;
+
+public:
+
+  /** \brief Construct from a set of arguments
+   */
+  template<class... TT>
+  constexpr TupleVector(TT&&... tt) :
+    Base(std::forward<TT>(tt)...)
+  {}
+
+  /** \brief Default constructor
+   */
+  constexpr TupleVector()
+  {}
+
+  /** \brief Const access to the tuple elements
+   */
+  template<std::size_t i>
+  constexpr decltype(auto) operator[](const Dune::index_constant<i>&) const
+  {
+    return std::get<i>(*this);
+  }
+
+  /** \brief Non-const access to the tuple elements
+   */
+  template<std::size_t i>
+  decltype(auto) operator[](const Dune::index_constant<i>&)
+  {
+    return std::get<i>(*this);
+  }
+
+  /** \brief Number of elements of the tuple */
+  static constexpr std::size_t size()
+  {
+    return std::tuple_size<Base>::value;
+  }
+};
+
+
+
+template<class... T>
+constexpr auto makeTupleVector(T&&... t)
+{
+  // The std::decay_t<T> is is a slight simplification,
+  // because std::reference_wrapper needs special care.
+  return TupleVector<std::decay_t<T>...>(std::forward<T>(t)...);
+}
+
+
+
+}  // namespace Dune
+
+#endif // DUNE_COMMON_TUPLEVECTOR_HH