/rust/registry/src/index.crates.io-1949cf8c6b5b557f/revision-0.17.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 ($($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();
    #[cfg(not(feature = "fixed-width-encoding"))]
    assert_eq!(mem.len(), 6);
    #[cfg(feature = "fixed-width-encoding")]
    assert_eq!(mem.len(), 13);
    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();
    #[cfg(not(feature = "fixed-width-encoding"))]
    assert_eq!(mem.len(), 14);
    #[cfg(feature = "fixed-width-encoding")]
    assert_eq!(mem.len(), 21);
    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();
    #[cfg(not(feature = "fixed-width-encoding"))]
    assert_eq!(mem.len(), 16);
    #[cfg(feature = "fixed-width-encoding")]
    assert_eq!(mem.len(), 23);
    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();
    #[cfg(not(feature = "fixed-width-encoding"))]
    assert_eq!(mem.len(), 20);
    #[cfg(feature = "fixed-width-encoding")]
    assert_eq!(mem.len(), 34);
    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: 2026-03-11 07:34

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: <(surrealdb_core::idx::trees::vector::SerializedVector, surrealdb_core::idx::trees::hnsw::docs::ElementDocs) 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: <(alloc::string::String, surrealdb_core::expr::kind::Kind) 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: <(surrealdb_core::idx::trees::vector::SerializedVector, surrealdb_core::idx::trees::hnsw::docs::ElementDocs) 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: <(alloc::string::String, surrealdb_core::expr::kind::Kind) 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 ($($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		#[cfg(not(feature = "fixed-width-encoding"))]
104		assert_eq!(mem.len(), 6);
105		#[cfg(feature = "fixed-width-encoding")]
106		assert_eq!(mem.len(), 13);
107		let out =
108		<(String, bool) as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
109		.unwrap();
110		assert_eq!(val, out);
111		}
112
113		#[test]
114		fn test_tuple_3() {
115		let val = (String::from("test"), true, 1419247293847192847.13947134978139487);
116		assert_bincode_compat(&val);
117		let mut mem: Vec<u8> = vec![];
118		val.serialize_revisioned(&mut mem).unwrap();
119		#[cfg(not(feature = "fixed-width-encoding"))]
120		assert_eq!(mem.len(), 14);
121		#[cfg(feature = "fixed-width-encoding")]
122		assert_eq!(mem.len(), 21);
123		let out = <(String, bool, f64) as DeserializeRevisioned>::deserialize_revisioned(
124		&mut mem.as_slice(),
125		)
126		.unwrap();
127		assert_eq!(val, out);
128		}
129
130		#[test]
131		fn test_tuple_4() {
132		let val = (String::from("test"), true, 1419247293847192847.13947134978139487, Some('t'));
133		assert_bincode_compat(&val);
134		let mut mem: Vec<u8> = vec![];
135		val.serialize_revisioned(&mut mem).unwrap();
136		#[cfg(not(feature = "fixed-width-encoding"))]
137		assert_eq!(mem.len(), 16);
138		#[cfg(feature = "fixed-width-encoding")]
139		assert_eq!(mem.len(), 23);
140		let out =
141		<(String, bool, f64, Option<char>) as DeserializeRevisioned>::deserialize_revisioned(
142		&mut mem.as_slice(),
143		)
144		.unwrap();
145		assert_eq!(val, out);
146		}
147
148		#[test]
149		fn test_tuple_5() {
150		let val = (
151		String::from("test"),
152		true,
153		1419247293847192847.13947134978139487,
154		Some('t'),
155		vec![4u8, 19u8, 133u8],
156		);
157		assert_bincode_compat(&val);
158		let mut mem: Vec<u8> = vec![];
159		val.serialize_revisioned(&mut mem).unwrap();
160		#[cfg(not(feature = "fixed-width-encoding"))]
161		assert_eq!(mem.len(), 20);
162		#[cfg(feature = "fixed-width-encoding")]
163		assert_eq!(mem.len(), 34);
164		let out =
165		<(String, bool, f64, Option<char>, Vec<u8>) as DeserializeRevisioned>::deserialize_revisioned(
166		&mut mem.as_slice(),
167		)
168		.unwrap();
169		assert_eq!(val, out);
170		}
171		}