Add a constructor from std::array to DiscreteElement and DiscreteVector (#969)

* Add a constructor from std::array to DiscreteElement and DiscreteVector

* Remove redundant static_assert

Author: tpadioleau

CMakeLists.txt

@@ -140,6 +140,7 @@ target_sources(
                 include/ddc/detail/tagged_vector.hpp
                 include/ddc/detail/type_seq.hpp
                 include/ddc/detail/type_traits.hpp
+                include/ddc/detail/utils.hpp
                 include/ddc/aligned_allocator.hpp
                 include/ddc/chunk.hpp
                 include/ddc/chunk_common.hpp

include/ddc/ddc.hpp

@@ -39,6 +39,7 @@ namespace ddc {
 #include "detail/macros.hpp"
 #include "detail/tagged_vector.hpp"
 #include "detail/type_seq.hpp"
+#include "detail/utils.hpp"
 
 #include "real_type.hpp"
 #include "scope_guard.hpp"

include/ddc/detail/utils.hpp

@@ -0,0 +1,29 @@
+// Copyright (C) The DDC development team, see COPYRIGHT.md file
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+#include <Kokkos_Macros.hpp>
+
+namespace ddc::detail {
+
+template <class OutputType, class InputType, std::size_t... Idx>
+KOKKOS_FUNCTION constexpr std::array<OutputType, sizeof...(Idx)> convert_array_to(
+        std::array<InputType, sizeof...(Idx)> const& values,
+        std::index_sequence<Idx...>) noexcept
+{
+    static_assert(std::is_convertible_v<InputType, OutputType>);
+    if constexpr (std::is_same_v<InputType, OutputType>) {
+        return values;
+    } else {
+        return {static_cast<OutputType>(std::get<Idx>(values))...};
+    }
+}
+
+} // namespace ddc::detail

include/ddc/discrete_element.hpp

@@ -14,6 +14,7 @@
 
 #include "detail/macros.hpp"
 #include "detail/type_seq.hpp"
+#include "detail/utils.hpp"
 
 #include "discrete_vector.hpp"
 
@@ -190,6 +191,17 @@ class DiscreteElement
     {
     }
 
+    template <
+            class IntegerType,
+            class = std::enable_if_t<std::is_convertible_v<IntegerType, DiscreteElementType>>>
+    KOKKOS_FUNCTION constexpr explicit DiscreteElement(
+            std::array<IntegerType, sizeof...(Tags)> const& values) noexcept
+        : m_values(
+                  detail::convert_array_to<
+                          DiscreteElementType>(values, std::make_index_sequence<sizeof...(Tags)>()))
+    {
+    }
+
     template <
             class... Params,
             class = std::enable_if_t<(!is_discrete_element_v<Params> && ...)>,

include/ddc/discrete_vector.hpp

@@ -14,6 +14,7 @@
 
 #include "detail/macros.hpp"
 #include "detail/type_seq.hpp"
+#include "detail/utils.hpp"
 
 namespace ddc {
 
@@ -300,6 +301,18 @@ class DiscreteVector : public detail::DiscreteVectorConversionOperators<Discrete
     {
     }
 
+    template <
+            class IntegerType,
+            class = std::enable_if_t<std::is_convertible_v<IntegerType, DiscreteVectorElement>>>
+    KOKKOS_FUNCTION constexpr explicit DiscreteVector(
+            std::array<IntegerType, sizeof...(Tags)> const& values) noexcept
+        : m_values(
+                  detail::convert_array_to<DiscreteVectorElement>(
+                          values,
+                          std::make_index_sequence<sizeof...(Tags)>()))
+    {
+    }
+
     template <
             class... Params,
             class = std::enable_if_t<(!is_discrete_vector_v<Params> && ...)>,

tests/discrete_element.cpp

@@ -44,6 +44,47 @@ using DVectXYZ = ddc::DiscreteVector<DDimX, DDimY, DDimZ>;
 
 } // namespace anonymous_namespace_workaround_discrete_element_cpp
 
+TEST(DiscreteElementXYTest, ValueConstructor)
+{
+    DElemXY const ixy {};
+    EXPECT_EQ(ixy.uid<DDimX>(), ddc::DiscreteElementType());
+    EXPECT_EQ(ixy.uid<DDimY>(), ddc::DiscreteElementType());
+}
+
+TEST(DiscreteElementXYTest, ConstructorFromIntegersWithoutConversion)
+{
+    ddc::DiscreteElementType const uid_x = 7;
+    ddc::DiscreteElementType const uid_y = 13;
+    DElemXY const ixy(uid_x, uid_y);
+    EXPECT_EQ(ixy.uid<DDimX>(), uid_x);
+    EXPECT_EQ(ixy.uid<DDimY>(), uid_y);
+}
+
+TEST(DiscreteElementXYTest, ConstructorFromIntegersWithConversion)
+{
+    short const uid_x = 7;
+    short const uid_y = 13;
+    DElemXY const ixy(uid_x, uid_y);
+    EXPECT_EQ(ixy.uid<DDimX>(), uid_x);
+    EXPECT_EQ(ixy.uid<DDimY>(), uid_y);
+}
+
+TEST(DiscreteElementXYTest, ConstructorFromArrayWithoutConversion)
+{
+    std::array<ddc::DiscreteElementType, 2> const uids {7, 13};
+    DElemXY const ixy(uids);
+    EXPECT_EQ(ixy.uid<DDimX>(), uids[0]);
+    EXPECT_EQ(ixy.uid<DDimY>(), uids[1]);
+}
+
+TEST(DiscreteElementXYTest, ConstructorFromArrayWithConversion)
+{
+    std::array<short, 2> const uids {7, 13};
+    DElemXY const ixy(uids);
+    EXPECT_EQ(ixy.uid<DDimX>(), uids[0]);
+    EXPECT_EQ(ixy.uid<DDimY>(), uids[1]);
+}
+
 TEST(DiscreteElementXYZTest, ConstructorFromDiscreteElements)
 {
     ddc::DiscreteElementType const uid_x = 7;
@@ -134,22 +175,6 @@ TEST(DiscreteElementXTest, BinaryOperatorMinus)
     EXPECT_EQ(ddc::get<DDimX>(dv2_x), dv_x);
 }
 
-TEST(DiscreteElementXYTest, ValueConstructor)
-{
-    DElemXY const ixy {};
-    EXPECT_EQ(ixy.uid<DDimX>(), ddc::DiscreteElementType());
-    EXPECT_EQ(ixy.uid<DDimY>(), ddc::DiscreteElementType());
-}
-
-TEST(DiscreteElementXYTest, UntaggedConstructor)
-{
-    ddc::DiscreteElementType const uid_x = 7;
-    ddc::DiscreteElementType const uid_y = 13;
-    DElemXY const ixy(uid_x, uid_y);
-    EXPECT_EQ(ixy.uid<DDimX>(), uid_x);
-    EXPECT_EQ(ixy.uid<DDimY>(), uid_y);
-}
-
 TEST(DiscreteElementXYTest, RightExternalBinaryOperatorPlus)
 {
     ddc::DiscreteElementType const uid_x = 7;

tests/discrete_vector.cpp

@@ -35,6 +35,47 @@ using DVectXYZ = ddc::DiscreteVector<DDimX, DDimY, DDimZ>;
 
 } // namespace anonymous_namespace_workaround_discrete_vector_cpp
 
+TEST(DiscreteVectorXZTest, ValueConstructor)
+{
+    DVectXZ const ixz {};
+    EXPECT_EQ(ixz.get<DDimX>(), ddc::DiscreteVectorElement());
+    EXPECT_EQ(ixz.get<DDimZ>(), ddc::DiscreteVectorElement());
+}
+
+TEST(DiscreteVectorXZTest, ConstructorFromIntegersWithoutConversion)
+{
+    ddc::DiscreteVectorElement const dv_x = 7;
+    ddc::DiscreteVectorElement const dv_z = 13;
+    DVectXZ const ixz(dv_x, dv_z);
+    EXPECT_EQ(ixz.get<DDimX>(), dv_x);
+    EXPECT_EQ(ixz.get<DDimZ>(), dv_z);
+}
+
+TEST(DiscreteVectorXZTest, ConstructorFromIntegersWithConversion)
+{
+    short const dv_x = 7;
+    short const dv_z = 13;
+    DVectXZ const ixz(dv_x, dv_z);
+    EXPECT_EQ(ixz.get<DDimX>(), dv_x);
+    EXPECT_EQ(ixz.get<DDimZ>(), dv_z);
+}
+
+TEST(DiscreteVectorXZTest, ConstructorFromArrayWithoutConversion)
+{
+    std::array<ddc::DiscreteVectorElement, 2> const dvs {7, 13};
+    DVectXZ const ixz(dvs);
+    EXPECT_EQ(ixz.get<DDimX>(), dvs[0]);
+    EXPECT_EQ(ixz.get<DDimZ>(), dvs[1]);
+}
+
+TEST(DiscreteVectorXZTest, ConstructorFromArrayWithConversion)
+{
+    std::array<short, 2> const dvs {7, 13};
+    DVectXZ const ixz(dvs);
+    EXPECT_EQ(ixz.get<DDimX>(), dvs[0]);
+    EXPECT_EQ(ixz.get<DDimZ>(), dvs[1]);
+}
+
 TEST(DiscreteVectorXYZTest, ConstructorFromDiscreteVectors)
 {
     ddc::DiscreteVectorElement const dv_x = 7;