/rust/registry/src/index.crates.io-1949cf8c6b5b557f/revision-0.17.0/src/implementations/arc.rs

Source
use crate::DeserializeRevisioned;
use crate::SerializeRevisioned;

use super::super::Error;
use super::super::Revisioned;
use std::sync::Arc;

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

impl<T> DeserializeRevisioned for Arc<T>
where
  T: DeserializeRevisioned,
{
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    Ok(Arc::new(T::deserialize_revisioned(reader)?))
  }
}

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

// Specialized implementations for Arc<str>
impl SerializeRevisioned for Arc<str> {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    self.as_ref().serialize_revisioned(writer)
  }
}

impl DeserializeRevisioned for Arc<str> {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    String::deserialize_revisioned(reader).map(Arc::from)
  }
}

impl Revisioned for Arc<str> {
  #[inline]
  fn revision() -> u16 {
    1
  }
}

#[cfg(test)]
mod tests {

  use super::*;

  #[test]
  fn test_arc() {
    let val = Arc::new(u32::MAX);
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    #[cfg(not(feature = "fixed-width-encoding"))]
    assert_eq!(mem.len(), 5);
    #[cfg(feature = "fixed-width-encoding")]
    assert_eq!(mem.len(), 4);
    let out = DeserializeRevisioned::deserialize_revisioned(&mut mem.as_slice()).unwrap();
    assert_eq!(val, out);
  }

  #[test]
  fn test_arc_str() {
    let val: Arc<str> = Arc::from("hello world");
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    #[cfg(not(feature = "fixed-width-encoding"))]
    assert_eq!(mem.len(), 12); // 11 chars + 1 byte for length encoding
    #[cfg(feature = "fixed-width-encoding")]
    assert_eq!(mem.len(), 19); // 11 chars + 8 bytes for length encoding
    let out: Arc<str> =
      <Arc<str> as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
        .unwrap();
    assert_eq!(val, out);
  }
}

Line	Count	Source
1		use crate::DeserializeRevisioned;
2		use crate::SerializeRevisioned;
3
4		use super::super::Error;
5		use super::super::Revisioned;
6		use std::sync::Arc;
7
8		impl<T> SerializeRevisioned for Arc<T>
9		where
10		T: SerializeRevisioned,
11		{
12		#[inline]
13	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
14	0	self.as_ref().serialize_revisioned(writer)
15	0	} Unexecuted instantiation: <alloc::sync::Arc<surrealdb_core::val::Value> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <alloc::sync::Arc<surrealdb_core::iam::auth::Auth> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <alloc::sync::Arc<surrealdb_core::val::record_id::RecordIdKey> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <alloc::sync::Arc<surrealdb_core::val::record_id::RecordId> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <alloc::sync::Arc<surrealdb_core::catalog::record::Record> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <alloc::sync::Arc<_> as revision::SerializeRevisioned>::serialize_revisioned::<_>
16		}
17
18		impl<T> DeserializeRevisioned for Arc<T>
19		where
20		T: DeserializeRevisioned,
21		{
22		#[inline]
23	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
24	0	Ok(Arc::new(T::deserialize_revisioned(reader)?))
25	0	} Unexecuted instantiation: <alloc::sync::Arc<surrealdb_core::val::record_id::RecordIdKey> as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <alloc::sync::Arc<_> as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
26		}
27
28		impl<T> Revisioned for Arc<T>
29		where
30		T: Revisioned,
31		{
32		#[inline]
33	0	fn revision() -> u16 {
34	0	1
35	0	}
36		}
37
38		// Specialized implementations for Arc<str>
39		impl SerializeRevisioned for Arc<str> {
40		#[inline]
41	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
42	0	self.as_ref().serialize_revisioned(writer)
43	0	} Unexecuted instantiation: <alloc::sync::Arc<str> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <alloc::sync::Arc<str> as revision::SerializeRevisioned>::serialize_revisioned::<_>
44		}
45
46		impl DeserializeRevisioned for Arc<str> {
47		#[inline]
48	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
49	0	String::deserialize_revisioned(reader).map(Arc::from)
50	0	}
51		}
52
53		impl Revisioned for Arc<str> {
54		#[inline]
55	0	fn revision() -> u16 {
56	0	1
57	0	}
58		}
59
60		#[cfg(test)]
61		mod tests {
62
63		use super::*;
64
65		#[test]
66		fn test_arc() {
67		let val = Arc::new(u32::MAX);
68		let mut mem: Vec<u8> = vec![];
69		val.serialize_revisioned(&mut mem).unwrap();
70		#[cfg(not(feature = "fixed-width-encoding"))]
71		assert_eq!(mem.len(), 5);
72		#[cfg(feature = "fixed-width-encoding")]
73		assert_eq!(mem.len(), 4);
74		let out = DeserializeRevisioned::deserialize_revisioned(&mut mem.as_slice()).unwrap();
75		assert_eq!(val, out);
76		}
77
78		#[test]
79		fn test_arc_str() {
80		let val: Arc<str> = Arc::from("hello world");
81		let mut mem: Vec<u8> = vec![];
82		val.serialize_revisioned(&mut mem).unwrap();
83		#[cfg(not(feature = "fixed-width-encoding"))]
84		assert_eq!(mem.len(), 12); // 11 chars + 1 byte for length encoding
85		#[cfg(feature = "fixed-width-encoding")]
86		assert_eq!(mem.len(), 19); // 11 chars + 8 bytes for length encoding
87		let out: Arc<str> =
88		<Arc<str> as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
89		.unwrap();
90		assert_eq!(val, out);
91		}
92		}

Coverage Report

Created: 2026-03-11 07:34