/rust/registry/src/index.crates.io-1949cf8c6b5b557f/revision-0.10.0/src/implementations/vecs.rs

Source
use super::super::Error;
use super::super::Revisioned;

pub(crate) fn serialize_slice<T, W>(v: &[T], writer: &mut W) -> Result<(), Error>
where
  W: std::io::Write,
  T: Revisioned,
{
  v.len().serialize_revisioned(writer)?;
  for v in v {
    v.serialize_revisioned(writer)?;
  }
  Ok(())
}

impl<T> Revisioned for Vec<T>
where
  T: Revisioned,
{
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    serialize_slice(self.as_slice(), writer)
  }

  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    let len = usize::deserialize_revisioned(reader)?;
    let mut vec = Vec::with_capacity(len);
    for _ in 0..len {
      let v: T = T::deserialize_revisioned(reader)?;
      vec.push(v);
    }
    Ok(vec)
  }

  fn revision() -> u16 {
    1
  }
}

#[cfg(test)]
mod tests {

  use super::Revisioned;

  #[test]
  fn test_vec() {
    let val: Vec<String> =
      vec![String::from("this"), String::from("is"), String::from("a"), String::from("test")];
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 16);
    let out = <Vec<String> as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
    assert_eq!(val, out);
  }
}

Line	Count	Source
1		use super::super::Error;
2		use super::super::Revisioned;
3
4	0	pub(crate) fn serialize_slice<T, W>(v: &[T], writer: &mut W) -> Result<(), Error>
5	0	where
6	0	W: std::io::Write,
7	0	T: Revisioned,
8		{
9	0	v.len().serialize_revisioned(writer)?;
10	0	for v in v {
11	0	v.serialize_revisioned(writer)?;
12		}
13	0	Ok(())
14	0	} Unexecuted instantiation: revision::implementations::vecs::serialize_slice::<surrealkv::manifest::ManifestChangeType, alloc::vec::Vec<u8>> Unexecuted instantiation: revision::implementations::vecs::serialize_slice::<u8, alloc::vec::Vec<u8>> Unexecuted instantiation: revision::implementations::vecs::serialize_slice::<_, _>
15
16		impl<T> Revisioned for Vec<T>
17		where
18		T: Revisioned,
19		{
20		#[inline]
21	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
22	0	serialize_slice(self.as_slice(), writer)
23	0	} Unexecuted instantiation: <alloc::vec::Vec<surrealkv::manifest::ManifestChangeType> as revision::Revisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <alloc::vec::Vec<_> as revision::Revisioned>::serialize_revisioned::<_>
24
25		#[inline]
26	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
27	0	let len = usize::deserialize_revisioned(reader)?;
28	0	let mut vec = Vec::with_capacity(len);
29	0	for _ in 0..len {
30	0	let v: T = T::deserialize_revisioned(reader)?;
31	0	vec.push(v);
32		}
33	0	Ok(vec)
34	0	} Unexecuted instantiation: <alloc::vec::Vec<surrealkv::manifest::ManifestChangeType> as revision::Revisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <alloc::vec::Vec<u8> as revision::Revisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <alloc::vec::Vec<_> as revision::Revisioned>::deserialize_revisioned::<_>
35
36	0	fn revision() -> u16 {
37	0	1
38	0	}
39		}
40
41		#[cfg(test)]
42		mod tests {
43
44		use super::Revisioned;
45
46		#[test]
47		fn test_vec() {
48		let val: Vec<String> =
49		vec![String::from("this"), String::from("is"), String::from("a"), String::from("test")];
50		let mut mem: Vec<u8> = vec![];
51		val.serialize_revisioned(&mut mem).unwrap();
52		assert_eq!(mem.len(), 16);
53		let out = <Vec<String> as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
54		assert_eq!(val, out);
55		}
56		}

Coverage Report

Created: 2025-10-10 07:11