add conversion assign to hymap (#1702)

include/gridtools/common/hymap.hpp

@@ -229,6 +229,21 @@ namespace gridtools {
             values &operator=(values const &) = default;
             values &operator=(values &&) = default;
 
+            template <class Src>
+            constexpr GT_FUNCTION
+                std::enable_if_t<((!std::is_same_v<values, std::decay_t<Src>> && is_hymap<std::decay_t<Src>>::value) &&
+                                     ... &&
+                                     std::is_assignable_v<Vals &,
+                                         std::add_lvalue_reference_t<element_at<Keys, std::remove_reference_t<Src>>>>),
+                    values &>
+                operator=(Src &&src) {
+                (...,
+                    (tuple_util::host_device::get<meta::st_position<meta::list<Keys...>, Keys>::value>(m_vals) =
+                            tuple_util::host_device::get<meta::st_position<get_keys<std::decay_t<Src>>, Keys>::value>(
+                                src)));
+                return *this;
+            }
+
             GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(values, m_vals);
 
             friend keys hymap_get_keys(values const &) { return {}; }
@@ -252,7 +267,7 @@ namespace gridtools {
                 meta::if_<meta::is_empty<MetaMap>, meta::list<meta::list<>, meta::list<>>, meta::transpose<MetaMap>>>
         using from_meta_map = from_keys_values<meta::first<KeysAndValues>, meta::second<KeysAndValues>, KeyCtor>;
 
-        namespace hymap_impl_ {
+        namespace impl_ {
             template <class Maps>
             using merged_keys = meta::dedup<meta::transform<meta::first, meta::flatten<Maps>>>;
 
@@ -285,7 +300,7 @@ namespace gridtools {
                 template <class Values, class Maps, class Keys = meta::flatten<meta::transform<get_keys, Maps>>>
                 using apply = typename get_from_keys_values<meta::first<Maps>>::template apply<Keys, Values>;
             };
-        } // namespace hymap_impl_
+        } // namespace impl_
     }     // namespace hymap
 } // namespace gridtools
 
@@ -377,7 +392,7 @@ namespace gridtools {
             template <class... Maps>
             GT_TARGET GT_FORCE_INLINE constexpr auto concat(Maps... maps) {
                 static_assert(meta::is_set_fast<meta::concat<get_keys<Maps>...>>::value, GT_INTERNAL_ERROR);
-                return tuple_util::concat_ex<hymap_impl_::concat_result_maker_f>(std::move(maps)...);
+                return tuple_util::concat_ex<impl_::concat_result_maker_f>(std::move(maps)...);
             }
 
             template <template <class...> class KeyCtor,
@@ -511,8 +526,8 @@ namespace gridtools {
             GT_TARGET GT_FORCE_INLINE constexpr auto merge(Primary primary, Secondaries... secondaries) {
                 return merge(std::move(primary), merge(std::move(secondaries)...));
             }
-        } // namespace hymap
-    }     // namespace hymap
+        }
+    } // namespace hymap
 } // namespace gridtools
 
 #endif // GT_TARGET_ITERATING

include/gridtools/common/tuple_util.hpp

@@ -289,8 +289,14 @@ namespace gridtools {
         //
         namespace lazy {
             template <size_t I, class T>
-            using element = meta::lazy::at_c<traits::to_types<T>, I>;
-        }
+            struct element {
+                using type = meta::at_c<traits::to_types<T>, I>;
+            };
+            template <size_t I, class T>
+            struct element<I, T const> {
+                using type = std::add_const_t<meta::at_c<traits::to_types<T>, I>>;
+            };
+        } // namespace lazy
         GT_META_DELEGATE_TO_LAZY(element, (size_t I, class T), (I, T));
 
         template <class T, class = void>

tests/unit_tests/common/test_hymap.cpp

@@ -188,14 +188,13 @@ namespace gridtools {
             EXPECT_EQ(16, at_key<c>(testee));
         }
 
-        TEST(concat, smoke) {
-            auto m1 = hymap::keys<a, b>::make_values(1, 2);
-            auto m2 = hymap::keys<c>::make_values(3.5);
-
-            auto testee = hymap::concat(m1, m2);
-            EXPECT_EQ(1, at_key<a>(testee));
-            EXPECT_EQ(2, at_key<b>(testee));
-            EXPECT_EQ(3.5, at_key<c>(testee));
+        TEST(assingment, smoke) {
+            hymap::keys<a, b>::values<double, double> testee;
+            auto src = hymap::keys<b, a, c>::make_values(88, 3.5, 16);
+            testee = src;
+            EXPECT_EQ(3.5, at_key<a>(testee));
+            EXPECT_EQ(88, at_key<b>(testee));
         }
+
     } // namespace
 } // namespace gridtools

tests/unit_tests/sid/test_sid_composite.cpp

@@ -237,5 +237,22 @@ namespace gridtools {
             EXPECT_EQ(at_key<a>(stride_j), 0);
             EXPECT_EQ(at_key<b>(stride_j), 1);
         }
+
+        TEST(composite, assign) {
+            using field_t = double[1][1];
+
+            field_t const src0 = {42};
+            field_t const src1 = {24};
+            field_t dst0 = {};
+            field_t dst1 = {};
+
+            sid::composite::keys<a, b>::values<field_t const &, field_t const &> src(src0, src1);
+            sid::composite::keys<b, a>::values<field_t &, field_t &> dst(dst0, dst1);
+
+            *sid::get_origin(dst)() = *sid::get_origin(src)();
+
+            EXPECT_EQ(dst0[0][0], 24);
+            EXPECT_EQ(dst1[0][0], 42);
+        }
     } // namespace
 } // namespace gridtools