use crate::config::Config;
use crate::error::{DecodeError, Result};
use serde::de::{self, DeserializeOwned};
pub(crate) struct Deserializer<'de> {
input: &'de [u8],
pub(crate) pos: usize,
cfg: Config,
}
impl<'de> Deserializer<'de> {
pub fn new(input: &'de [u8], cfg: Config) -> Self {
Self { input, pos: 0, cfg }
}
fn read_u8(&mut self) -> Result<u8> {
if self.pos >= self.input.len() { return Err(DecodeError::UnexpectedEof); }
let v = self.input[self.pos];
self.pos += 1;
Ok(v)
}
fn read_exact(&mut self, len: usize) -> Result<&'de [u8]> {
let end = self.pos.checked_add(len).ok_or(DecodeError::UnexpectedEof)?;
let slice = self.input.get(self.pos..end).ok_or(DecodeError::UnexpectedEof)?;
self.pos = end;
Ok(slice)
}
fn read_le_u16(&mut self) -> Result<u16> {
let s = self.read_exact(2)?;
Ok(u16::from_le_bytes([s[0], s[1]]))
}
fn read_le_u32(&mut self) -> Result<u32> {
let s = self.read_exact(4)?;
Ok(u32::from_le_bytes([s[0], s[1], s[2], s[3]]))
}
fn read_le_u64(&mut self) -> Result<u64> {
let s = self.read_exact(8)?;
Ok(u64::from_le_bytes([s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]]))
}
fn read_varint(&mut self) -> Result<u64> {
let mut value: u64 = 0;
let mut shift = 0u32;
loop {
let b = self.read_u8()?;
value |= ((b & 0x7F) as u64) << shift;
if b & 0x80 == 0 { break; }
shift += 7;
if shift >= 64 { return Err(DecodeError::Message("varint too large".into())); }
}
Ok(value)
}
fn read_len(&mut self) -> Result<usize> {
if let Some(limit) = self.cfg.limit {
if self.cfg.use_varint {
let v = self.read_varint()? as usize;
if v > limit { return Err(DecodeError::Message("length exceeds limit".into())); }
Ok(v)
} else {
let v = self.read_le_u64()? as usize;
if v > limit { return Err(DecodeError::Message("length exceeds limit".into())); }
Ok(v)
}
} else if self.cfg.use_varint {
Ok(self.read_varint()? as usize)
} else {
Ok(self.read_le_u64()? as usize)
}
}
}
impl<'de> de::Deserializer<'de> for &mut Deserializer<'de> {
type Error = DecodeError;
fn deserialize_any<V>(self, _visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
Err(DecodeError::Message("deserialize_any not supported".into()))
}
fn deserialize_bool<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let b = self.read_u8()?;
match b {
0 => visitor.visit_bool(false),
1 => visitor.visit_bool(true),
other => Err(DecodeError::Message(format!("invalid bool tag {}", other))),
}
}
fn deserialize_u8<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let v = self.read_u8()?;
visitor.visit_u8(v)
}
fn deserialize_u16<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let v = self.read_le_u16()?;
visitor.visit_u16(v)
}
fn deserialize_u32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let v = self.read_le_u32()?;
visitor.visit_u32(v)
}
fn deserialize_u64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let v = self.read_le_u64()?;
visitor.visit_u64(v)
}
fn deserialize_i8<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let v = self.read_u8()? as i8;
visitor.visit_i8(v)
}
fn deserialize_i16<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let v = self.read_le_u16()? as i16;
visitor.visit_i16(v)
}
fn deserialize_i32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let v = self.read_le_u32()? as i32;
visitor.visit_i32(v)
}
fn deserialize_i64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let v = self.read_le_u64()? as i64;
visitor.visit_i64(v)
}
fn deserialize_f32<V>(self, _visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
Err(DecodeError::Message("f32 not supported".into()))
}
fn deserialize_f64<V>(self, _visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
Err(DecodeError::Message("f64 not supported".into()))
}
fn deserialize_char<V>(self, _visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
Err(DecodeError::Message("char not supported".into()))
}
fn deserialize_str<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let len = self.read_len()?;
let bytes = self.read_exact(len)?;
match std::str::from_utf8(bytes) {
Ok(s) => visitor.visit_borrowed_str(s),
Err(e) => Err(DecodeError::InvalidUtf8(e)),
}
}
fn deserialize_string<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let len = self.read_len()?;
let bytes = self.read_exact(len)?;
match std::str::from_utf8(bytes) {
Ok(s) => visitor.visit_string(s.to_owned()),
Err(e) => Err(DecodeError::InvalidUtf8(e)),
}
}
fn deserialize_bytes<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let len = self.read_len()?;
let bytes = self.read_exact(len)?;
visitor.visit_borrowed_bytes(bytes)
}
fn deserialize_byte_buf<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let len = self.read_len()?;
let bytes = self.read_exact(len)?;
visitor.visit_byte_buf(bytes.to_vec())
}
fn deserialize_option<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let tag = self.read_u8()?;
match tag {
0 => visitor.visit_none(),
1 => visitor.visit_some(self),
other => Err(DecodeError::Message(format!("invalid option tag {}", other))),
}
}
fn deserialize_unit<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
visitor.visit_unit()
}
fn deserialize_seq<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let len = self.read_len()?;
struct Access<'a, 'de: 'a> { remaining: usize, de: &'a mut Deserializer<'de> }
impl<'de, 'a> de::SeqAccess<'de> for Access<'a, 'de> {
type Error = DecodeError;
fn next_element_seed<T>(&mut self, seed: T) -> std::result::Result<Option<T::Value>, Self::Error>
where T: de::DeserializeSeed<'de> {
if self.remaining == 0 { return Ok(None); }
self.remaining -= 1;
let v = seed.deserialize(&mut *self.de)?;
Ok(Some(v))
}
}
let access = Access { remaining: len, de: self };
visitor.visit_seq(access)
}
fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
self.deserialize_seq(visitor)
}
fn deserialize_map<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
let len = self.read_len()?;
struct MapAccess<'a, 'de: 'a> { remaining: usize, de: &'a mut Deserializer<'de> }
impl<'de, 'a> de::MapAccess<'de> for MapAccess<'a, 'de> {
type Error = DecodeError;
fn next_key_seed<K>(&mut self, seed: K) -> std::result::Result<Option<K::Value>, Self::Error>
where K: de::DeserializeSeed<'de> {
if self.remaining == 0 { return Ok(None); }
let key = seed.deserialize(&mut *self.de)?;
Ok(Some(key))
}
fn next_value_seed<VV>(&mut self, seed: VV) -> std::result::Result<VV::Value, Self::Error>
where VV: de::DeserializeSeed<'de> {
self.remaining -= 1;
let v = seed.deserialize(&mut *self.de)?;
Ok(v)
}
}
let access = MapAccess { remaining: len, de: self };
visitor.visit_map(access)
}
fn deserialize_struct<V>(self, _name: &'static str, _fields: &'static [&'static str], visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
self.deserialize_map(visitor)
}
fn deserialize_identifier<V>(self, _visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
Err(DecodeError::Message("identifier not supported".into()))
}
fn deserialize_enum<V>(self, _name: &'static str, _variants: &'static [&'static str], _visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
Err(DecodeError::Message("enum not supported".into()))
}
fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
self.deserialize_unit(visitor)
}
fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
visitor.visit_newtype_struct(self)
}
fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
self.deserialize_seq(visitor)
}
fn deserialize_ignored_any<V>(self, _visitor: V) -> std::result::Result<V::Value, Self::Error>
where V: de::Visitor<'de> {
Err(DecodeError::Message("ignored_any not supported".into()))
}
}
pub fn decode_from_slice<T>(data: &[u8], cfg: Config) -> Result<(T, usize)>
where T: DeserializeOwned {
let mut d = Deserializer::new(data, cfg);
let value = T::deserialize(&mut d).map_err(|e| DecodeError::Message(format!("deserialize error: {:?}", e)))?;
Ok((value, d.pos))
}