Trait serde::de::Deserializer[−][src]

pub trait Deserializer {
    type Error: Error;
    fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor;

    fn visit_bool<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_usize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_u8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_u16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_u32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_u64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_isize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_i8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_i16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_i32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_i64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_f32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_f64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_char<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_str<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_string<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_unit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_option<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_unit_struct<V>(
        &mut self, 
        _name: &'static str, 
        visitor: V
    ) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_newtype_struct<V>(
        &mut self, 
        name: &'static str, 
        visitor: V
    ) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_tuple_struct<V>(
        &mut self, 
        _name: &'static str, 
        len: usize, 
        visitor: V
    ) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_struct<V>(
        &mut self, 
        _name: &'static str, 
        _fields: &'static [&'static str], 
        visitor: V
    ) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_tuple<V>(
        &mut self, 
        _len: usize, 
        visitor: V
    ) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_enum<V>(
        &mut self, 
        _enum: &'static str, 
        _variants: &'static [&'static str], 
        _visitor: V
    ) -> Result<V::Value, Self::Error>
    where
        V: EnumVisitor,
    { ... }

    fn visit_bytes<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn visit_struct_field<V>(
        &mut self, 
        visitor: V
    ) -> Result<V::Value, Self::Error>
    where
        V: Visitor,
    { ... }

    fn format() -> &'static str { ... }
}

Deserializer is a trait that can deserialize values by threading a Visitor trait through a value. It supports two entry point styles which enables different kinds of deserialization.

  1. The visit method. File formats like JSON embed the type of it's construct in it's file format. This allows the Deserializer to deserialize into a generic type like json::Value, which can represent all JSON types.

  2. The visit_* methods. File formats like bincode do not embed in it's format how to decode it's values. It relies instead on the Deserialize type to hint to the Deserializer with the visit_* methods how it should parse the next value. One downside though to only supporting the visit_* types is that it does not allow for deserializing into a generic json::Value-esque type.

Associated Types

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

Required Methods

This method walks a visitor through a value as it is being deserialized.

Provided Methods

This method hints that the Deserialize type is expecting a bool value.

This method hints that the Deserialize type is expecting an usize value.

This method hints that the Deserialize type is expecting an u8 value.

This method hints that the Deserialize type is expecting an u16 value.

This method hints that the Deserialize type is expecting an u32 value.

This method hints that the Deserialize type is expecting an u64 value.

This method hints that the Deserialize type is expecting an isize value.

This method hints that the Deserialize type is expecting an i8 value.

This method hints that the Deserialize type is expecting an i16 value.

This method hints that the Deserialize type is expecting an i32 value.

This method hints that the Deserialize type is expecting an i64 value.

This method hints that the Deserialize type is expecting a f32 value.

This method hints that the Deserialize type is expecting a f64 value.

This method hints that the Deserialize type is expecting a char value.

This method hints that the Deserialize type is expecting a &str value.

This method hints that the Deserialize type is expecting a String value.

This method hints that the Deserialize type is expecting an unit value.

This method hints that the Deserialize type is expecting an Option value. This allows deserializers that encode an optional value as a nullable value to convert the null value into a None, and a regular value as Some(value).

This method hints that the Deserialize type is expecting a sequence value. This allows deserializers to parse sequences that aren't tagged as sequences.

This method hints that the Deserialize type is expecting a map of values. This allows deserializers to parse sequences that aren't tagged as maps.

This method hints that the Deserialize type is expecting a unit struct. This allows deserializers to a unit struct that aren't tagged as a unit struct.

This method hints that the Deserialize type is expecting a newtype struct. This allows deserializers to a newtype struct that aren't tagged as a newtype struct.

This method hints that the Deserialize type is expecting a tuple struct. This allows deserializers to parse sequences that aren't tagged as sequences.

This method hints that the Deserialize type is expecting a struct. This allows deserializers to parse sequences that aren't tagged as maps.

This method hints that the Deserialize type is expecting a tuple value. This allows deserializers that provide a custom tuple serialization to properly deserialize the type.

This method hints that the Deserialize type is expecting an enum value. This allows deserializers that provide a custom enumeration serialization to properly deserialize the type.

This method hints that the Deserialize type is expecting a Vec<u8>. This allows deserializers that provide a custom byte vector serialization to properly deserialize the type.

This method hints that the Deserialize type is expecting some sort of struct key mapping. This allows deserializers to choose between &str, usize, or &[u8] to properly deserialize a struct key.

Specify a format string for the deserializer.

The deserializer format is used to determine which format specific field attributes should be used with the deserializer.

Implementors