From 19fed15463a7c6f0cdfced41eeece8062352c6e4 Mon Sep 17 00:00:00 2001
From: Victor Koenders <gpg@trangar.com>
Date: Thu, 14 Oct 2021 20:33:03 +0200
Subject: [PATCH] Added support for tuples with up to 8 values

---
 src/de/impl_tuples.rs  | 141 +++++++++++++++++++++++++++++++++++++++++
 src/de/mod.rs          |   1 +
 src/enc/impl_tuples.rs | 138 ++++++++++++++++++++++++++++++++++++++++
 src/enc/mod.rs         |   1 +
 tests/basic_types.rs   |  13 ++++
 5 files changed, 294 insertions(+)
 create mode 100644 src/de/impl_tuples.rs
 create mode 100644 src/enc/impl_tuples.rs

diff --git a/src/de/impl_tuples.rs b/src/de/impl_tuples.rs
new file mode 100644
index 0000000..a384a2f
--- /dev/null
+++ b/src/de/impl_tuples.rs
@@ -0,0 +1,141 @@
+use super::{Decodable, Decode};
+use crate::error::DecodeError;
+
+impl<A> Decodable for (A,)
+where
+    A: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((A::decode(&mut decoder)?,))
+    }
+}
+
+impl<A, B> Decodable for (A, B)
+where
+    A: Decodable,
+    B: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((A::decode(&mut decoder)?, B::decode(&mut decoder)?))
+    }
+}
+
+impl<A, B, C> Decodable for (A, B, C)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+        ))
+    }
+}
+
+impl<A, B, C, D> Decodable for (A, B, C, D)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+    D: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+            D::decode(&mut decoder)?,
+        ))
+    }
+}
+
+impl<A, B, C, D, E> Decodable for (A, B, C, D, E)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+    D: Decodable,
+    E: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+            D::decode(&mut decoder)?,
+            E::decode(&mut decoder)?,
+        ))
+    }
+}
+
+impl<A, B, C, D, E, F> Decodable for (A, B, C, D, E, F)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+    D: Decodable,
+    E: Decodable,
+    F: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+            D::decode(&mut decoder)?,
+            E::decode(&mut decoder)?,
+            F::decode(&mut decoder)?,
+        ))
+    }
+}
+
+impl<A, B, C, D, E, F, G> Decodable for (A, B, C, D, E, F, G)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+    D: Decodable,
+    E: Decodable,
+    F: Decodable,
+    G: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+            D::decode(&mut decoder)?,
+            E::decode(&mut decoder)?,
+            F::decode(&mut decoder)?,
+            G::decode(&mut decoder)?,
+        ))
+    }
+}
+
+impl<A, B, C, D, E, F, G, H> Decodable for (A, B, C, D, E, F, G, H)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+    D: Decodable,
+    E: Decodable,
+    F: Decodable,
+    G: Decodable,
+    H: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+            D::decode(&mut decoder)?,
+            E::decode(&mut decoder)?,
+            F::decode(&mut decoder)?,
+            G::decode(&mut decoder)?,
+            H::decode(&mut decoder)?,
+        ))
+    }
+}
diff --git a/src/de/mod.rs b/src/de/mod.rs
index 49407e4..199f559 100644
--- a/src/de/mod.rs
+++ b/src/de/mod.rs
@@ -3,6 +3,7 @@
 use crate::error::DecodeError;
 
 mod decoder;
+mod impl_tuples;
 mod impls;
 
 pub mod read;
diff --git a/src/enc/impl_tuples.rs b/src/enc/impl_tuples.rs
new file mode 100644
index 0000000..b9cdb64
--- /dev/null
+++ b/src/enc/impl_tuples.rs
@@ -0,0 +1,138 @@
+use super::{Encode, Encodeable};
+use crate::error::EncodeError;
+
+impl<A> Encodeable for (A,)
+where
+    A: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B> Encodeable for (A, B)
+where
+    A: Encodeable,
+    B: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C> Encodeable for (A, B, C)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C, D> Encodeable for (A, B, C, D)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+    D: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        self.3.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C, D, E> Encodeable for (A, B, C, D, E)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+    D: Encodeable,
+    E: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        self.3.encode(&mut encoder)?;
+        self.4.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C, D, E, F> Encodeable for (A, B, C, D, E, F)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+    D: Encodeable,
+    E: Encodeable,
+    F: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        self.3.encode(&mut encoder)?;
+        self.4.encode(&mut encoder)?;
+        self.5.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C, D, E, F, G> Encodeable for (A, B, C, D, E, F, G)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+    D: Encodeable,
+    E: Encodeable,
+    F: Encodeable,
+    G: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        self.3.encode(&mut encoder)?;
+        self.4.encode(&mut encoder)?;
+        self.5.encode(&mut encoder)?;
+        self.6.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C, D, E, F, G, H> Encodeable for (A, B, C, D, E, F, G, H)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+    D: Encodeable,
+    E: Encodeable,
+    F: Encodeable,
+    G: Encodeable,
+    H: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        self.3.encode(&mut encoder)?;
+        self.4.encode(&mut encoder)?;
+        self.5.encode(&mut encoder)?;
+        self.6.encode(&mut encoder)?;
+        self.7.encode(&mut encoder)?;
+        Ok(())
+    }
+}
diff --git a/src/enc/mod.rs b/src/enc/mod.rs
index f4d76a8..be3dd27 100644
--- a/src/enc/mod.rs
+++ b/src/enc/mod.rs
@@ -1,6 +1,7 @@
 //! Encoder-based structs and traits.
 
 mod encoder;
+mod impl_tuples;
 mod impls;
 
 use crate::error::EncodeError;
diff --git a/tests/basic_types.rs b/tests/basic_types.rs
index 7b270a6..d7a48a4 100644
--- a/tests/basic_types.rs
+++ b/tests/basic_types.rs
@@ -58,6 +58,7 @@ where
 
 #[test]
 fn test_numbers() {
+    // integer types
     the_same(5u8);
     the_same(5u16);
     the_same(5u32);
@@ -75,13 +76,25 @@ fn test_numbers() {
     the_same(5.0f32);
     the_same(5.0f64);
 
+    // bool
     the_same(true);
     the_same(false);
 
+    // utf8 characters
     for char in "aÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö文".chars()
     {
         the_same(char);
     }
+
+    // tuples, up to 8
+    the_same((1u8,));
+    the_same((1u8, 2u8));
+    the_same((1u8, 2u8, 3u8));
+    the_same((1u8, 2u8, 3u8, 4u8));
+    the_same((1u8, 2u8, 3u8, 4u8, 5u8));
+    the_same((1u8, 2u8, 3u8, 4u8, 5u8, 6u8));
+    the_same((1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8));
+    the_same((1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8));
 }
 
 #[test]