allow virtual datum store to work with types reflectable by boost.pfr

Author: bernhardmgruber

examples/nbody/nbody.cpp

@@ -154,14 +154,15 @@ namespace usellama
         std::normal_distribution<FP> dist(FP(0), FP(1));
         for (std::size_t i = 0; i < PROBLEM_SIZE; ++i)
         {
-            auto p = particles(i);
-            p(0_DC, 0_DC) = dist(engine);
-            p(0_DC, 1_DC) = dist(engine);
-            p(0_DC, 2_DC) = dist(engine);
-            p(1_DC, 0_DC) = dist(engine) / FP(10);
-            p(1_DC, 1_DC) = dist(engine) / FP(10);
-            p(1_DC, 2_DC) = dist(engine) / FP(10);
-            p(2_DC) = dist(engine) / FP(100);
+            Particle p;
+            p.pos.x = dist(engine);
+            p.pos.y = dist(engine);
+            p.pos.z = dist(engine);
+            p.vel.x = dist(engine) / FP(10);
+            p.vel.y = dist(engine) / FP(10);
+            p.vel.z = dist(engine) / FP(10);
+            p.mass = dist(engine) / FP(100);
+            particles(i).store(p);
         }
         watch.printAndReset("init");
 

include/llama/View.hpp

@@ -10,6 +10,7 @@
 #include "macros.hpp"
 #include "mapping/One.hpp"
 
+#include <boost/pfr.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <type_traits>
 
@@ -259,18 +260,50 @@ namespace llama
         template <typename... Ts>
         constexpr inline auto dependentFalse = false;
 
+        template <typename T>
+        constexpr inline auto tupleish_size = []() constexpr
+        {
+            if constexpr (isTupleLike<T>)
+                return std::tuple_size_v<T>;
+            else if constexpr (std::is_aggregate_v<T>) // TODO
+                return boost::pfr::tuple_size_v<T>;
+            else
+                static_assert(
+                    dependentFalse<T>,
+                    "T is not a tuple like type or an aggregate to reflect with boost.pfr");
+        }
+        ();
+
+        template <std::size_t I, typename T>
+        decltype(auto) tupleish_get(T&& t)
+        {
+            using DT = std::decay_t<T>;
+            if constexpr (isTupleLike<DT>)
+            {
+                using std::get;
+                return get<I>(std::forward<T>(t));
+            }
+            else if constexpr (std::is_aggregate_v<DT>) // TODO
+                return boost::pfr::get<I>(std::forward<T>(t));
+            else
+                static_assert(
+                    dependentFalse<T>,
+                    "T is not a tuple like type or an aggregate to reflect with boost.pfr");
+        }
+
         template <typename Tuple1, typename Tuple2, std::size_t... Is>
         LLAMA_FN_HOST_ACC_INLINE void assignTuples(Tuple1&& dst, Tuple2&& src, std::index_sequence<Is...>);
 
         template <typename T1, typename T2>
         LLAMA_FN_HOST_ACC_INLINE void assignTupleElement(T1&& dst, T2&& src)
         {
-            if constexpr (isTupleLike<std::decay_t<T1>> && isTupleLike<std::decay_t<T2>>)
-            {
-                static_assert(std::tuple_size_v<std::decay_t<T1>> == std::tuple_size_v<std::decay_t<T2>>);
-                assignTuples(dst, src, std::make_index_sequence<std::tuple_size_v<std::decay_t<T1>>>{});
-            }
-            else if constexpr (!isTupleLike<std::decay_t<T1>> && !isTupleLike<std::decay_t<T2>>)
+            using DT1 = std::decay_t<T1>;
+            using DT2 = std::decay_t<T2>;
+            constexpr auto isTupleish1 = isTupleLike<DT1> || std::is_aggregate_v<DT1>;
+            constexpr auto isTupleish2 = isTupleLike<DT2> || std::is_aggregate_v<DT2>;
+            if constexpr (isTupleish1 && isTupleish2)
+                assignTuples(dst, src, std::make_index_sequence<tupleish_size<DT1>>{});
+            else if constexpr (!isTupleish1 && !isTupleish2)
                 std::forward<T1>(dst) = std::forward<T2>(src);
             else
                 static_assert(dependentFalse<T1, T2>, "Elements to assign are not tuple/tuple or non-tuple/non-tuple.");
@@ -279,9 +312,11 @@ namespace llama
         template <typename Tuple1, typename Tuple2, std::size_t... Is>
         LLAMA_FN_HOST_ACC_INLINE void assignTuples(Tuple1&& dst, Tuple2&& src, std::index_sequence<Is...>)
         {
-            static_assert(std::tuple_size_v<std::decay_t<Tuple1>> == std::tuple_size_v<std::decay_t<Tuple2>>);
-            using std::get;
-            (assignTupleElement(get<Is>(std::forward<Tuple1>(dst)), get<Is>(std::forward<Tuple2>(src))), ...);
+            static_assert(tupleish_size<std::decay_t<Tuple1>> == tupleish_size<std::decay_t<Tuple2>>);
+            (assignTupleElement(
+                 tupleish_get<Is>(std::forward<Tuple1>(dst)),
+                 tupleish_get<Is>(std::forward<Tuple2>(src))),
+             ...);
         }
 
         template <typename T, typename Tuple, std::size_t... Is>
@@ -659,7 +694,7 @@ namespace llama
         template <typename TupleLike>
         void store(const TupleLike& t)
         {
-            internal::assignTuples(asTuple(), t, std::make_index_sequence<std::tuple_size_v<TupleLike>>{});
+            internal::assignTuples(asTuple(), t, std::make_index_sequence<std::tuple_size_v<decltype(asTuple())>>{});
         }
     };
 } // namespace llama

tests/virtualdatum.cpp

@@ -797,7 +797,7 @@ TEST_CASE("VirtualDatum.load.constref")
     }
 }
 
-TEST_CASE("VirtualDatum.store")
+TEST_CASE("VirtualDatum.store.tuplelike")
 {
     llama::One<Name> datum;
 
@@ -878,3 +878,52 @@ TEST_CASE("VirtualDatum.loadAs.constref")
         CHECK(pos.y == 1);
     }
 }
+
+TEST_CASE("VirtualDatum.store.aggregate")
+{
+    struct MyPosAgg
+    {
+        int a;
+        int y;
+    };
+
+    struct MyVelAgg
+    {
+        int x;
+        int y;
+        int z;
+    };
+
+    struct MyDatumAgg
+    {
+        MyPosAgg pos;
+        MyVelAgg vel;
+        int weight;
+    };
+
+    llama::One<Name> datum;
+
+    datum = 1;
+    {
+        MyPosAgg pos{2, 3};
+        datum(tag::Pos{}).store(pos);
+        CHECK(datum(tag::Pos{}, tag::A{}) == 2);
+        CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
+        CHECK(datum(tag::Vel{}, tag::X{}) == 1);
+        CHECK(datum(tag::Vel{}, tag::Y{}) == 1);
+        CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
+        CHECK(datum(tag::Weight{}) == 1);
+    }
+
+    datum = 1;
+    {
+        MyDatumAgg d{{2, 3}, {4, 5, 6}, 7};
+        datum.store(d);
+        CHECK(datum(tag::Pos{}, tag::A{}) == 2);
+        CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
+        CHECK(datum(tag::Vel{}, tag::X{}) == 4);
+        CHECK(datum(tag::Vel{}, tag::Y{}) == 5);
+        CHECK(datum(tag::Vel{}, tag::Z{}) == 6);
+        CHECK(datum(tag::Weight{}) == 7);
+    }
+}