use config::{BincodeByteOrder, Options}; | |
use std::io::Read; | |
use self::read::{BincodeRead, IoReader, SliceReader}; | |
use byteorder::ReadBytesExt; | |
use config::{IntEncoding, SizeLimit}; | |
use serde; | |
use serde::de::Error as DeError; | |
use serde::de::IntoDeserializer; | |
use {Error, ErrorKind, Result}; | |
/// Specialized ways to read data into bincode. | |
pub mod read; | |
/// A Deserializer that reads bytes from a buffer. | |
/// | |
/// This struct should rarely be used. | |
/// In most cases, prefer the `deserialize_from` function. | |
/// | |
/// The ByteOrder that is chosen will impact the endianness that | |
/// is used to read integers out of the reader. | |
/// | |
/// ```ignore | |
/// let d = Deserializer::new(&mut some_reader, SizeLimit::new()); | |
/// serde::Deserialize::deserialize(&mut deserializer); | |
/// let bytes_read = d.bytes_read(); | |
/// ``` | |
pub struct Deserializer<R, O: Options> { | |
pub(crate) reader: R, | |
options: O, | |
} | |
macro_rules! impl_deserialize_literal { | |
($name:ident : $ty:ty = $read:ident()) => { | |
#[inline] | |
pub(crate) fn $name(&mut self) -> Result<$ty> { | |
self.read_literal_type::<$ty>()?; | |
self.reader | |
.$read::<<O::Endian as BincodeByteOrder>::Endian>() | |
.map_err(Into::into) | |
} | |
}; | |
} | |
impl<'de, IR: Read, O: Options> Deserializer<IoReader<IR>, O> { | |
/// Creates a new Deserializer with a given `Read`er and options. | |
pub fn with_reader(r: IR, options: O) -> Self { | |
Deserializer { | |
reader: IoReader::new(r), | |
options, | |
} | |
} | |
} | |
impl<'de, O: Options> Deserializer<SliceReader<'de>, O> { | |
/// Creates a new Deserializer that will read from the given slice. | |
pub fn from_slice(slice: &'de [u8], options: O) -> Self { | |
Deserializer { | |
reader: SliceReader::new(slice), | |
options, | |
} | |
} | |
} | |
impl<'de, R: BincodeRead<'de>, O: Options> Deserializer<R, O> { | |
/// Creates a new Deserializer with the given `BincodeRead`er | |
pub fn with_bincode_read(r: R, options: O) -> Deserializer<R, O> { | |
Deserializer { reader: r, options } | |
} | |
pub(crate) fn deserialize_byte(&mut self) -> Result<u8> { | |
self.read_literal_type::<u8>()?; | |
self.reader.read_u8().map_err(Into::into) | |
} | |
impl_deserialize_literal! { deserialize_literal_u16 : u16 = read_u16() } | |
impl_deserialize_literal! { deserialize_literal_u32 : u32 = read_u32() } | |
impl_deserialize_literal! { deserialize_literal_u64 : u64 = read_u64() } | |
serde_if_integer128! { | |
impl_deserialize_literal! { deserialize_literal_u128 : u128 = read_u128() } | |
} | |
fn read_bytes(&mut self, count: u64) -> Result<()> { | |
self.options.limit().add(count) | |
} | |
fn read_literal_type<T>(&mut self) -> Result<()> { | |
use std::mem::size_of; | |
self.read_bytes(size_of::<T>() as u64) | |
} | |
fn read_vec(&mut self) -> Result<Vec<u8>> { | |
let len = O::IntEncoding::deserialize_len(self)?; | |
self.read_bytes(len as u64)?; | |
self.reader.get_byte_buffer(len) | |
} | |
fn read_string(&mut self) -> Result<String> { | |
let vec = self.read_vec()?; | |
String::from_utf8(vec).map_err(|e| ErrorKind::InvalidUtf8Encoding(e.utf8_error()).into()) | |
} | |
} | |
macro_rules! impl_deserialize_int { | |
($name:ident = $visitor_method:ident ($dser_method:ident)) => { | |
#[inline] | |
fn $name<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
visitor.$visitor_method(O::IntEncoding::$dser_method(self)?) | |
} | |
}; | |
} | |
impl<'de, 'a, R, O> serde::Deserializer<'de> for &'a mut Deserializer<R, O> | |
where | |
R: BincodeRead<'de>, | |
O: Options, | |
{ | |
type Error = Error; | |
#[inline] | |
fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
Err(Box::new(ErrorKind::DeserializeAnyNotSupported)) | |
} | |
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
match self.deserialize_byte()? { | |
1 => visitor.visit_bool(true), | |
0 => visitor.visit_bool(false), | |
value => Err(ErrorKind::InvalidBoolEncoding(value).into()), | |
} | |
} | |
impl_deserialize_int!(deserialize_u16 = visit_u16(deserialize_u16)); | |
impl_deserialize_int!(deserialize_u32 = visit_u32(deserialize_u32)); | |
impl_deserialize_int!(deserialize_u64 = visit_u64(deserialize_u64)); | |
impl_deserialize_int!(deserialize_i16 = visit_i16(deserialize_i16)); | |
impl_deserialize_int!(deserialize_i32 = visit_i32(deserialize_i32)); | |
impl_deserialize_int!(deserialize_i64 = visit_i64(deserialize_i64)); | |
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
self.read_literal_type::<f32>()?; | |
let value = self | |
.reader | |
.read_f32::<<O::Endian as BincodeByteOrder>::Endian>()?; | |
visitor.visit_f32(value) | |
} | |
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
self.read_literal_type::<f64>()?; | |
let value = self | |
.reader | |
.read_f64::<<O::Endian as BincodeByteOrder>::Endian>()?; | |
visitor.visit_f64(value) | |
} | |
serde_if_integer128! { | |
impl_deserialize_int!(deserialize_u128 = visit_u128(deserialize_u128)); | |
impl_deserialize_int!(deserialize_i128 = visit_i128(deserialize_i128)); | |
} | |
#[inline] | |
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
visitor.visit_u8(self.deserialize_byte()? as u8) | |
} | |
#[inline] | |
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
visitor.visit_i8(self.deserialize_byte()? as i8) | |
} | |
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
visitor.visit_unit() | |
} | |
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
use std::str; | |
let error = || ErrorKind::InvalidCharEncoding.into(); | |
let mut buf = [0u8; 4]; | |
// Look at the first byte to see how many bytes must be read | |
self.reader.read_exact(&mut buf[..1])?; | |
let width = utf8_char_width(buf[0]); | |
if width == 1 { | |
return visitor.visit_char(buf[0] as char); | |
} | |
if width == 0 { | |
return Err(error()); | |
} | |
if self.reader.read_exact(&mut buf[1..width]).is_err() { | |
return Err(error()); | |
} | |
let res = str::from_utf8(&buf[..width]) | |
.ok() | |
.and_then(|s| s.chars().next()) | |
.ok_or_else(error)?; | |
visitor.visit_char(res) | |
} | |
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
let len = O::IntEncoding::deserialize_len(self)?; | |
self.read_bytes(len as u64)?; | |
self.reader.forward_read_str(len, visitor) | |
} | |
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
visitor.visit_string(self.read_string()?) | |
} | |
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
let len = O::IntEncoding::deserialize_len(self)?; | |
self.read_bytes(len as u64)?; | |
self.reader.forward_read_bytes(len, visitor) | |
} | |
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
visitor.visit_byte_buf(self.read_vec()?) | |
} | |
fn deserialize_enum<V>( | |
self, | |
_enum: &'static str, | |
_variants: &'static [&'static str], | |
visitor: V, | |
) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
impl<'de, 'a, R: 'a, O> serde::de::EnumAccess<'de> for &'a mut Deserializer<R, O> | |
where | |
R: BincodeRead<'de>, | |
O: Options, | |
{ | |
type Error = Error; | |
type Variant = Self; | |
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)> | |
where | |
V: serde::de::DeserializeSeed<'de>, | |
{ | |
let idx: u32 = O::IntEncoding::deserialize_u32(self)?; | |
let val: Result<_> = seed.deserialize(idx.into_deserializer()); | |
Ok((val?, self)) | |
} | |
} | |
visitor.visit_enum(self) | |
} | |
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
struct Access<'a, R: Read + 'a, O: Options + 'a> { | |
deserializer: &'a mut Deserializer<R, O>, | |
len: usize, | |
} | |
impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, O: Options> serde::de::SeqAccess<'de> | |
for Access<'a, R, O> | |
{ | |
type Error = Error; | |
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> | |
where | |
T: serde::de::DeserializeSeed<'de>, | |
{ | |
if self.len > 0 { | |
self.len -= 1; | |
let value = | |
serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?; | |
Ok(Some(value)) | |
} else { | |
Ok(None) | |
} | |
} | |
fn size_hint(&self) -> Option<usize> { | |
Some(self.len) | |
} | |
} | |
visitor.visit_seq(Access { | |
deserializer: self, | |
len, | |
}) | |
} | |
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
let value: u8 = serde::de::Deserialize::deserialize(&mut *self)?; | |
match value { | |
0 => visitor.visit_none(), | |
1 => visitor.visit_some(&mut *self), | |
v => Err(ErrorKind::InvalidTagEncoding(v as usize).into()), | |
} | |
} | |
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
let len = O::IntEncoding::deserialize_len(self)?; | |
self.deserialize_tuple(len, visitor) | |
} | |
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
struct Access<'a, R: Read + 'a, O: Options + 'a> { | |
deserializer: &'a mut Deserializer<R, O>, | |
len: usize, | |
} | |
impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, O: Options> serde::de::MapAccess<'de> | |
for Access<'a, R, O> | |
{ | |
type Error = Error; | |
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>> | |
where | |
K: serde::de::DeserializeSeed<'de>, | |
{ | |
if self.len > 0 { | |
self.len -= 1; | |
let key = | |
serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?; | |
Ok(Some(key)) | |
} else { | |
Ok(None) | |
} | |
} | |
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> | |
where | |
V: serde::de::DeserializeSeed<'de>, | |
{ | |
let value = serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?; | |
Ok(value) | |
} | |
fn size_hint(&self) -> Option<usize> { | |
Some(self.len) | |
} | |
} | |
let len = O::IntEncoding::deserialize_len(self)?; | |
visitor.visit_map(Access { | |
deserializer: self, | |
len, | |
}) | |
} | |
fn deserialize_struct<V>( | |
self, | |
_name: &str, | |
fields: &'static [&'static str], | |
visitor: V, | |
) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
self.deserialize_tuple(fields.len(), visitor) | |
} | |
fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
let message = "Bincode does not support Deserializer::deserialize_identifier"; | |
Err(Error::custom(message)) | |
} | |
fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
visitor.visit_newtype_struct(self) | |
} | |
fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
visitor.visit_unit() | |
} | |
fn deserialize_tuple_struct<V>( | |
self, | |
_name: &'static str, | |
len: usize, | |
visitor: V, | |
) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
self.deserialize_tuple(len, visitor) | |
} | |
fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
let message = "Bincode does not support Deserializer::deserialize_ignored_any"; | |
Err(Error::custom(message)) | |
} | |
fn is_human_readable(&self) -> bool { | |
false | |
} | |
} | |
impl<'de, 'a, R, O> serde::de::VariantAccess<'de> for &'a mut Deserializer<R, O> | |
where | |
R: BincodeRead<'de>, | |
O: Options, | |
{ | |
type Error = Error; | |
fn unit_variant(self) -> Result<()> { | |
Ok(()) | |
} | |
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value> | |
where | |
T: serde::de::DeserializeSeed<'de>, | |
{ | |
serde::de::DeserializeSeed::deserialize(seed, self) | |
} | |
fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
serde::de::Deserializer::deserialize_tuple(self, len, visitor) | |
} | |
fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value> | |
where | |
V: serde::de::Visitor<'de>, | |
{ | |
serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor) | |
} | |
} | |
static UTF8_CHAR_WIDTH: [u8; 256] = [ | |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1, // 0x1F | |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1, // 0x3F | |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1, // 0x5F | |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1, // 0x7F | |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
0, // 0x9F | |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
0, // 0xBF | |
0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
2, // 0xDF | |
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xEF | |
4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xFF | |
]; | |
// This function is a copy of core::str::utf8_char_width | |
fn utf8_char_width(b: u8) -> usize { | |
UTF8_CHAR_WIDTH[b as usize] as usize | |
} |