/rust/registry/src/index.crates.io-1949cf8c6b5b557f/revision-0.14.0/src/implementations/tuple.rs

Source
use super::super::Error;
use super::super::{DeserializeRevisioned, Revisioned, SerializeRevisioned};

macro_rules! impl_tuple {
  ($($n:ident),*$(,)?) => {
    impl_tuple!{@marker $($n,)*}
  };

  ($($n:ident,)* @marker $head:ident, $($tail:ident,)*) => {
    impl<$($n),*> SerializeRevisioned for ($($n,)*)
      where $($n: SerializeRevisioned),*
    {
      #[inline]
      #[allow(non_snake_case)]
      fn serialize_revisioned<W: std::io::Write>(&self, _writer: &mut W) -> Result<(), Error> {
        let ($(ref $n,)*) = *self;
        $(
          $n.serialize_revisioned(_writer)?;
        )*
        Ok(())
      }
    }

    impl<$($n),*> DeserializeRevisioned for ($($n,)*)
      where $($n: DeserializeRevisioned),*
    {
      #[inline]
      #[allow(non_snake_case)]
      fn deserialize_revisioned<R: std::io::Read>(_reader: &mut R) -> Result<Self, Error> {
        $(
          let $n = DeserializeRevisioned::deserialize_revisioned(_reader)?;
        )*
        Ok(($($n,)*))
      }
    }

    impl<$($n),*> Revisioned for ($($n,)*)
      where $($n: Revisioned),*
    {
      #[inline]
      fn revision() -> u16{
        1
      }
    }

    impl_tuple!{$($n,)* $head, @marker $($tail,)*}

  };
  ($($n:ident,)* @marker) => {
    impl<$($n),*> SerializeRevisioned for ($($n),*)
      where $($n: SerializeRevisioned),*
    {
      #[inline]
      #[allow(non_snake_case)]
      fn serialize_revisioned<W: std::io::Write>(&self, _writer: &mut W) -> Result<(), Error> {
        let ($(ref $n),*) = self;
        $(
          $n.serialize_revisioned(_writer)?;
        )*
        Ok(())
      }
    }

    impl<$($n),*> DeserializeRevisioned for ($($n),*)
      where $($n: DeserializeRevisioned),*
    {
      #[inline]
      #[allow(non_snake_case)]
      fn deserialize_revisioned<R: std::io::Read>(_reader: &mut R) -> Result<Self, Error> {
        $(
          let $n = DeserializeRevisioned::deserialize_revisioned(_reader)?;
        )*
        Ok(($($n),*))
      }
    }

    impl<$($n),*> Revisioned for ($($n),*)
      where $($n: Revisioned),*
    {
      #[inline]
      fn revision() -> u16{
        1
      }
    }
  };
}

impl_tuple! { A,B,C,D,E,F }

#[cfg(test)]
mod tests {

  use crate::implementations::assert_bincode_compat;

  use super::*;

  #[test]
  fn test_tuple_2() {
    let val = (String::from("test"), true);
    assert_bincode_compat(&val);
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 6);
    let out =
      <(String, bool) as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
        .unwrap();
    assert_eq!(val, out);
  }

  #[test]
  fn test_tuple_3() {
    let val = (String::from("test"), true, 1419247293847192847.13947134978139487);
    assert_bincode_compat(&val);
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 14);
    let out = <(String, bool, f64) as DeserializeRevisioned>::deserialize_revisioned(
      &mut mem.as_slice(),
    )
    .unwrap();
    assert_eq!(val, out);
  }

  #[test]
  fn test_tuple_4() {
    let val = (String::from("test"), true, 1419247293847192847.13947134978139487, Some('t'));
    assert_bincode_compat(&val);
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 16);
    let out =
      <(String, bool, f64, Option<char>) as DeserializeRevisioned>::deserialize_revisioned(
        &mut mem.as_slice(),
      )
      .unwrap();
    assert_eq!(val, out);
  }

  #[test]
  fn test_tuple_5() {
    let val = (
      String::from("test"),
      true,
      1419247293847192847.13947134978139487,
      Some('t'),
      vec![4u8, 19u8, 133u8],
    );
    assert_bincode_compat(&val);
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 20);
    let out =
      <(String, bool, f64, Option<char>, Vec<u8>) as DeserializeRevisioned>::deserialize_revisioned(
        &mut mem.as_slice(),
      )
      .unwrap();
    assert_eq!(val, out);
  }
}

