use crate::{ error::{Error, Result}, reader::{ReadAdapter, Reader, SliceAdapter}, }; use serde::de::{self, Deserialize, DeserializeOwned, DeserializeSeed, IntoDeserializer, Visitor}; use std::convert::TryFrom; use std::io::Read; use std::str; pub fn from_vec<'de, T: Deserialize<'de>>(vec: &'de Vec) -> Result { from_slice(vec.as_slice()) } pub fn read_from(read: &mut R) -> Result { let mut de = Deserializer::new(ReadAdapter::new(read)); Deserialize::deserialize(&mut de) } pub fn from_slice<'de, T: Deserialize<'de>>(slice: &'de [u8]) -> Result { let mut de = Deserializer::new(SliceAdapter::new(slice)); Deserialize::deserialize(&mut de) } fn try_from>(value: TSource) -> Result { let cast = TDest::try_from(value).map_err(|_| Error::TypeConversion)?; Ok(cast) } /// Returns the number of bytes needed to store the unicode character in UTF-8 whose /// encoding begins with the given byte. If the given byte is not valid as the first byte /// for any character, then a failed result with Error::InvalidUtf8Char is returned. fn num_bytes_for_char(first_byte: u8) -> Result { if first_byte & 128u8 == 0 { return Ok(1); } for bit in 2..5 { let mask = 128u8 >> bit; if mask & first_byte == 0 { return Ok(bit); } } Err(Error::InvalidUtf8) } /// Returns the unicode code point of the character that is encoded in UTF-8 in the given buffer /// as a u32. If the given buffer is not of a valid length then a failed result is returned. /// No other verification is performed. fn u32_from_utf8(buf: &[u8]) -> Result { const MASK: u8 = 0b0011_1111; fn mask(byte: u8, mask: u8) -> u32 { (byte & mask) as u32 } fn two_bytes(buf: &[u8]) -> u32 { mask(buf[0], 0b0001_1111) << 6 | mask(buf[1], MASK) } fn three_bytes(buf: &[u8]) -> u32 { mask(buf[0], 0b0000_1111) << 12 | mask(buf[1], MASK) << 6 | mask(buf[2], MASK) } fn four_bytes(buf: &[u8]) -> u32 { mask(buf[0], 0b0000_0111) << 18 | mask(buf[1], MASK) << 12 | mask(buf[2], MASK) << 6 | mask(buf[3], MASK) } let code_point = match buf.len() { 1 => Some(buf[0] as u32), 2 => Some(two_bytes(buf)), 3 => Some(three_bytes(buf)), 4 => Some(four_bytes(buf)), _ => None, }; code_point.ok_or(Error::InvalidUtf8) } fn char_from_utf8(buf: &[u8]) -> Result { let result = u32_from_utf8(buf); let option = char::from_u32(result?); option.ok_or(Error::InvalidUtf8) } pub struct Deserializer { input: T, } impl<'de, T: Reader<'de>> Deserializer { pub fn new(input: T) -> Self { Self { input } } fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> { self.input.read_exact(buf) } fn borrow_bytes(&mut self, len: usize) -> Result<&'de [u8]> { self.input.borrow_bytes(len) } fn read_array(&mut self) -> Result<[u8; N]> { let mut array = [0u8; N]; self.read_exact(array.as_mut_slice())?; Ok(array) } fn read_u8(&mut self) -> Result { let buf = self.read_array::<1>()?; Ok(buf[0]) } fn read_u16(&mut self) -> Result { let buf = self.read_array()?; Ok(u16::from_le_bytes(buf)) } fn read_u32(&mut self) -> Result { let buf = self.read_array()?; Ok(u32::from_le_bytes(buf)) } fn read_u64(&mut self) -> Result { let buf = self.read_array()?; Ok(u64::from_le_bytes(buf)) } fn read_u128(&mut self) -> Result { let buf = self.read_array()?; Ok(u128::from_le_bytes(buf)) } fn read_i8(&mut self) -> Result { let value = self.read_u8()?; Ok(value as i8) } fn read_i16(&mut self) -> Result { let value = self.read_u16()?; Ok(value as i16) } fn read_i32(&mut self) -> Result { let value = self.read_u32()?; Ok(value as i32) } fn read_i64(&mut self) -> Result { let value = self.read_u64()?; Ok(value as i64) } fn read_i128(&mut self) -> Result { let value = self.read_u128()?; Ok(value as i128) } fn read_bool(&mut self) -> Result { let byte = self.read_u8()?; Ok(byte > 0) } fn read_vec(&mut self) -> Result> { let len = try_from(self.read_u32()?)?; let mut vec = vec![0; len]; self.read_exact(vec.as_mut_slice())?; Ok(vec) } fn read_bytes(&mut self) -> Result<&'de [u8]> { let len = try_from(self.read_u32()?)?; self.borrow_bytes(len) } fn read_string(&mut self) -> Result { let vec = self.read_vec()?; let value = String::from_utf8(vec).map_err(|_| Error::TypeConversion)?; Ok(value) } fn read_str(&mut self) -> Result<&'de str> { let bytes = self.read_bytes()?; std::str::from_utf8(bytes).map_err(|_| Error::InvalidUtf8) } } impl<'de, 'a, T: Reader<'de>> de::Deserializer<'de> for &'a mut Deserializer { type Error = Error; fn deserialize_any>(self, _visitor: V) -> Result { Err(Error::NotSupported("deserialize_any is not supported")) } fn deserialize_bool>(self, visitor: V) -> Result { let value = self.read_bool()?; visitor.visit_bool(value) } fn deserialize_i8>(self, visitor: V) -> Result { let value = self.read_i8()?; visitor.visit_i8(value) } fn deserialize_i16>(self, visitor: V) -> Result { let value = self.read_i16()?; visitor.visit_i16(value) } fn deserialize_i32>(self, visitor: V) -> Result { let value = self.read_i32()?; visitor.visit_i32(value) } fn deserialize_i64>(self, visitor: V) -> Result { let value = self.read_i64()?; visitor.visit_i64(value) } fn deserialize_i128>(self, visitor: V) -> Result { let value = self.read_i128()?; visitor.visit_i128(value) } fn deserialize_u8>(self, visitor: V) -> Result { let value = self.read_u8()?; visitor.visit_u8(value) } fn deserialize_u16>(self, visitor: V) -> Result { let value = self.read_u16()?; visitor.visit_u16(value) } fn deserialize_u32>(self, visitor: V) -> Result { let value = self.read_u32()?; visitor.visit_u32(value) } fn deserialize_u64>(self, visitor: V) -> Result { let value = self.read_u64()?; visitor.visit_u64(value) } fn deserialize_u128>(self, visitor: V) -> Result { let value = self.read_u128()?; visitor.visit_u128(value) } fn deserialize_f32>(self, visitor: V) -> Result { let mut buf = [0u8; 4]; self.read_exact(&mut buf)?; let value = f32::from_le_bytes(buf); visitor.visit_f32(value) } fn deserialize_f64>(self, visitor: V) -> Result { let mut buf = [0u8; 8]; self.read_exact(&mut buf)?; let value = f64::from_le_bytes(buf); visitor.visit_f64(value) } fn deserialize_char>(self, visitor: V) -> Result { let byte = self.read_u8()?; let char_len = num_bytes_for_char(byte)?; let mut buf = [0u8; 4]; buf[0] = byte; self.read_exact(&mut buf[1..char_len])?; let result = char_from_utf8(&buf[..char_len]); visitor.visit_char(result?) } fn deserialize_str>(self, visitor: V) -> Result { let value = self.read_str()?; visitor.visit_borrowed_str(value) } fn deserialize_string>(self, visitor: V) -> Result { let value = self.read_string()?; visitor.visit_string(value) } fn deserialize_bytes>(self, visitor: V) -> Result { let value = self.read_bytes()?; visitor.visit_borrowed_bytes(value) } fn deserialize_byte_buf>(self, visitor: V) -> Result { let value = self.read_vec()?; visitor.visit_byte_buf(value) } fn deserialize_option>(self, visitor: V) -> Result { let some = self.read_bool()?; if some { visitor.visit_some(self) } else { visitor.visit_none() } } fn deserialize_unit>(self, visitor: V) -> Result { visitor.visit_unit() } fn deserialize_unit_struct>( self, _name: &'static str, visitor: V, ) -> Result { visitor.visit_unit() } fn deserialize_newtype_struct>( self, _name: &'static str, visitor: V, ) -> Result { visitor.visit_newtype_struct(self) } fn deserialize_seq>(self, visitor: V) -> Result { let len = self.read_u32()?; visitor.visit_seq(SeqAccess { elements_left: len, deserializer: self, }) } fn deserialize_tuple>(self, len: usize, visitor: V) -> Result { visitor.visit_seq(SeqAccess { elements_left: try_from(len)?, deserializer: self, }) } fn deserialize_tuple_struct>( self, _name: &'static str, len: usize, visitor: V, ) -> Result { self.deserialize_tuple(len, visitor) } fn deserialize_map>(self, visitor: V) -> Result { let len = self.read_u32()?; visitor.visit_map(SeqAccess { elements_left: len, deserializer: self, }) } fn deserialize_struct>( self, _name: &'static str, fields: &'static [&'static str], visitor: V, ) -> Result { self.deserialize_tuple(fields.len(), visitor) } fn deserialize_enum>( self, _name: &'static str, _variants: &'static [&'static str], visitor: V, ) -> Result { visitor.visit_enum(self) } fn deserialize_identifier>(self, _visitor: V) -> Result { Err(Error::NotSupported("Deserializer::deserialize_identifier")) } fn deserialize_ignored_any>(self, _visitor: V) -> Result { Err(Error::NotSupported("Deserializer::deserialize_ignored_any")) } fn is_human_readable(&self) -> bool { false } } struct SeqAccess<'a, T> { elements_left: u32, deserializer: &'a mut Deserializer, } impl<'a, 'de, T: Reader<'de>> de::SeqAccess<'de> for SeqAccess<'a, T> { type Error = Error; fn next_element_seed>(&mut self, seed: S) -> Result> { if 0 == self.elements_left { return Ok(None); } self.elements_left -= 1; seed.deserialize(&mut *self.deserializer).map(Some) } } impl<'a, 'de, T: Reader<'de>> de::MapAccess<'de> for SeqAccess<'a, T> { type Error = Error; fn next_key_seed>(&mut self, seed: S) -> Result> { if 0 == self.elements_left { return Ok(None); } self.elements_left -= 1; seed.deserialize(&mut *self.deserializer).map(Some) } fn next_value_seed>(&mut self, seed: U) -> Result { seed.deserialize(&mut *self.deserializer) } } impl<'de, T: Reader<'de>> de::VariantAccess<'de> for &mut Deserializer { type Error = Error; fn unit_variant(self) -> Result<()> { Ok(()) } fn newtype_variant_seed>(self, seed: S) -> Result { seed.deserialize(self) } fn tuple_variant>(self, len: usize, visitor: V) -> Result { de::Deserializer::deserialize_tuple(self, len, visitor) } fn struct_variant>( self, fields: &'static [&'static str], visitor: V, ) -> Result { de::Deserializer::deserialize_struct(self, "", fields, visitor) } } impl<'de, T: Reader<'de>> de::EnumAccess<'de> for &mut Deserializer { type Error = Error; type Variant = Self; fn variant_seed>(self, seed: S) -> Result<(S::Value, Self::Variant)> { let int = self.read_u16()?; let index: u32 = try_from(int)?; let value = seed.deserialize(index.into_deserializer())?; Ok((value, self)) } } #[cfg(test)] mod test { use crate::from_slice; use super::{from_vec, num_bytes_for_char, Result}; use serde::Deserialize; use std::collections::HashMap; #[test] fn test_num_bytes_for_char() -> Result<()> { fn test_case(c: char) -> Result<()> { let len = c.len_utf8(); let mut buf: Vec = vec![0; len]; c.encode_utf8(buf.as_mut_slice()); let result = num_bytes_for_char(buf[0]); assert_eq!(len, result?); Ok(()) } test_case('$')?; test_case('£')?; test_case('€')?; test_case('😑')?; Ok(()) } #[test] fn deserialize_false() -> Result<()> { let vec: Vec = vec![0x00]; let result = from_vec(&vec); assert_eq!(false, result?); Ok(()) } #[test] fn deserialize_true() -> Result<()> { let vec: Vec = vec![0x01]; let result = from_vec(&vec); assert_eq!(true, result?); Ok(()) } #[test] fn deserialize_i8() -> Result<()> { let vec: Vec = vec![0xFE]; let result = from_vec(&vec); assert_eq!(-2i8, result?); Ok(()) } #[test] fn deserialize_i16() -> Result<()> { let vec: Vec = vec![0xFD, 0xFF]; let result = from_vec(&vec); assert_eq!(-3i16, result?); Ok(()) } #[test] fn deserialize_i32() -> Result<()> { let vec: Vec = vec![0xFE, 0xFF, 0xFF, 0xFF]; let result = from_vec(&vec); assert_eq!(-2i32, result?); Ok(()) } #[test] fn deserialize_i64() -> Result<()> { let vec: Vec = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]; let result = from_vec(&vec); assert_eq!(-2i64, result?); Ok(()) } #[test] fn deserialize_i128() -> Result<()> { let vec: Vec = vec![ 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, ]; let result = from_vec(&vec); assert_eq!(-2i128, result?); Ok(()) } #[test] fn deserialize_u8() -> Result<()> { let vec: Vec = vec![0xFF]; let result = from_vec(&vec); assert_eq!(255u8, result?); Ok(()) } #[test] fn deserialize_u16() -> Result<()> { let vec: Vec = vec![0xFE, 0xFF]; let result = from_vec(&vec); assert_eq!(0xFFFEu16, result?); Ok(()) } #[test] fn deserialize_u32() -> Result<()> { let vec: Vec = vec![0xFE, 0xFF, 0xFF, 0xFF]; let result = from_vec(&vec); assert_eq!(0xFFFFFFFEu32, result?); Ok(()) } #[test] fn deserialize_u64() -> Result<()> { let vec: Vec = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]; let result = from_vec(&vec); assert_eq!(0xFFFFFFFFFFFFFFFEu64, result?); Ok(()) } #[test] fn deserialize_u128() -> Result<()> { let vec: Vec = vec![ 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, ]; let result = from_vec(&vec); assert_eq!(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEu128, result?); Ok(()) } #[test] fn deserialize_f32() -> Result<()> { let vec: Vec = vec![0x00, 0x00, 0x20, 0x3E]; let result = from_vec(&vec); assert_eq!(0.15625f32, result?); Ok(()) } #[test] fn deserialize_f64() -> Result<()> { let vec: Vec = vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F]; let result = from_vec(&vec); assert_eq!(1f64, result?); Ok(()) } #[test] fn deserialize_char() -> Result<()> { fn test_case(c: char, vec: Vec) -> Result<()> { let result = from_vec(&vec); assert_eq!(c, result?); Ok(()) } test_case('*', vec![0x2A])?; test_case('£', vec![0xC2, 0xA3])?; test_case('€', vec![0xE2, 0x82, 0xAC])?; test_case('😎', vec![0xF0, 0x9F, 0x98, 0x8E])?; Ok(()) } /// Returns the bytes that would be returned if the given data were serialized. macro_rules! input { ($expected:expr) => {{ const LEN: [u8; 4] = ($expected.len() as u32).to_le_bytes(); const INPUT_LEN: usize = LEN.len() + EXPECTED.len(); let mut input = [0u8; INPUT_LEN]; (&mut input[..LEN.len()]).copy_from_slice(&LEN); (&mut input[LEN.len()..]).copy_from_slice(&EXPECTED); input }}; } #[test] fn deserialize_str() -> Result<()> { const EXPECTED: &[u8] = b"Without nature's limits, humanity's true nature was revealed."; let input = input!(EXPECTED); let actual: &str = from_slice(input.as_slice())?; let expected = std::str::from_utf8(EXPECTED).unwrap(); assert_eq!(expected, actual); Ok(()) } #[test] fn deserialize_string() -> Result<()> { let vec: Vec = vec![ 0x06, 0x00, 0x00, 0x00, 'l' as u8, 'o' as u8, 'c' as u8, 'a' as u8, 's' as u8, 'h' as u8, ]; let result: Result = from_vec(&vec); assert_eq!("locash", result?); Ok(()) } #[test] fn deserialize_bytes() -> Result<()> { const EXPECTED: &[u8] = b"I have altered the API, pray I don't alter it any further."; let input = input!(EXPECTED); let actual: &[u8] = from_slice(input.as_slice())?; assert_eq!(EXPECTED, actual); Ok(()) } #[test] fn deserialize_byte_buf() -> Result<()> { let vec: Vec = vec![0x04, 0x00, 0x00, 0x00, 0x42, 0x91, 0xBE, 0xEF]; let result: Result> = from_vec(&vec); assert_eq!(&vec[4..], result?); Ok(()) } #[test] fn deserialize_none() -> Result<()> { let vec: Vec = vec![0x00]; let result: Result> = from_vec(&vec); assert_eq!(None, result?); Ok(()) } #[test] fn deserialize_some() -> Result<()> { let vec: Vec = vec![0x01, 0xD5]; let result: Result> = from_vec(&vec); assert_eq!(Some(0xD5u8), result?); Ok(()) } #[test] fn deserialize_tuple() -> Result<()> { let expected = ("orb".to_string(), 12u16); let vec: Vec = vec![ 0x03, 0x00, 0x00, 0x00, 'o' as u8, 'r' as u8, 'b' as u8, 0x0C, 0x00, ]; let result = from_vec(&vec); assert_eq!(expected, result?); Ok(()) } #[test] fn deserialize_map() -> Result<()> { let expected: HashMap = HashMap::from([("blue".to_string(), 5), ("red".to_string(), 7)]); let vec: Vec = vec![ 0x02, 0x00, 0x00, 0x00, // Number of entries in the map. 0x04, 0x00, 0x00, 0x00, 'b' as u8, 'l' as u8, 'u' as u8, 'e' as u8, // First key. 0x05, // First value. 0x03, 0x00, 0x00, 0x00, 'r' as u8, 'e' as u8, 'd' as u8, // Second key. 0x07, // Second value. ]; let result = from_vec(&vec); assert_eq!(expected, result?); Ok(()) } #[test] fn deserialize_struct() -> Result<()> { #[derive(Debug, PartialEq, Deserialize)] struct Order { customer: String, item_id: u16, quantity: u8, } let expected = Order { customer: "Bob".to_string(), item_id: 256, quantity: 255, }; let vec: Vec = vec![ 0x03, 0x00, 0x00, 0x00, 'B' as u8, 'o' as u8, 'b' as u8, 0x00, 0x01, 0xFF, ]; let result = from_vec(&vec); assert_eq!(expected, result?); Ok(()) } #[test] fn deserialize_enum() -> Result<()> { #[derive(Debug, PartialEq, Deserialize)] enum Emotions { Anguish, Catharsis, } let vec: Vec = vec![0x01, 0x00]; let result = from_vec(&vec); assert_eq!(Emotions::Catharsis, result?); Ok(()) } #[test] fn deserialize_struct_variant() -> Result<()> { #[derive(Debug, PartialEq, Deserialize)] enum Vector { Dim2(i32, i32), Dim3(i32, i32, i32), } let expected = Vector::Dim3(1, -1, -2); let vec: Vec = vec![ 0x01, 0x00, // The variant index. 0x01, 0x00, 0x00, 0x00, // The first entry. 0xFF, 0xFF, 0xFF, 0xFF, // The second entry. 0xFE, 0xFF, 0xFF, 0xFF, // The last entry. ]; let result = from_vec(&vec); assert_eq!(expected, result?); Ok(()) } }