Add untested ForEachTypeNested

Author: franzpoeschel

include/openPMD/binding/python/auxiliary.hpp

@@ -37,7 +37,8 @@ struct ForEachType<Functor, FirstType, OtherTypes...>
     static void call(Args &&...args)
     {
         Functor::template call<FirstType>(args...);
-        ForEachType<Functor, OtherTypes...>::template call<Args...>(args...);
+        ForEachType<Functor, OtherTypes...>::template call<Args...>(
+            std::forward<Args>(args)...);
     }
 };
 
@@ -49,4 +50,121 @@ struct ForEachType<Functor>
     { /* no-op */
     }
 };
+
+namespace internal
+{
+
+    template <typename Functor, typename... Tuples>
+    struct ForEachTypeNestedImpl;
+
+    // Functor::template call<std::tuple<Type1, Type2, Type3, ...>>(args...)
+    template <typename Functor, typename FirstTuple, typename... Tuples>
+    struct ForEachTypeNestedImpl<Functor, FirstTuple, Tuples...>
+    {
+
+        template <typename InnerFunctor, typename Tuple>
+        struct ForEachType_Tuple;
+
+        template <typename InnerFunctor, typename... Types>
+        struct ForEachType_Tuple<InnerFunctor, std::tuple<Types...>>
+        {
+            template <typename... Args>
+            static void call(Args &&...args)
+            {
+                ForEachType<InnerFunctor, Types...>::template call<Args...>(
+                    std::forward<Args>(args)...);
+            }
+        };
+
+        template <typename FirstType, typename Tuple>
+        struct PrependToTuple;
+        template <typename FirstType, typename... Othertypes>
+        struct PrependToTuple<FirstType, std::tuple<Othertypes...>>
+        {
+            using type = std::tuple<FirstType, Othertypes...>;
+        };
+
+        // transform the outer Functor such that the first type argument
+        // FirstType is already specified
+        template <typename FirstType>
+        struct PartialApply
+        {
+            // RestType is a tuple
+            // Args the function arguments
+            template <typename RestTypes, typename... Args>
+            static void call(Args &&...args)
+            {
+                using concatenated_tuple_t =
+                    typename PrependToTuple<FirstType, RestTypes>::type;
+                Functor::template call<concatenated_tuple_t, Args...>(
+                    std::forward<Args>(args)...);
+            }
+        };
+
+        struct Runner
+        {
+            template <typename Type1, typename... Args>
+            static void call(Args &&...args)
+            {
+                using partially_applied_t = PartialApply<Type1>;
+                // recursive call
+                ForEachTypeNestedImpl<partially_applied_t, Tuples...>::
+                    template call<Args...>(std::forward<Args>(args)...);
+            }
+        };
+
+        template <typename... Args>
+        static void call(Args &&...args)
+        {
+            // outer loop
+            using foreach_t = ForEachType_Tuple<Runner, FirstTuple>;
+            foreach_t::template call<Args...>(std::forward<Args>(args)...);
+        }
+    };
+
+    template <typename Functor>
+    struct ForEachTypeNestedImpl<Functor>
+    {
+        template <typename... Args>
+        static void call(Args &&...args)
+        {
+            Functor::template call<std::tuple<>, Args...>(
+                std::forward<Args>(args)...);
+        }
+    };
+} // namespace internal
+
+template <typename Functor, typename... Tuples>
+struct ForEachTypeNested
+{
+    template <typename InnerFunctor, typename Tuple>
+    struct ApplyTupleAsTypes;
+
+    template <typename InnerFunctor, typename... Types>
+    struct ApplyTupleAsTypes<InnerFunctor, std::tuple<Types...>>
+    {
+        template <typename... Args>
+        static void call(Args &&...args)
+        {
+            InnerFunctor::template call<Types...>(std::forward<Args>(args)...);
+        }
+    };
+
+    struct TupledFunctor
+    {
+        template <typename Tuple, typename... Args>
+        static void call(Args &&...args)
+        {
+            ApplyTupleAsTypes<Functor, Tuple>::template call<Args...>(
+                std::forward<Args>(args)...);
+        }
+    };
+
+    template <typename... Args>
+    static void call(Args &&...args)
+    {
+        internal::ForEachTypeNestedImpl<TupledFunctor, Tuples...>::
+            template call<Args...>(std::forward<Args>(args)...);
+    }
+};
 } // namespace auxiliary