Fix tuple assignment

Author: HUD-Software

interface/core/containers/compressed_tuple.h

@@ -706,7 +706,7 @@ namespace hud
         constexpr compressed_tuple &operator=(const compressed_tuple &other) noexcept
         requires(hud::conjunction_v<hud::is_copy_assignable<types_t>...>)
         {
-            details::tuple::tuple_assign<sizeof...(types_t), compressed_tuple, compressed_tuple>()(*this, other);
+            details::tuple::tuple_assign<sizeof...(types_t)>()(*this, other);
             return *this;
         }
 
@@ -721,7 +721,7 @@ namespace hud
         requires(hud::conjunction_v<hud::is_copy_assignable<types_t, u_types_t>...>)
         constexpr compressed_tuple &operator=(const compressed_tuple<u_types_t...> &other) noexcept
         {
-            details::tuple::tuple_assign<sizeof...(types_t), compressed_tuple, compressed_tuple<u_types_t...>>()(*this, other);
+            details::tuple::tuple_assign<sizeof...(types_t)>()(*this, other);
             return *this;
         }
 
@@ -735,7 +735,7 @@ namespace hud
         constexpr compressed_tuple &operator=(compressed_tuple &&other) noexcept
         requires(hud::conjunction_v<hud::is_move_assignable<types_t>...>)
         {
-            details::tuple::tuple_assign<sizeof...(types_t), compressed_tuple, compressed_tuple>()(*this, hud::move(other));
+            details::tuple::tuple_assign<sizeof...(types_t)>()(*this, hud::move(other));
             return *this;
         }
 
@@ -750,7 +750,7 @@ namespace hud
         requires(hud::conjunction_v<hud::is_move_assignable<types_t, u_types_t>...>)
         constexpr compressed_tuple &operator=(compressed_tuple<u_types_t...> &&other) noexcept
         {
-            details::tuple::tuple_assign<sizeof...(types_t), compressed_tuple, compressed_tuple<u_types_t...>>()(*this, hud::move(other));
+            details::tuple::tuple_assign<sizeof...(types_t)>()(*this, hud::move(other));
             return *this;
         }
 

interface/core/containers/tuple.h

@@ -320,30 +320,25 @@ namespace hud
          * Recursively assign a tuple to another.
          * @tparam count Number of element to assign
          */
-        template<usize count, typename tuple_to_type, typename tuple_from_type>
-        struct tuple_assign;
-
-        template<usize count, typename... types_t, typename... u_types_t>
-        struct tuple_assign<count, hud::tuple<types_t...>, hud::tuple<u_types_t...>>
+        template<usize count>
+        struct tuple_assign
         {
-            using tuple_to_type = hud::tuple<types_t...>;
-            using tuple_from_type = hud::tuple<u_types_t...>;
-
             /**
              * Assign a 2 tuple elements.
              * @tparam types_t... List of types_t of the tuple to
              * @tparam u_types_t... List of types_t of the tuple from
              * @param to The assigned tuple
              * @param from The tuple to assign
              */
+            template<typename tuple_to_type, typename tuple_from_type>
             constexpr void operator()([[maybe_unused]] tuple_to_type &to, [[maybe_unused]] const tuple_from_type &from) noexcept
             {
                 static_assert(hud::tuple_size_v<tuple_to_type> == hud::tuple_size_v<tuple_from_type>, "Assigning tuples of different size is not supported");
                 if constexpr (count > 0u)
                 {
                     constexpr const usize idx = tuple_size_v<tuple_to_type> - count;
-                    hud::get<idx>(to) = hud::get<idx>(from);
-                    tuple_assign<count - 1u, tuple_to_type, tuple_from_type>()(to, from);
+                    get<idx>(to) = get<idx>(from);
+                    tuple_assign<count - 1u>()(to, from);
                 }
             }
 
@@ -354,18 +349,26 @@ namespace hud
              * @param to The assigned tuple
              * @param from The tuple to assign
              */
+            template<typename tuple_to_type, typename tuple_from_type>
             constexpr void operator()([[maybe_unused]] tuple_to_type &to, [[maybe_unused]] tuple_from_type &&from) noexcept
             {
                 static_assert(hud::tuple_size_v<tuple_to_type> == hud::tuple_size_v<tuple_from_type>, "Assigning tuples of different size is not supported");
                 if constexpr (count > 0)
                 {
                     constexpr const usize idx = tuple_size_v<tuple_to_type> - count;
-                    hud::get<idx>(to) = hud::get<idx>(hud::move(from));
-                    tuple_assign<count - 1u, tuple_to_type, tuple_from_type>()(to, hud::move(from));
+                    get<idx>(to) = get<idx>(hud::move(from));
+                    tuple_assign<count - 1u>()(to, hud::move(from));
                 }
             }
         };
 
