From 1158bc2a770c0b7e04462ca7e2a9cf5bb8de7a36 Mon Sep 17 00:00:00 2001
From: Bernhard Manfred Gruber <bernhardmgruber@gmail.com>
Date: Wed, 14 Sep 2022 12:46:09 +0200
Subject: [PATCH] Refactor asTupleImpl and asFlatTupleImpl

This should improve readability and make the return type more clearly visible.
---
 include/llama/RecordRef.hpp | 46 ++++++++++++++++++++++---------------
 1 file changed, 28 insertions(+), 18 deletions(-)

diff --git a/include/llama/RecordRef.hpp b/include/llama/RecordRef.hpp
index 98986bc34e..9aa7982afa 100644
--- a/include/llama/RecordRef.hpp
+++ b/include/llama/RecordRef.hpp
@@ -195,22 +195,27 @@ namespace llama
             }
         };
 
-        template<typename ProxyReference, typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto asTupleImpl(ProxyReference&& leaf, T)
-            -> std::enable_if_t<!isRecordRef<std::decay_t<ProxyReference>>, ProxyReference>
+        template<
+            typename ProxyReference,
+            typename T,
+            std::enable_if_t<!isRecordRef<std::decay_t<ProxyReference>>, int> = 0>
+        LLAMA_FN_HOST_ACC_INLINE auto asTupleImpl(ProxyReference&& leaf, T) -> ProxyReference
         {
             return leaf;
         }
 
-        template<typename TWithOptionalConst, typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto asTupleImpl(TWithOptionalConst& leaf, T) -> std::
-            enable_if_t<!isRecordRef<std::decay_t<TWithOptionalConst>>, std::reference_wrapper<TWithOptionalConst>>
+        template<
+            typename TWithOptionalConst,
+            typename T,
+            std::enable_if_t<!isRecordRef<std::decay_t<TWithOptionalConst>>, int> = 0>
+        LLAMA_FN_HOST_ACC_INLINE auto asTupleImpl(TWithOptionalConst& leaf, T)
+            -> std::reference_wrapper<TWithOptionalConst>
         {
             return leaf;
         }
 
         template<typename RecordRef, typename T, std::size_t N, std::size_t... Is>
-        LLAMA_FN_HOST_ACC_INLINE auto asTupleImplArr(RecordRef&& vd, T (&&)[N], std::index_sequence<Is...>)
+        LLAMA_FN_HOST_ACC_INLINE auto asTupleImplForArray(RecordRef&& vd, T (&&)[N], std::index_sequence<Is...>)
         {
             return std::make_tuple(asTupleImpl(vd(RecordCoord<Is>{}), T{})...);
         }
@@ -218,7 +223,7 @@ namespace llama
         template<typename RecordRef, typename T, std::size_t N>
         LLAMA_FN_HOST_ACC_INLINE auto asTupleImpl(RecordRef&& vd, T (&&a)[N])
         {
-            return asTupleImplArr(std::forward<RecordRef>(vd), std::move(a), std::make_index_sequence<N>{});
+            return asTupleImplForArray(std::forward<RecordRef>(vd), std::move(a), std::make_index_sequence<N>{});
         }
 
         template<typename RecordRef, typename... Fields>
@@ -227,22 +232,27 @@ namespace llama
             return std::make_tuple(asTupleImpl(vd(GetFieldTag<Fields>{}), GetFieldType<Fields>{})...);
         }
 
-        template<typename ProxyReference, typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto asFlatTupleImpl(ProxyReference&& leaf, T)
-            -> std::enable_if_t<!isRecordRef<std::decay_t<ProxyReference>>, std::tuple<ProxyReference>>
+        template<
+            typename ProxyReference,
+            typename T,
+            std::enable_if_t<!isRecordRef<std::decay_t<ProxyReference>>, int> = 0>
+        LLAMA_FN_HOST_ACC_INLINE auto asFlatTupleImpl(ProxyReference&& leaf, T) -> std::tuple<ProxyReference>
         {
-            return {std::move(leaf)};
+            static_assert(!std::is_reference_v<ProxyReference>);
+            return {std::move(leaf)}; // NOLINT(bugprone-move-forwarding-reference)
         }
 
-        template<typename TWithOptionalConst, typename T>
-        LLAMA_FN_HOST_ACC_INLINE auto asFlatTupleImpl(TWithOptionalConst& leaf, T)
-            -> std::enable_if_t<!isRecordRef<std::decay_t<TWithOptionalConst>>, std::tuple<TWithOptionalConst&>>
+        template<
+            typename TWithOptionalConst,
+            typename T,
+            std::enable_if_t<!isRecordRef<std::decay_t<TWithOptionalConst>>, int> = 0>
+        LLAMA_FN_HOST_ACC_INLINE auto asFlatTupleImpl(TWithOptionalConst& leaf, T) -> std::tuple<TWithOptionalConst&>
         {
             return {leaf};
         }
 
         template<typename RecordRef, typename T, std::size_t N, std::size_t... Is>
-        LLAMA_FN_HOST_ACC_INLINE auto asFlatTupleImplArr(RecordRef&& vd, T (&&)[N], std::index_sequence<Is...>)
+        LLAMA_FN_HOST_ACC_INLINE auto asFlatTupleImplForArray(RecordRef&& vd, T (&&)[N], std::index_sequence<Is...>)
         {
             return std::tuple_cat(asFlatTupleImpl(vd(RecordCoord<Is>{}), T{})...);
         }
@@ -250,7 +260,7 @@ namespace llama
         template<typename RecordRef, typename T, std::size_t N>
         LLAMA_FN_HOST_ACC_INLINE auto asFlatTupleImpl(RecordRef&& vd, T (&&a)[N])
         {
-            return asFlatTupleImplArr(std::forward<RecordRef>(vd), std::move(a), std::make_index_sequence<N>{});
+            return asFlatTupleImplForArray(std::forward<RecordRef>(vd), std::move(a), std::make_index_sequence<N>{});
         }
 
         template<typename RecordRef, typename... Fields>
@@ -302,7 +312,7 @@ namespace llama
         LLAMA_FN_HOST_ACC_INLINE auto makeFromTuple(Tuple&& src, std::index_sequence<Is...>)
         {
             using std::get;
-            return T{get<Is>(std::forward<Tuple>(src))...};
+            return T{get<Is>(src)...}; // no forward of src, since we call get multiple times on it
         }
 
         template<typename T, typename SFINAE, typename... Args>