Enforce that the dimensions passed to discrete element, vector and domain are unique (CExA-project#972)

* Enforce that the dimensions passed to discrete element, vector and domain
are unique

* Introduce a `type_seq_is_unique` trait

Author: tretre91

include/ddc/detail/type_seq.hpp

@@ -189,6 +189,9 @@ constexpr bool in_tags_v = false;
 template <class TypeSeq, class OTypeSeq>
 constexpr bool type_seq_contains_v = false;
 
+template <class TypeSeq>
+constexpr bool type_seq_is_unique_v = false;
+
 template <class TypeSeq, class B>
 constexpr bool type_seq_same_v = type_seq_contains_v<TypeSeq, B> && type_seq_contains_v<B, TypeSeq>;
 
@@ -220,6 +223,12 @@ template <class TagSeqA, class TagSeqB, class TagSeqC>
 using type_seq_replace_t =
         typename detail::TypeSeqReplace<TagSeqA, TagSeqB, TagSeqC, detail::TypeSeq<>>::type;
 
+template <class... Tags>
+constexpr bool type_seq_is_unique_v<detail::TypeSeq<Tags...>>
+        = ((type_seq_size_v<type_seq_remove_t<detail::TypeSeq<Tags...>, detail::TypeSeq<Tags>>>
+            == sizeof...(Tags) - 1)
+           && ...);
+
 template <class T>
 using to_type_seq_t = typename detail::ToTypeSeq<T>::type;
 

include/ddc/discrete_domain.hpp

@@ -63,6 +63,10 @@ class DiscreteDomain
     template <class...>
     friend class DiscreteDomain;
 
+    static_assert(
+            type_seq_is_unique_v<detail::TypeSeq<DDims...>>,
+            "The dimensions of a DiscreteDomain must be unique");
+
 public:
     using discrete_element_type = DiscreteElement<DDims...>;
 

include/ddc/discrete_element.hpp

@@ -161,6 +161,10 @@ class DiscreteElement
 {
     using tags_seq = detail::TypeSeq<Tags...>;
 
+    static_assert(
+            type_seq_is_unique_v<tags_seq>,
+            "The dimensions of a DiscreteElement must be unique");
+
     friend KOKKOS_FUNCTION constexpr std::array<DiscreteElementType, sizeof...(Tags)>& detail::
             array<Tags...>(DiscreteElement<Tags...>& v) noexcept;
 

include/ddc/discrete_vector.hpp

@@ -277,6 +277,10 @@ class DiscreteVector : public detail::DiscreteVectorConversionOperators<Discrete
 
     using tags_seq = detail::TypeSeq<Tags...>;
 
+    static_assert(
+            type_seq_is_unique_v<tags_seq>,
+            "The dimensions of a DiscreteVector must be unique");
+
 private:
     std::array<DiscreteVectorElement, sizeof...(Tags)> m_values;
 

include/ddc/sparse_discrete_domain.hpp

@@ -122,6 +122,10 @@ class SparseDiscreteDomain
     template <class...>
     friend class SparseDiscreteDomain;
 
+    static_assert(
+            type_seq_is_unique_v<detail::TypeSeq<DDims...>>,
+            "The dimensions of a SparseDiscreteDomain must be unique");
+
 public:
     using discrete_element_type = DiscreteElement<DDims...>;
 

include/ddc/strided_discrete_domain.hpp

@@ -71,6 +71,10 @@ class StridedDiscreteDomain
     template <class...>
     friend class StridedDiscreteDomain;
 
+    static_assert(
+            type_seq_is_unique_v<detail::TypeSeq<DDims...>>,
+            "The dimensions of a StridedDiscreteDomain must be unique");
+
 public:
     using discrete_element_type = DiscreteElement<DDims...>;
 

tests/type_seq.cpp

@@ -93,3 +93,19 @@ TEST(TypeSeqTest, Replace)
     using ExpectedR = ddc::detail::TypeSeq<a, y, c, z, e>;
     EXPECT_TRUE((ddc::type_seq_same_v<R, ExpectedR>));
 }
+
+TEST(TypeSeqTest, IsUnique)
+{
+    using A = ddc::detail::TypeSeq<a, b, c, d, e>;
+    using B = ddc::detail::TypeSeq<>;
+    using C = ddc::detail::TypeSeq<y>;
+    using D = ddc::detail::TypeSeq<y, y>;
+    using E = ddc::detail::TypeSeq<a, b, c, d, b, e>;
+    using F = ddc::detail::TypeSeq<a, b, a, c, b, a, d, b, e, a>;
+    EXPECT_TRUE((ddc::type_seq_is_unique_v<A>));
+    EXPECT_TRUE((ddc::type_seq_is_unique_v<B>));
+    EXPECT_TRUE((ddc::type_seq_is_unique_v<C>));
+    EXPECT_FALSE((ddc::type_seq_is_unique_v<D>));
+    EXPECT_FALSE((ddc::type_seq_is_unique_v<E>));
+    EXPECT_FALSE((ddc::type_seq_is_unique_v<F>));
+}