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

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

use super::super::Error;
use super::super::Revisioned;
use std::ops::Bound;

impl<T: SerializeRevisioned> SerializeRevisioned for Bound<T> {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    match *self {
      Bound::Unbounded => 0u32.serialize_revisioned(writer),
      Bound::Included(ref value) => {
        1u32.serialize_revisioned(writer)?;
        value.serialize_revisioned(writer)
      }
      Bound::Excluded(ref value) => {
        2u32.serialize_revisioned(writer)?;
        value.serialize_revisioned(writer)
      }
    }
  }
}

impl<T: DeserializeRevisioned> DeserializeRevisioned for Bound<T> {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    let variant = u32::deserialize_revisioned(reader)?;
    match variant {
      0 => Ok(Bound::Unbounded),
      1 => Ok(Bound::Included(
        T::deserialize_revisioned(reader)
          .map_err(|ref err| Error::Deserialize(format!("{:?}", err)))?,
      )),
      2 => Ok(Bound::Excluded(
        T::deserialize_revisioned(reader)
          .map_err(|ref err| Error::Deserialize(format!("{:?}", err)))?,
      )),
      _ => Err(Error::Deserialize("Unknown variant index".to_string())),
    }
  }
}

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

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn test_bound_unbounded() {
    let val: Bound<String> = Bound::Unbounded;
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    #[cfg(not(feature = "fixed-width-encoding"))]
    assert_eq!(mem.len(), 1);
    #[cfg(feature = "fixed-width-encoding")]
    assert_eq!(mem.len(), 4);
    let out =
      <Bound<String> as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
        .unwrap();
    assert_eq!(val, out);
  }

  #[test]
  fn test_bound_excluded() {
    let val: Bound<String> = Bound::Excluded(String::from("this is a test"));
    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(), 26);
    let out =
      <Bound<String> as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
        .unwrap();
    assert_eq!(val, out);
  }

  #[test]
  fn test_bound_included() {
    let val: Bound<String> = Bound::Included(String::from("this is a test"));
    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(), 26);
    let out =
      <Bound<String> 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::ops::Bound;
7
8		impl<T: SerializeRevisioned> SerializeRevisioned for Bound<T> {
9		#[inline]
10	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
11	0	match *self {
12	0	Bound::Unbounded => 0u32.serialize_revisioned(writer),
13	0	Bound::Included(ref value) => {
14	0	1u32.serialize_revisioned(writer)?;
15	0	value.serialize_revisioned(writer)
16		}
17	0	Bound::Excluded(ref value) => {
18	0	2u32.serialize_revisioned(writer)?;
19	0	value.serialize_revisioned(writer)
20		}
21		}
22	0	} Unexecuted instantiation: <core::ops::range::Bound<surrealdb_core::val::Value> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <core::ops::range::Bound<surrealdb_core::val::record_id::RecordIdKey> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <core::ops::range::Bound<_> as revision::SerializeRevisioned>::serialize_revisioned::<_>
23		}
24
25		impl<T: DeserializeRevisioned> DeserializeRevisioned for Bound<T> {
26		#[inline]
27	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
28	0	let variant = u32::deserialize_revisioned(reader)?;
29	0	match variant {
30	0	0 => Ok(Bound::Unbounded),
31		1 => Ok(Bound::Included(
32	0	T::deserialize_revisioned(reader)
33	0	.map_err(\|ref err\| Error::Deserialize(format!("{:?}", err)))?, Unexecuted instantiation: <core::ops::range::Bound<surrealdb_core::val::Value> as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]>::{closure#0} Unexecuted instantiation: <core::ops::range::Bound<surrealdb_core::val::record_id::RecordIdKey> as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]>::{closure#0} Unexecuted instantiation: <core::ops::range::Bound<_> as revision::DeserializeRevisioned>::deserialize_revisioned::<_>::{closure#0}
34		)),
35		2 => Ok(Bound::Excluded(
36	0	T::deserialize_revisioned(reader)
37	0	.map_err(\|ref err\| Error::Deserialize(format!("{:?}", err)))?, Unexecuted instantiation: <core::ops::range::Bound<surrealdb_core::val::Value> as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]>::{closure#1} Unexecuted instantiation: <core::ops::range::Bound<surrealdb_core::val::record_id::RecordIdKey> as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]>::{closure#1} Unexecuted instantiation: <core::ops::range::Bound<_> as revision::DeserializeRevisioned>::deserialize_revisioned::<_>::{closure#1}
38		)),
39	0	_ => Err(Error::Deserialize("Unknown variant index".to_string())),
40		}
41	0	} Unexecuted instantiation: <core::ops::range::Bound<surrealdb_core::val::Value> as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <core::ops::range::Bound<surrealdb_core::val::record_id::RecordIdKey> as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <core::ops::range::Bound<_> as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
42		}
43
44		impl<T: Revisioned> Revisioned for Bound<T> {
45		#[inline]
46	0	fn revision() -> u16 {
47	0	1
48	0	}
49		}
50
51		#[cfg(test)]
52		mod tests {
53		use super::*;
54
55		#[test]
56		fn test_bound_unbounded() {
57		let val: Bound<String> = Bound::Unbounded;
58		let mut mem: Vec<u8> = vec![];
59		val.serialize_revisioned(&mut mem).unwrap();
60		#[cfg(not(feature = "fixed-width-encoding"))]
61		assert_eq!(mem.len(), 1);
62		#[cfg(feature = "fixed-width-encoding")]
63		assert_eq!(mem.len(), 4);
64		let out =
65		<Bound<String> as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
66		.unwrap();
67		assert_eq!(val, out);
68		}
69
70		#[test]
71		fn test_bound_excluded() {
72		let val: Bound<String> = Bound::Excluded(String::from("this is a test"));
73		let mut mem: Vec<u8> = vec![];
74		val.serialize_revisioned(&mut mem).unwrap();
75		#[cfg(not(feature = "fixed-width-encoding"))]
76		assert_eq!(mem.len(), 16);
77		#[cfg(feature = "fixed-width-encoding")]
78		assert_eq!(mem.len(), 26);
79		let out =
80		<Bound<String> as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
81		.unwrap();
82		assert_eq!(val, out);
83		}
84
85		#[test]
86		fn test_bound_included() {
87		let val: Bound<String> = Bound::Included(String::from("this is a test"));
88		let mut mem: Vec<u8> = vec![];
89		val.serialize_revisioned(&mut mem).unwrap();
90		#[cfg(not(feature = "fixed-width-encoding"))]
91		assert_eq!(mem.len(), 16);
92		#[cfg(feature = "fixed-width-encoding")]
93		assert_eq!(mem.len(), 26);
94		let out =
95		<Bound<String> as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
96		.unwrap();
97		assert_eq!(val, out);
98		}
99		}

Coverage Report

Created: 2026-03-31 07:09