Coverage Report

Created: 2025-11-28 06:44

Line	Count	Source
1		use super::super::Error;
2		use super::super::{DeserializeRevisioned, Revisioned, SerializeRevisioned};
3
4		macro_rules! impl_tuple {
5		($($n:ident),*$(,)?) => {
6		impl_tuple!{@marker $($n,)*}
7		};
8
9		($($n:ident,)* @marker $head:ident, $($tail:ident,)*) => {
10		impl<$($n),> SerializeRevisioned for ($($n,))
11		where $($n: SerializeRevisioned),*
12		{
13		#[inline]
14		#[allow(non_snake_case)]
15	0	fn serialize_revisioned<W: std::io::Write>(&self, _writer: &mut W) -> Result<(), Error> {
16	0	let ($(ref $n,)) = self;
17		$(
18	0	$n.serialize_revisioned(_writer)?;
19		)*
20	0	Ok(())
21	0	} Unexecuted instantiation: <(alloc::string::String, surrealdb_core::expr::kind::Kind) as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <(surrealdb_core::expr::idiom::Idiom, surrealdb_core::expr::expression::Expr) as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <(_,) as revision::SerializeRevisioned>::serialize_revisioned::<_> Unexecuted instantiation: <(_, _) as revision::SerializeRevisioned>::serialize_revisioned::<_> Unexecuted instantiation: <(_, _, _) as revision::SerializeRevisioned>::serialize_revisioned::<_> Unexecuted instantiation: <(_, _, _, _) as revision::SerializeRevisioned>::serialize_revisioned::<_> Unexecuted instantiation: <(_, _, _, _, _) as revision::SerializeRevisioned>::serialize_revisioned::<_> Unexecuted instantiation: <() as revision::SerializeRevisioned>::serialize_revisioned::<_>
22		}
23
24		impl<$($n),> DeserializeRevisioned for ($($n,))
25		where $($n: DeserializeRevisioned),*
26		{
27		#[inline]
28		#[allow(non_snake_case)]
29	0	fn deserialize_revisioned<R: std::io::Read>(_reader: &mut R) -> Result<Self, Error> {
30		$(
31	0	let $n = DeserializeRevisioned::deserialize_revisioned(_reader)?;
32		)*
33	0	Ok(($($n,)*))
34	0	} Unexecuted instantiation: <(alloc::string::String, surrealdb_core::expr::kind::Kind) as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <(surrealdb_core::expr::idiom::Idiom, surrealdb_core::expr::expression::Expr) as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <(_,) as revision::DeserializeRevisioned>::deserialize_revisioned::<_> Unexecuted instantiation: <(_, _) as revision::DeserializeRevisioned>::deserialize_revisioned::<_> Unexecuted instantiation: <(_, _, _) as revision::DeserializeRevisioned>::deserialize_revisioned::<_> Unexecuted instantiation: <(_, _, _, _) as revision::DeserializeRevisioned>::deserialize_revisioned::<_> Unexecuted instantiation: <(_, _, _, _, _) as revision::DeserializeRevisioned>::deserialize_revisioned::<_> Unexecuted instantiation: <() as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
35		}
36
37		impl<$($n),> Revisioned for ($($n,))
38		where $($n: Revisioned),*
39		{
40		#[inline]
41	0	fn revision() -> u16{
42	0	1
43	0	} Unexecuted instantiation: <(_,) as revision::Revisioned>::revision Unexecuted instantiation: <(_, _) as revision::Revisioned>::revision Unexecuted instantiation: <(_, _, _) as revision::Revisioned>::revision Unexecuted instantiation: <(_, _, _, _) as revision::Revisioned>::revision Unexecuted instantiation: <(_, _, _, _, _) as revision::Revisioned>::revision Unexecuted instantiation: <() as revision::Revisioned>::revision
44		}
45
46		impl_tuple!{$($n,)* $head, @marker $($tail,)*}
47
48		};
49		($($n:ident,)* @marker) => {
50		impl<$($n),> SerializeRevisioned for ($($n),)
51		where $($n: SerializeRevisioned),*
52		{
53		#[inline]
54		#[allow(non_snake_case)]
55	0	fn serialize_revisioned<W: std::io::Write>(&self, _writer: &mut W) -> Result<(), Error> {
56	0	let ($(ref $n),*) = self;
57		$(
58	0	$n.serialize_revisioned(_writer)?;
59		)*
60	0	Ok(())
61	0	}
62		}
63
64		impl<$($n),> DeserializeRevisioned for ($($n),)
65		where $($n: DeserializeRevisioned),*
66		{
67		#[inline]
68		#[allow(non_snake_case)]
69	0	fn deserialize_revisioned<R: std::io::Read>(_reader: &mut R) -> Result<Self, Error> {
70		$(
71	0	let $n = DeserializeRevisioned::deserialize_revisioned(_reader)?;
72		)*
73	0	Ok(($($n),*))
74	0	}
75		}
76
77		impl<$($n),> Revisioned for ($($n),)
78		where $($n: Revisioned),*
79		{
80		#[inline]
81	0	fn revision() -> u16{
82	0	1
83	0	}
84		}
85		};
86		}
87
88		impl_tuple! { A,B,C,D,E,F }
89
90		#[cfg(test)]
91		mod tests {
92
93		use crate::implementations::assert_bincode_compat;
94
95		use super::*;
96
97		#[test]
98		fn test_tuple_2() {
99		let val = (String::from("test"), true);
100		assert_bincode_compat(&val);
101		let mut mem: Vec<u8> = vec![];
102		val.serialize_revisioned(&mut mem).unwrap();
103		assert_eq!(mem.len(), 6);
104		let out =
105		<(String, bool) as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
106		.unwrap();
107		assert_eq!(val, out);
108		}
109
110		#[test]
111		fn test_tuple_3() {
112		let val = (String::from("test"), true, 1419247293847192847.13947134978139487);
113		assert_bincode_compat(&val);
114		let mut mem: Vec<u8> = vec![];
115		val.serialize_revisioned(&mut mem).unwrap();
116		assert_eq!(mem.len(), 14);
117		let out = <(String, bool, f64) as DeserializeRevisioned>::deserialize_revisioned(
118		&mut mem.as_slice(),
119		)
120		.unwrap();
121		assert_eq!(val, out);
122		}
123
124		#[test]
125		fn test_tuple_4() {
126		let val = (String::from("test"), true, 1419247293847192847.13947134978139487, Some('t'));
127		assert_bincode_compat(&val);
128		let mut mem: Vec<u8> = vec![];
129		val.serialize_revisioned(&mut mem).unwrap();
130		assert_eq!(mem.len(), 16);
131		let out =
132		<(String, bool, f64, Option<char>) as DeserializeRevisioned>::deserialize_revisioned(
133		&mut mem.as_slice(),
134		)
135		.unwrap();
136		assert_eq!(val, out);
137		}
138
139		#[test]
140		fn test_tuple_5() {
141		let val = (
142		String::from("test"),
143		true,
144		1419247293847192847.13947134978139487,
145		Some('t'),
146		vec![4u8, 19u8, 133u8],
147		);
148		assert_bincode_compat(&val);
149		let mut mem: Vec<u8> = vec![];
150		val.serialize_revisioned(&mut mem).unwrap();
151		assert_eq!(mem.len(), 20);
152		let out =
153		<(String, bool, f64, Option<char>, Vec<u8>) as DeserializeRevisioned>::deserialize_revisioned(
154		&mut mem.as_slice(),
155		)
156		.unwrap();
157		assert_eq!(val, out);
158		}
159		}