/rust/registry/src/index.crates.io-1949cf8c6b5b557f/revision-0.28.0/src/implementations/roaring.rs

Source
#![cfg(feature = "roaring")]

use super::super::Error;
use super::super::{DeserializeRevisioned, Revisioned, SerializeRevisioned};
use roaring::{RoaringBitmap, RoaringTreemap};

impl SerializeRevisioned for RoaringTreemap {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    self.serialize_into(writer).map_err(|ref err| Error::Serialize(format!("{:?}", err)))
  }
}

impl DeserializeRevisioned for RoaringTreemap {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    Self::deserialize_from(reader).map_err(|ref err| Error::Deserialize(format!("{:?}", err)))
  }
}

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

impl SerializeRevisioned for RoaringBitmap {
  #[inline]
  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
    self.serialize_into(writer).map_err(|ref err| Error::Serialize(format!("{:?}", err)))
  }
}

impl DeserializeRevisioned for RoaringBitmap {
  #[inline]
  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
    Self::deserialize_from(reader).map_err(|ref err| Error::Deserialize(format!("{:?}", err)))
  }
}

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

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

  #[test]
  fn test_roaring_treemap() {
    let val = RoaringTreemap::new();
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 8);
    let out =
      <RoaringTreemap as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
        .unwrap();
    assert_eq!(val, out);
  }

  #[test]
  fn test_roaring_bitmap() {
    let val = RoaringBitmap::new();
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 8);
    let out =
      <RoaringBitmap as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
        .unwrap();
    assert_eq!(val, out);
  }
}

Line	Count	Source
1		#![cfg(feature = "roaring")]
2
3		use super::super::Error;
4		use super::super::{DeserializeRevisioned, Revisioned, SerializeRevisioned};
5		use roaring::{RoaringBitmap, RoaringTreemap};
6
7		impl SerializeRevisioned for RoaringTreemap {
8		#[inline]
9	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
10	0	self.serialize_into(writer).map_err(\|ref err\| Error::Serialize(format!("{:?}", err))) Unexecuted instantiation: <roaring::treemap::RoaringTreemap as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>>::{closure#0} Unexecuted instantiation: <roaring::treemap::RoaringTreemap as revision::SerializeRevisioned>::serialize_revisioned::<_>::{closure#0}
11	0	} Unexecuted instantiation: <roaring::treemap::RoaringTreemap as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>> Unexecuted instantiation: <roaring::treemap::RoaringTreemap as revision::SerializeRevisioned>::serialize_revisioned::<_>
12		}
13
14		impl DeserializeRevisioned for RoaringTreemap {
15		#[inline]
16	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
17	0	Self::deserialize_from(reader).map_err(\|ref err\| Error::Deserialize(format!("{:?}", err))) Unexecuted instantiation: <roaring::treemap::RoaringTreemap as revision::DeserializeRevisioned>::deserialize_revisioned::<revision::slice_reader::SliceReader>::{closure#0} Unexecuted instantiation: <roaring::treemap::RoaringTreemap as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]>::{closure#0} Unexecuted instantiation: <roaring::treemap::RoaringTreemap as revision::DeserializeRevisioned>::deserialize_revisioned::<_>::{closure#0}
18	0	} Unexecuted instantiation: <roaring::treemap::RoaringTreemap as revision::DeserializeRevisioned>::deserialize_revisioned::<revision::slice_reader::SliceReader> Unexecuted instantiation: <roaring::treemap::RoaringTreemap as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]> Unexecuted instantiation: <roaring::treemap::RoaringTreemap as revision::DeserializeRevisioned>::deserialize_revisioned::<_>
19		}
20
21		impl Revisioned for RoaringTreemap {
22		#[inline]
23	0	fn revision() -> u16 {
24	0	1
25	0	}
26		}
27
28		impl SerializeRevisioned for RoaringBitmap {
29		#[inline]
30	0	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
31	0	self.serialize_into(writer).map_err(\|ref err\| Error::Serialize(format!("{:?}", err)))
32	0	}
33		}
34
35		impl DeserializeRevisioned for RoaringBitmap {
36		#[inline]
37	0	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
38	0	Self::deserialize_from(reader).map_err(\|ref err\| Error::Deserialize(format!("{:?}", err)))
39	0	}
40		}
41
42		impl Revisioned for RoaringBitmap {
43		#[inline]
44	0	fn revision() -> u16 {
45	0	1
46	0	}
47		}
48
49		#[cfg(test)]
50		mod tests {
51		use super::*;
52
53		#[test]
54		fn test_roaring_treemap() {
55		let val = RoaringTreemap::new();
56		let mut mem: Vec<u8> = vec![];
57		val.serialize_revisioned(&mut mem).unwrap();
58		assert_eq!(mem.len(), 8);
59		let out =
60		<RoaringTreemap as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
61		.unwrap();
62		assert_eq!(val, out);
63		}
64
65		#[test]
66		fn test_roaring_bitmap() {
67		let val = RoaringBitmap::new();
68		let mut mem: Vec<u8> = vec![];
69		val.serialize_revisioned(&mut mem).unwrap();
70		assert_eq!(mem.len(), 8);
71		let out =
72		<RoaringBitmap as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())
73		.unwrap();
74		assert_eq!(val, out);
75		}
76		}

Coverage Report

Created: 2026-06-30 07:02