From abdc44a8d960e3eeaf598de6ff6d2de61bf23926 Mon Sep 17 00:00:00 2001 From: Dirk Van Haerenborgh Date: Fri, 24 Jan 2025 19:57:18 +0100 Subject: [PATCH] add arc impl --- src/impls/arc.rs | 151 +++++++++++++++++++++++++++++++++++++++++++++++ src/impls/mod.rs | 3 + 2 files changed, 154 insertions(+) create mode 100644 src/impls/arc.rs diff --git a/src/impls/arc.rs b/src/impls/arc.rs new file mode 100644 index 00000000..d00af34a --- /dev/null +++ b/src/impls/arc.rs @@ -0,0 +1,151 @@ +use no_std_io::io::{Read, Seek, Write}; +use std::sync::Arc; + +use alloc::vec::Vec; + +use crate::ctx::Limit; +use crate::reader::Reader; +use crate::writer::Writer; +use crate::{DekuError, DekuReader, DekuWriter}; + +impl<'a, T, Ctx> DekuReader<'a, Ctx> for Arc +where + T: DekuReader<'a, Ctx>, + Ctx: Copy, +{ + fn from_reader_with_ctx( + reader: &mut Reader, + inner_ctx: Ctx, + ) -> Result { + let val = ::from_reader_with_ctx(reader, inner_ctx)?; + Ok(Arc::new(val)) + } +} + +impl<'a, T, Ctx, Predicate> DekuReader<'a, (Limit, Ctx)> for Arc<[T]> +where + T: DekuReader<'a, Ctx>, + Ctx: Copy, + Predicate: FnMut(&T) -> bool, +{ + fn from_reader_with_ctx( + reader: &mut Reader, + (limit, inner_ctx): (Limit, Ctx), + ) -> Result { + // use Vec's implementation and convert to Arc<[T]> + let val = >::from_reader_with_ctx(reader, (limit, inner_ctx))?; + Ok(Arc::from(val.into_boxed_slice())) + } +} + +impl DekuWriter for Arc<[T]> +where + T: DekuWriter, + Ctx: Copy, +{ + /// Write all `T`s to bits + fn to_writer( + &self, + writer: &mut Writer, + ctx: Ctx, + ) -> Result<(), DekuError> { + for v in self.as_ref() { + v.to_writer(writer, ctx)?; + } + Ok(()) + } +} + +impl DekuWriter for Arc +where + T: DekuWriter, + Ctx: Copy, +{ + /// Write all `T`s to bits + fn to_writer( + &self, + writer: &mut Writer, + ctx: Ctx, + ) -> Result<(), DekuError> { + self.as_ref().to_writer(writer, ctx)?; + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use no_std_io::io::Cursor; + use rstest::rstest; + + use super::*; + use crate::ctx::*; + use crate::native_endian; + use crate::reader::Reader; + #[cfg(feature = "bits")] + use bitvec::prelude::*; + + #[rstest(input, expected, + case( + &[0xEF, 0xBE], + Arc::new(native_endian!(0xBEEF_u16)), + ), + )] + fn test_boxed(input: &[u8], expected: Arc) { + let mut cursor = Cursor::new(input); + let mut reader = Reader::new(&mut cursor); + let res_read = >::from_reader_with_ctx(&mut reader, ()).unwrap(); + assert_eq!(expected, res_read); + + let mut writer = Writer::new(Cursor::new(vec![])); + res_read.to_writer(&mut writer, ()).unwrap(); + assert_eq!(input.to_vec(), writer.inner.into_inner()); + } + + // Note: Copied tests from vec.rs impl + #[cfg(feature = "bits")] + #[rstest(input, endian, bit_size, limit, expected, expected_rest_bits, expected_rest_bytes, expected_write, + case::normal_le([0xAA, 0xBB, 0xCC, 0xDD].as_ref(), Endian::Little, Some(16), 2.into(), Arc::from(vec![0xBBAA, 0xDDCC].into_boxed_slice()), bits![u8, Msb0;], &[], vec![0xAA, 0xBB, 0xCC, 0xDD]), + case::normal_be([0xAA, 0xBB, 0xCC, 0xDD].as_ref(), Endian::Big, Some(16), 2.into(), Arc::from(vec![0xAABB, 0xCCDD].into_boxed_slice()), bits![u8, Msb0;], &[], vec![0xAA, 0xBB, 0xCC, 0xDD]), + case::predicate_le([0xAA, 0xBB, 0xCC, 0xDD].as_ref(), Endian::Little, Some(16), (|v: &u16| *v == 0xBBAA).into(), Arc::from(vec![0xBBAA].into_boxed_slice()), bits![u8, Msb0;], &[0xcc, 0xdd], vec![0xAA, 0xBB]), + case::predicate_be([0xAA, 0xBB, 0xCC, 0xDD].as_ref(), Endian::Big, Some(16), (|v: &u16| *v == 0xAABB).into(), Arc::from(vec![0xAABB].into_boxed_slice()), bits![u8, Msb0;], &[0xcc, 0xdd], vec![0xAA, 0xBB]), + case::bytes_le([0xAA, 0xBB, 0xCC, 0xDD].as_ref(), Endian::Little, Some(16), BitSize(16).into(), Arc::from(vec![0xBBAA].into_boxed_slice()), bits![u8, Msb0;], &[0xcc, 0xdd], vec![0xAA, 0xBB]), + case::bytes_be([0xAA, 0xBB, 0xCC, 0xDD].as_ref(), Endian::Big, Some(16), BitSize(16).into(), Arc::from(vec![0xAABB].into_boxed_slice()), bits![u8, Msb0;], &[0xcc, 0xdd], vec![0xAA, 0xBB]), + )] + fn test_boxed_slice_from_reader_with_ctx bool>( + input: &[u8], + endian: Endian, + bit_size: Option, + limit: Limit, + expected: Arc<[u16]>, + expected_rest_bits: &bitvec::slice::BitSlice, + expected_rest_bytes: &[u8], + expected_write: Vec, + ) { + // Unwrap here because all test cases are `Some`. + let bit_size = bit_size.unwrap(); + + let mut cursor = Cursor::new(input); + let mut reader = Reader::new(&mut cursor); + let res_read = + >::from_reader_with_ctx(&mut reader, (limit, (endian, BitSize(bit_size)))) + .unwrap(); + assert_eq!(expected, res_read); + assert_eq!( + reader.rest(), + expected_rest_bits.iter().by_vals().collect::>() + ); + let mut buf = vec![]; + cursor.read_to_end(&mut buf).unwrap(); + assert_eq!(expected_rest_bytes, buf); + + assert_eq!(input[..expected_write.len()].to_vec(), expected_write); + + let mut writer = Writer::new(Cursor::new(vec![])); + res_read + .to_writer(&mut writer, (endian, BitSize(bit_size))) + .unwrap(); + assert_eq!(expected_write, writer.inner.into_inner()); + + assert_eq!(input[..expected_write.len()].to_vec(), expected_write); + } +} diff --git a/src/impls/mod.rs b/src/impls/mod.rs index 2b9b3ede..fd4a04a8 100644 --- a/src/impls/mod.rs +++ b/src/impls/mod.rs @@ -7,6 +7,9 @@ mod tuple; mod unit; mod vec; +#[cfg(feature = "std")] +mod arc; + #[cfg(feature = "std")] mod cow;