+        // template<usize count, typename... types_t, typename... u_types_t>
+        // struct tuple_assign<count, hud::tuple<types_t...>, hud::tuple<u_types_t...>>
+        // {
+        //     using tuple_to_type = hud::tuple<types_t...>;
+        //     using tuple_from_type = hud::tuple<u_types_t...>;
+        // };
+
         /** Swap tuple1_t and tuple2_t element at the index if element is swappable. */
         template<usize type_index, typename tuple1_t, typename tuple2_t, bool = hud::is_swappable_v<hud::tuple_element_t<type_index, tuple1_t>, hud::tuple_element_t<type_index, tuple2_t>>>
         struct swap_element
@@ -815,7 +818,7 @@ namespace hud
         constexpr tuple &operator=(const tuple &other) noexcept
         requires(hud::conjunction_v<hud::is_copy_assignable<types_t>...>)
         {
-            details::tuple::tuple_assign<sizeof...(types_t), tuple, tuple>()(*this, other);
+            details::tuple::tuple_assign<sizeof...(types_t)>()(*this, other);
             return *this;
         }
 
@@ -830,7 +833,7 @@ namespace hud
         requires(hud::conjunction_v<hud::is_copy_assignable<types_t, u_types_t>...>)
         constexpr tuple &operator=(const tuple<u_types_t...> &other) noexcept
         {
-            details::tuple::tuple_assign<sizeof...(types_t), tuple, tuple<u_types_t...>>()(*this, other);
+            details::tuple::tuple_assign<sizeof...(types_t)>()(*this, other);
             return *this;
         }
 
@@ -844,7 +847,7 @@ namespace hud
         constexpr tuple &operator=(tuple &&other) noexcept
         requires(hud::conjunction_v<hud::is_move_assignable<types_t>...>)
         {
-            details::tuple::tuple_assign<sizeof...(types_t), tuple, tuple>()(*this, hud::move(other));
+            details::tuple::tuple_assign<sizeof...(types_t)>()(*this, hud::move(other));
             return *this;
         }
 
@@ -859,7 +862,7 @@ namespace hud
         requires(hud::conjunction_v<hud::is_move_assignable<types_t, u_types_t>...>)
         constexpr tuple &operator=(tuple<u_types_t...> &&other) noexcept
         {
-            details::tuple::tuple_assign<sizeof...(types_t), tuple, tuple<u_types_t...>>()(*this, hud::move(other));
+            details::tuple::tuple_assign<sizeof...(types_t)>()(*this, hud::move(other));
             return *this;
         }
 

test/compressed_tuple/compressed_tuple_assignments.cpp

@@ -9,7 +9,7 @@ GTEST_TEST(compressed_tuple, copy_assign_trivially_copy_assignable_same_types)
         tuple_type compressed_tuple {hud::tag_init};
         const tuple_type other_tuple {12.0f, 123, L'h'};
         compressed_tuple = other_tuple;
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple) == 12.f,
             hud::get<1>(compressed_tuple) == 123,
             hud::get<2>(compressed_tuple) == L'h',
@@ -43,7 +43,7 @@ GTEST_TEST(compressed_tuple, copy_assign_trivially_copy_assignable_different_typ
         tuple_type compressed_tuple {hud::tag_init};
         const other_tuple_type other_tuple {(u16)12, (i16)123, u'h'};
         compressed_tuple = other_tuple;
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple) == 12,
             hud::get<1>(compressed_tuple) == 123,
             hud::get<2>(compressed_tuple) == L'h',
@@ -76,7 +76,7 @@ GTEST_TEST(compressed_tuple, copy_assign_non_trivially_copy_assignable_same_type
         tuple_type compressed_tuple {hud::tag_init};
         const tuple_type other_tuple {1, 12.0f, 123, L'h'};
         compressed_tuple = other_tuple;
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple).id() == 1,
             hud::get<0>(compressed_tuple).copy_constructor_count() == 0u,
             hud::get<0>(compressed_tuple).copy_assign_count() == 1u,
