Fix inconsistency between explicit constructors and assignement ope…

include/ddc/detail/tagged_vector.hpp

@@ -290,22 +290,6 @@ class TaggedVector : public TaggedVectorConversionOperators<TaggedVector<Element
 
     KOKKOS_DEFAULTED_FUNCTION TaggedVector& operator=(TaggedVector&& other) = default;
 
-    template <class... OTags>
-    KOKKOS_FUNCTION constexpr TaggedVector& operator=(
-            TaggedVector<ElementType, OTags...> const& other) noexcept
-    {
-        ((this->get<Tags>() = other.template get<Tags>()), ...);
-        return *this;
-    }
-
-    template <class... OTags>
-    KOKKOS_FUNCTION constexpr TaggedVector& operator=(
-            TaggedVector<ElementType, OTags...>&& other) noexcept
-    {
-        ((this->get<Tags>() = std::move(other.template get<Tags>())), ...);
-        return *this;
-    }
-
     /// Returns a reference to the underlying `std::array`
     KOKKOS_FUNCTION constexpr std::array<ElementType, sizeof...(Tags)>& array() noexcept
     {

include/ddc/discrete_domain.hpp

@@ -100,25 +100,6 @@ class DiscreteDomain
 
     KOKKOS_DEFAULTED_FUNCTION DiscreteDomain& operator=(DiscreteDomain&& x) = default;
 
-    /**
-     * @brief Copy a DiscreteDomain by reordering and slicing.
-     *
-     * An assign operator to build a DiscreteDomain from another compatible domain.
-     * A domain is compatible if it either contains the same dimensions as this
-     * domain (even if they are in a different order) or if it contains at
-     * the dimensions of this domain plus some additional dimensions which will
-     * be unused here.
-     *
-     * @param domain A compatible domain.
-     */
-    template <class... ODDims>
-    DiscreteDomain& KOKKOS_FUNCTION operator=(DiscreteDomain<ODDims...> const& domain)
-    {
-        m_element_begin = DiscreteElement<DDims...>(domain.front());
-        m_element_end = m_element_begin + DiscreteVector<DDims...>(domain.extents());
-        return *this;
-    }
-
     template <class... ODims>
     KOKKOS_FUNCTION constexpr bool operator==(DiscreteDomain<ODims...> const& other) const
     {

include/ddc/discrete_element.hpp

@@ -192,21 +192,6 @@ class DiscreteElement
 
     KOKKOS_DEFAULTED_FUNCTION DiscreteElement& operator=(DiscreteElement&& other) = default;
 
-    template <class... OTags>
-    KOKKOS_FUNCTION constexpr DiscreteElement& operator=(
-            DiscreteElement<OTags...> const& other) noexcept
-    {
-        m_values = other.m_values;
-        return *this;
-    }
-
-    template <class... OTags>
-    KOKKOS_FUNCTION constexpr DiscreteElement& operator=(DiscreteElement<OTags...>&& other) noexcept
-    {
-        m_values = std::move(other.m_values);
-        return *this;
-    }
-
     template <class QueryTag>
     KOKKOS_FUNCTION constexpr value_type const& uid_or(value_type const& default_value) const&
     {

include/ddc/discrete_vector.hpp

@@ -300,21 +300,6 @@ class DiscreteVector : public detail::DiscreteVectorConversionOperators<Discrete
 
     KOKKOS_DEFAULTED_FUNCTION constexpr DiscreteVector& operator=(DiscreteVector&& other) = default;
 
-    template <class... OTags>
-    KOKKOS_FUNCTION constexpr DiscreteVector& operator=(
-            DiscreteVector<OTags...> const& other) noexcept
-    {
-        m_values = other.m_values;
-        return *this;
-    }
-
-    template <class... OTags>
-    KOKKOS_FUNCTION constexpr DiscreteVector& operator=(DiscreteVector<OTags...>&& other) noexcept
-    {
-        m_values = std::move(other.m_values);
-        return *this;
-    }
-
     template <class... OTags>
     KOKKOS_FUNCTION constexpr bool operator==(DiscreteVector<OTags...> const& rhs) const noexcept
     {

tests/discrete_domain.cpp

@@ -252,19 +252,3 @@ TEST(ProductMDomainTest, Transpose3DConstructor)
     EXPECT_EQ(ddc::select<DDimY>(dom_x_y_z.back()), ddc::select<DDimY>(dom_z_y_x.back()));
     EXPECT_EQ(ddc::select<DDimZ>(dom_x_y_z.back()), ddc::select<DDimZ>(dom_z_y_x.back()));
 }
-
-TEST(ProductMDomainTest, Transpose3DAssign)
-{
-    DDomX const dom_x(lbound_x, nelems_x);
-    DDomY const dom_y(lbound_y, nelems_y);
-    DDomZ const dom_z(lbound_z, nelems_z);
-    DDomXYZ const dom_x_y_z(dom_x, dom_y, dom_z);
-    DDomZYX dom_z_y_x;
-    dom_z_y_x = dom_x_y_z;
-    EXPECT_EQ(ddc::select<DDimX>(dom_x_y_z.front()), ddc::select<DDimX>(dom_z_y_x.front()));
-    EXPECT_EQ(ddc::select<DDimY>(dom_x_y_z.front()), ddc::select<DDimY>(dom_z_y_x.front()));
-    EXPECT_EQ(ddc::select<DDimZ>(dom_x_y_z.front()), ddc::select<DDimZ>(dom_z_y_x.front()));
-    EXPECT_EQ(ddc::select<DDimX>(dom_x_y_z.back()), ddc::select<DDimX>(dom_z_y_x.back()));
-    EXPECT_EQ(ddc::select<DDimY>(dom_x_y_z.back()), ddc::select<DDimY>(dom_z_y_x.back()));
-    EXPECT_EQ(ddc::select<DDimZ>(dom_x_y_z.back()), ddc::select<DDimZ>(dom_z_y_x.back()));
-}

tests/discrete_element.cpp

@@ -57,6 +57,19 @@ TEST(DiscreteElementXYZTest, ConstructorFromDiscreteElements)
     EXPECT_EQ(ixyz.uid<DDimZ>(), uid_z);
 }
 
+TEST(DiscreteElementXYZTest, CopyAssignment)
+{
+    std::size_t const uid_x = 7;
+    std::size_t const uid_y = 13;
+    std::size_t const uid_z = 4;
+    DElemXYZ const ixyz(uid_x, uid_y, uid_z);
+    DElemXYZ ixyz2(0, 0, 0);
+    ixyz2 = ixyz;
+    EXPECT_EQ(ixyz2.uid<DDimX>(), uid_x);
+    EXPECT_EQ(ixyz2.uid<DDimY>(), uid_y);
+    EXPECT_EQ(ixyz2.uid<DDimZ>(), uid_z);
+}
+
 TEST(DiscreteElementXTest, PreIncrement)
 {
     DElemX const ix0(3);

tests/tagged_vector.cpp

@@ -87,15 +87,6 @@ TEST(TaggedVector, Assignment)
     EXPECT_EQ(a.get<float>(), b.get<float>());
 }
 
-TEST(TaggedVector, ReorderingAssignment)
-{
-    ddc::detail::TaggedVector<int, double, float> const a(1, 2);
-    ddc::detail::TaggedVector<int, float, double> b;
-    b = a;
-    EXPECT_EQ(a.get<double>(), b.get<double>());
-    EXPECT_EQ(a.get<float>(), b.get<float>());
-}
-
 TEST(TaggedVector, MoveAssignment)
 {
     ddc::detail::TaggedVector<int, double, float> a(1, 2);
@@ -105,15 +96,6 @@ TEST(TaggedVector, MoveAssignment)
     EXPECT_EQ(2, b.get<float>());
 }
 
-TEST(TaggedVector, ReorderingMoveAssignment)
-{
-    ddc::detail::TaggedVector<int, double, float> a(1, 2);
-    ddc::detail::TaggedVector<int, float, double> b;
-    b = std::move(a);
-    EXPECT_EQ(1, b.get<double>());
-    EXPECT_EQ(2, b.get<float>());
-}
-
 TEST(TaggedVector, Conversion)
 {
     ddc::detail::TaggedVector<int, float, double> const a(1, 2);