Struct bincode::endian_choice::Deserializer

pub struct Deserializer<R, S: SizeLimit, E: ByteOrder> { /* fields omitted */ }

A Deserializer that reads bytes from a buffer.

This struct should rarely be used. In most cases, prefer the decode_from function.

let d = Deserializer::new(&mut some_reader, SizeLimit::new());
serde::Deserialize::deserialize(&mut deserializer);
let bytes_read = d.bytes_read();

Methods

impl<R: Read, E: ByteOrder, S: SizeLimit> Deserializer<R, S, E>

fn new(r: R, size_limit: S) -> Deserializer<R, S, E>

fn bytes_read(&self) -> u64

Returns the number of bytes read from the contained Reader.

Trait Implementations

impl<'a, R, S, E> Deserializer for &'a mut Deserializer<R, S, E> where R: Read,
        S: SizeLimit,
        E: ByteOrder

type Error = Error

The error type that can be returned if some error occurs during deserialization.

fn deserialize<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input.

fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a bool value.

fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a u16 value.

fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a u32 value.

fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a u64 value.

fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting an i16 value.

fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting an i32 value.

fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting an i64 value.

fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a f32 value.

fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a f64 value.

fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a u8 value.

fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting an i8 value.

fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a unit value.

fn deserialize_char<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a char value.

fn deserialize_str<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a string value and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_string<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a string value and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a byte array and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a byte array and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_enum<V>(self,
                       _enum: &'static str,
                       _variants: &'static [&'static str],
                       visitor: V)
                       -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting an enum value with a particular name and possible variants.

fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a tuple value with a particular number of elements.

fn deserialize_seq_fixed_size<V>(self,
                                 len: usize,
                                 visitor: V)
                                 -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a sequence of values and knows how many values there are without looking at the serialized data.

fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting an optional value.

fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a sequence of values.

fn deserialize_map<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a map of key-value pairs.

fn deserialize_struct<V>(self,
                         _name: &str,
                         fields: &'static [&'static str],
                         visitor: V)
                         -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a struct with a particular name and fields.

fn deserialize_struct_field<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting the name of a struct field.

fn deserialize_newtype_struct<V>(self,
                                 _name: &str,
                                 visitor: V)
                                 -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a newtype struct with a particular name.

fn deserialize_unit_struct<V>(self,
                              _name: &'static str,
                              visitor: V)
                              -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a unit struct with a particular name.

fn deserialize_tuple_struct<V>(self,
                               _name: &'static str,
                               len: usize,
                               visitor: V)
                               -> Result<V::Value> where V: Visitor

Hint that the Deserialize type is expecting a tuple struct with a particular name and number of fields.

fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor

Hint that the Deserialize type needs to deserialize a value whose type doesn't matter because it is ignored.

impl<'a, R, S, E> VariantVisitor for &'a mut Deserializer<R, S, E> where R: Read,
        S: SizeLimit,
        E: ByteOrder

type Error = Error

The error type that can be returned if some error occurs during deserialization. Must match the error type of our EnumVisitor.

fn visit_unit(self) -> Result<()>

Called when deserializing a variant with no values.

fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value> where T: DeserializeSeed

Called when deserializing a variant with a single value.

fn visit_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value> where V: Visitor

Called when deserializing a tuple-like variant.

fn visit_struct<V>(self,
                   fields: &'static [&'static str],
                   visitor: V)
                   -> Result<V::Value> where V: Visitor

Called when deserializing a struct-like variant.

fn visit_newtype<T>(self) -> Result<T, Self::Error> where T: Deserialize

Called when deserializing a variant with a single value.