@@ -119,7 +119,7 @@ GTEST_TEST(compressed_tuple, copy_assign_non_trivially_copy_assignable_different
         tuple_type compressed_tuple {hud::tag_init};
         const other_tuple_type other_tuple {1, (u16)12, (i16)123, u'h'};
         compressed_tuple = other_tuple;
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple).id() == 1,
             hud::get<0>(compressed_tuple).copy_constructor_count() == 0u,
             hud::get<0>(compressed_tuple).copy_assign_count() == 1u,
@@ -161,7 +161,7 @@ GTEST_TEST(compressed_tuple, move_assign_trivially_copy_assignable_same_types)
         tuple_type compressed_tuple {hud::tag_init};
         tuple_type other_tuple {12.0f, 123, L'h'};
         compressed_tuple = hud::move(other_tuple);
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple) == 12.f,
             hud::get<1>(compressed_tuple) == 123,
             hud::get<2>(compressed_tuple) == L'h',
@@ -195,7 +195,7 @@ GTEST_TEST(compressed_tuple, move_assign_trivially_copy_assignable_different_typ
         tuple_type compressed_tuple {hud::tag_init};
         other_tuple_type other_tuple {(u16)12, (i16)123, u'h'};
         compressed_tuple = hud::move(other_tuple);
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple) == 12,
             hud::get<1>(compressed_tuple) == 123,
             hud::get<2>(compressed_tuple) == L'h',
@@ -228,7 +228,7 @@ GTEST_TEST(compressed_tuple, move_assign_non_trivially_copy_assignable_same_type
         tuple_type compressed_tuple {hud::tag_init};
         tuple_type other_tuple {1, 12.0f, 123, L'h'};
         compressed_tuple = hud::move(other_tuple);
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple).id() == 1,
             hud::get<0>(compressed_tuple).copy_constructor_count() == 0u,
             hud::get<0>(compressed_tuple).copy_assign_count() == 1u,
@@ -271,7 +271,7 @@ GTEST_TEST(compressed_tuple, move_assign_non_trivially_copy_assignable_different
         tuple_type compressed_tuple {hud::tag_init};
         other_tuple_type other_tuple {1, (u16)12, (i16)123, u'h'};
         compressed_tuple = hud::move(other_tuple);
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple).id() == 1,
             hud::get<0>(compressed_tuple).copy_constructor_count() == 0u,
             hud::get<0>(compressed_tuple).copy_assign_count() == 1u,
@@ -313,7 +313,7 @@ GTEST_TEST(compressed_tuple, move_assign_trivially_move_assignable_same_types)
         tuple_type compressed_tuple {hud::tag_init};
         tuple_type other_tuple {12.0f, 123, L'h'};
         compressed_tuple = hud::move(other_tuple);
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple) == 12.f,
             hud::get<1>(compressed_tuple) == 123,
             hud::get<2>(compressed_tuple) == L'h',
@@ -347,7 +347,7 @@ GTEST_TEST(compressed_tuple, move_assign_trivially_move_assignable_different_typ
         tuple_type compressed_tuple {hud::tag_init};
         other_tuple_type other_tuple {(u16)12, (i16)123, u'h'};
         compressed_tuple = hud::move(other_tuple);
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple) == 12,
             hud::get<1>(compressed_tuple) == 123,
             hud::get<2>(compressed_tuple) == L'h',
@@ -380,7 +380,7 @@ GTEST_TEST(compressed_tuple, move_assign_non_trivially_move_assignable_same_type
         tuple_type compressed_tuple {hud::tag_init};
         tuple_type other_tuple {1, 12.0f, 123, L'h'};
         compressed_tuple = hud::move(other_tuple);
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple).id() == 1,
             hud::get<0>(compressed_tuple).copy_constructor_count() == 0u,
             hud::get<0>(compressed_tuple).move_constructor_count() == 0u,
@@ -429,7 +429,7 @@ GTEST_TEST(compressed_tuple, move_assign_non_trivially_move_assignable_different
         tuple_type compressed_tuple {hud::tag_init};
         other_tuple_type other_tuple {1, (u16)12, (i16)123, u'h'};
         compressed_tuple = hud::move(other_tuple);
-        return std::compressed_tuple {
+        return std::tuple {
             hud::get<0>(compressed_tuple).id() == 1,
             hud::get<0>(compressed_tuple).copy_constructor_count() == 0u,
             hud::get<0>(compressed_tuple).move_constructor_count() == 0u,