Serialize19 use indexed tuple access

* allow serialize tuples with multiples of same type

src/serialize19.lib/serialize19/serialize.Tuple.h

@@ -5,8 +5,11 @@
 namespace serialize19 {
 
 template<Archive A, class... Ts> void serialize(A& a, tuple19::Tuple<Ts...>& tuple) {
+    using meta19::nullptr_to;
     using meta19::type;
-    (serialize(a, tuple.amendOf(type<Ts>)), ...);
+    [&]<size_t... Is>(std::index_sequence<Is...>*) {
+        (serialize(a, tuple.template amendAt<Is>()), ...);
+    }(nullptr_to<std::make_index_sequence<sizeof...(Ts)>>);
 }
 
 } // namespace serialize19

src/serialize19.lib/serialize19/serialize.Tuple.test.cpp

@@ -21,3 +21,16 @@ TEST(serialize, Tuple) {
 
     EXPECT_EQ(output, input);
 }
+
+TEST(serialize, Tuple_ints) {
+    using T = Tuple<int, int, int>;
+    auto input = T{23, 42, 13};
+
+    auto buffer = dynamicWrite(input);
+
+    auto reader = ReadArchive{buffer.slice()};
+    auto output = T{};
+    serialize(reader, output);
+
+    EXPECT_EQ(output, input);
+}

src/serialize19.lib/serialize19/serialize.std_tuple.h

@@ -1,12 +1,17 @@
 #pragma once
 #include "serialize.h"
 
+#include <meta19/Type.h>
 #include <tuple>
 
 namespace serialize19 {
 
 template<Archive A, class... Ts> void serialize(A& a, std::tuple<Ts...>& tuple) {
-    (serialize(a, std::get<Ts>(tuple)), ...);
+    using meta19::nullptr_to;
+    using meta19::type;
+    [&]<size_t... Is>(std::index_sequence<Is...>*) {
+        (serialize(a, std::get<Is>(tuple)), ...);
+    }(nullptr_to<std::make_index_sequence<sizeof...(Ts)>>);
 }
 
 } // namespace serialize19

src/serialize19.lib/serialize19/serialize.std_tuple.test.cpp

@@ -19,3 +19,16 @@ TEST(serialize, std_tuple) {
 
     EXPECT_EQ(output, input);
 }
+
+TEST(serialize, std_tuple_ints) {
+    using T = std::tuple<int, int, int>;
+    auto input = T{23, 13, 42};
+
+    auto buffer = dynamicWrite(input);
+
+    auto reader = ReadArchive{buffer.slice()};
+    auto output = T{};
+    serialize(reader, output);
+
+    EXPECT_EQ(output, input);
+}