Use Hybrid::forEach instead of reimplementing the recursions and re-enable utilitytest

dune/common/array.hh

@@ -10,8 +10,8 @@
 
 #include <array>
 
-#include "dune/common/streamoperators.hh"
-#include "dune/common/std/make_array.hh"
+#include <dune/common/streamoperators.hh>
+#include <dune/common/std/make_array.hh>
 
 namespace Dune
 {

dune/common/forloop.hh

@@ -6,6 +6,9 @@
 
 #include <utility>
 
+#include <dune/common/hybridutilities.hh>
+#include <dune/common/std/utility.hh>
+
 /** \file
  * \brief A static for loop for template meta-programming
  */
@@ -13,46 +16,6 @@
 namespace Dune
 {
 
-#ifndef DOXYGEN
-  // GenericForLoop
-  // --------------
-
-  template< template< class, class > class Operation, template< int > class Value, int first, int last >
-  class GenericForLoop
-    : public Operation< Value< first >, GenericForLoop< Operation, Value, first+1, last > >
-  {
-    static_assert( (first <= last), "GenericForLoop: first > last" );
-  };
-
-  template< template< class, class > class Operation, template< int > class Value, int last >
-  class GenericForLoop< Operation, Value, last, last >
-    : public Value< last >
-  {};
-
-  // ForLoopHelper
-  // -------------
-
-  namespace ForLoopHelper
-  {
-
-    template< class A, class B >
-    struct Apply
-    {
-
-      template< typename... Params >
-      static void apply ( Params&&... params )
-      {
-        A::apply( std::forward<Params>(params)... );
-        B::apply( std::forward<Params>(params)... );
-      }
-
-    };
-
-  } // end namespace ForLoopHelper
-
-#endif
-
-
   /** \class ForLoop
    * @brief A static loop using TMP
    *
@@ -62,8 +25,8 @@ namespace Dune
    * which is called for i=first...last (first<=last are int template arguments).
    * A specialization for class template class Operation for i=first
    * or i=last is not required. The class Operation must provide a
-   * static void function apply(...). Arguments (as references)
-   * can be passed through the ForLoop to this function.
+   * static void function apply(...). Arguments are perfectly forwarded
+   * through the ForLoop to this function.
    *
    * It is possible to pass a subclass to the ForLoop
    * (since no specialization is needed).
@@ -98,17 +61,18 @@ namespace Dune
    *   }
    * };
    * \endcode
-   *
-   * \note Since Dune 2.4, ForLoop uses variadic templates and perfect forwarding and
-   *       thus supports arbitrary numbers of arguments to apply(), which can be any
-   *       combination of lvalues and rvalues.
-   *
    */
   template< template< int > class Operation, int first, int last >
-  class ForLoop
-    : public GenericForLoop< ForLoopHelper::Apply, Operation, first, last >
+  struct ForLoop
   {
     static_assert( (first <= last), "ForLoop: first > last" );
+
+    template<typename... Args>
+    static void apply(Args&&... args)
+    {
+      Hybrid::forEach(Std::make_index_sequence<last+1-first>{},
+        [&](auto i){Operation<i+first>::apply(std::forward<Args>(args)...);});
+    }
   };
 
 }

dune/common/streamoperators.hh

@@ -9,10 +9,10 @@
  */
 
 #include <array>
-#include <ostream>
 #include <tuple>
 
-#include <dune/common/forloop.hh>
+#include <dune/common/hybridutilities.hh>
+#include <dune/common/std/utility.hh>
 
 namespace Dune
 {
@@ -21,29 +21,6 @@ namespace Dune
      @{
    */
 
-  namespace
-  {
-    template<int i>
-    struct PrintTupleElement
-    {
-      template<typename Stream, typename Tuple>
-      static void apply(Stream& stream, const Tuple& t)
-      {
-        stream<<std::get<i>(t)<<",";
-      }
-    };
-
-    template<int i>
-    struct ReadTupleElement
-    {
-      template<typename Stream, typename Tuple>
-      static void apply(Stream& stream, Tuple& t)
-      {
-        stream>>std::get<i>(t);
-      }
-    };
-  }
-
   //! Print a std::tuple
   template<typename Stream, typename... Ts>
   inline Stream& operator<<(Stream& stream, const std::tuple<Ts...>& t)
@@ -51,7 +28,8 @@ namespace Dune
     stream<<"[";
     if(sizeof...(Ts)>0)
     {
-      ForLoop<PrintTupleElement, 0, sizeof...(Ts)-2>::apply(stream, t);
+      Hybrid::forEach(Std::make_index_sequence<sizeof...(Ts)-1>{},
+        [&](auto i){stream<<std::get<i>(t)<<",";});
       stream<<std::get<sizeof...(Ts)-1>(t);
     }
     stream<<"]";
@@ -62,7 +40,8 @@ namespace Dune
   template<typename Stream, typename... Ts>
   inline Stream& operator>>(Stream& stream, std::tuple<Ts...>& t)
   {
-    ForLoop<ReadTupleElement, 0, sizeof...(Ts)-1>::apply(stream, t);
+    Hybrid::forEach(Std::make_index_sequence<sizeof...(Ts)>{},
+      [&](auto i){stream>>std::get<i>(t);});
     return stream;
   }
 

dune/common/test/CMakeLists.txt

@@ -202,7 +202,7 @@ dune_add_test(SOURCES testfloatcmp.cc)
 
 dune_add_test(SOURCES tupleutilitytest.cc)
 
-#dune_add_test(SOURCES utilitytest.cc)
+dune_add_test(SOURCES utilitytest.cc)
 
 dune_add_test(SOURCES eigenvaluestest.cc
               LINK_LIBRARIES dunecommon

dune/common/test/utilitytest.cc

@@ -30,27 +30,26 @@ struct Counter {
 
 int main(int, char**)
 {
-
   typedef std::tuple<int*,double*,long*,char*> PointerTuple;
+  PointerTuple pointers = Dune::NullPointerInitialiser<PointerTuple>::apply();
 
-  std::tuple<int*,double*,long*,char*> pointers = Dune::NullPointerInitialiser<PointerTuple>::apply();
   int ret=0;
 
-  if(std::get<0>(pointers)!=0) {
+  if(std::get<0>(pointers)!=nullptr) {
     std::cerr<<"First pointer not null"<<std::endl;
     ret=1;
   }
-  if(std::get<1>(pointers)!=0) {
+  if(std::get<1>(pointers)!=nullptr) {
     std::cerr<<"Second pointer not null"<<std::endl;
     ret=2;
   }
 
-  if(std::get<2>(pointers)!=0) {
+  if(std::get<2>(pointers)!=nullptr) {
     std::cerr<<"Third pointer not null"<<std::endl;
     ret=3;
   }
 
-  if(std::get<3>(pointers)!=0) {
+  if(std::get<3>(pointers)!=nullptr) {
     std::cerr<<"Fourth pointer not null"<<std::endl;
     ret=4;
   }
@@ -70,15 +69,19 @@ int main(int, char**)
 
   Tuple1 t1(i,c,l,c);
   RefTuple1 refs(i, c, l, c);
+
+#if 0
   DUNE_UNUSED RefTuple1 refs2(Dune::transformTuple<Dune::AddRefTypeEvaluator>(t1));
-  PointerTuple1 pointers1
-    (Dune::transformTuple<Dune::AddPtrTypeEvaluator>(refs));
+  PointerTuple1 pointers1(Dune::transformTuple<Dune::AddPtrTypeEvaluator>(refs));
   if(&i != std::get<0>(pointers1) || &c != std::get<1>(pointers1) ||
      &l != std::get<2>(pointers1) || &c != std::get<3>(pointers1)) {
     std::cerr << "utilitytest: error: incorrect pointers in pointers1"
               << std::endl;
     ret = 1;
   }
+#endif
+
+  PointerTuple1 pointers1 = Dune::NullPointerInitialiser<PointerTuple1>::apply();
 
   if(static_cast<size_t>(std::tuple_size<PointerTuple>::value) != static_cast<size_t>(std::tuple_size<PointerTuple>::value)) {
     std::cerr<<"Length and size do not match!"<<std::endl;
@@ -90,8 +93,6 @@ int main(int, char**)
   forEach.apply(count);
   std::cout << "Number of elements is: " << count.result_ << std::endl;
 
-
-
   Dune::ForEachValuePair<PointerTuple,PointerTuple1> foreach1(pointers, pointers1);
 
   foreach1.apply(count);
@@ -105,6 +106,10 @@ int main(int, char**)
 
   typedef Dune::ForEachType<Eval,PointerTuple1>::Type ConvertedType DUNE_UNUSED;
   Dune::PointerPairDeletor<PointerTuple1>::apply(p);
+  if(p != PointerTuple1(nullptr,nullptr,nullptr,nullptr)){
+    ret+=20;
+    std::cerr<<"PointerPairDeletor not working!"<<std::endl;
+  }
 
   return ret;
 }

dune/common/tupleutility.hh

@@ -5,12 +5,10 @@
 #define DUNE_TUPLE_UTILITY_HH
 
 #include <cstddef>
-#include <iostream>
 #include <tuple>
+#include <type_traits>
 
-#include <dune/common/forloop.hh>
-#include <dune/common/unused.hh>
-#include <dune/common/typetraits.hh>
+#include <dune/common/hybridutilities.hh>
 #include <dune/common/std/type_traits.hh>
 #include <dune/common/std/utility.hh>
 
@@ -318,43 +316,6 @@ namespace Dune {
     }
   };
 
-  namespace
-  {
-    template<int i, typename T1,typename F>
-    struct Visitor
-    {
-      static inline void visit(F& func, T1& t1)
-      {
-        func.visit(std::get<std::tuple_size<T1>::value-i>(t1));
-        Visitor<i-1,T1,F>::visit(func, t1);
-      }
-    };
-
-    template<typename T1,typename F>
-    struct Visitor<0,T1,F>
-    {
-      static inline void visit(F&, T1&)
-      {}
-    };
-
-    template<int i, typename T1, typename T2,typename F>
-    struct PairVisitor
-    {
-      static inline void visit(F& func, T1& t1, T2& t2)
-      {
-        func.visit(std::get<std::tuple_size<T1>::value-i>(t1), std::get<std::tuple_size<T2>::value-i>(t2));
-        PairVisitor<i-1,T1,T2,F>::visit(func, t1, t2);
-      }
-    };
-
-    template<typename T1, typename T2, typename F>
-    struct PairVisitor<0,T1,T2,F>
-    {
-      static inline void visit(F&, T1&, T2&)
-      {}
-    };
-  }
-
   /**
    * @brief Helper template which implements iteration over all storage
    * elements in a std::tuple.
@@ -413,7 +374,8 @@ namespace Dune {
     template<class Functor>
     void apply(Functor& f) const
     {
-      Visitor<std::tuple_size<Tuple>::value,Tuple,Functor>::visit(f, t_);
+      Hybrid::forEach(Std::make_index_sequence<std::tuple_size<Tuple>::value>{},
+        [&](auto i){f.visit(std::get<i>(t_));});
     }
   private:
     Tuple& t_;
@@ -449,7 +411,8 @@ namespace Dune {
     template<class Functor>
     void apply(Functor& f)
     {
-      PairVisitor<std::tuple_size<Tuple1>::value,Tuple1,Tuple2,Functor>::visit(f, t1_, t2_);
+      Hybrid::forEach(Std::make_index_sequence<std::tuple_size<Tuple1>::value>{},
+        [&](auto i){f.visit(std::get<i>(t1_), std::get<i>(t2_));});
     }
   private:
     Tuple1& t1_;
@@ -494,27 +457,14 @@ namespace Dune {
 
   /**
    * @brief Deletes all objects pointed to in a std::tuple of pointers.
-   *
-   * \warning Pointers cannot be set to nullptr, so calling the Deletor twice
-   * or accessing elements of a deleted std::tuple leads to unforeseeable results!
    */
   template<class Tuple>
-  class PointerPairDeletor
+  struct PointerPairDeletor
   {
-    struct Deletor
-    {
-      template<typename P>
-      void visit(const P& p)
-      {
-        delete p;
-      }
-    };
-
-  public:
-    static void apply(Tuple& t)
+    template<typename... Ts>
+    static void apply(std::tuple<Ts...>& t)
     {
-      static Deletor deletor;
-      ForEachValue<Tuple>(t).apply(deletor);
+      Hybrid::forEach(t,[&](auto&& ti){delete ti; ti=nullptr;});
     }
   };