Trait Deserializer

trait Deserializer<'de>: Sized

A data format that can deserialize any data structure supported by Serde.

The role of this trait is to define the deserialization half of the Serde data model, which is a way to categorize every Rust data type into one of 29 possible types. Each method of the Deserializer trait corresponds to one of the types of the data model.

Implementations of Deserialize map themselves into this data model by passing to the Deserializer a Visitor implementation that can receive these various types.

The types that make up the Serde data model are:

The Deserializer trait supports two entry point styles which enables different kinds of deserialization.

  1. The deserialize_any method. Self-describing data formats like JSON are able to look at the serialized data and tell what it represents. For example the JSON deserializer may see an opening curly brace ({) and know that it is seeing a map. If the data format supports Deserializer::deserialize_any, it will drive the Visitor using whatever type it sees in the input. JSON uses this approach when deserializing serde_json::Value which is an enum that can represent any JSON document. Without knowing what is in a JSON document, we can deserialize it to serde_json::Value by going through Deserializer::deserialize_any.

  2. The various deserialize_* methods. Non-self-describing formats like Postcard need to be told what is in the input in order to deserialize it. The deserialize_* methods are hints to the deserializer for how to interpret the next piece of input. Non-self-describing formats are not able to deserialize something like serde_json::Value which relies on Deserializer::deserialize_any.

When implementing Deserialize, you should avoid relying on Deserializer::deserialize_any unless you need to be told by the Deserializer what type is in the input. Know that relying on Deserializer::deserialize_any means your data type will be able to deserialize from self-describing formats only, ruling out Postcard and many others.

Lifetime

The 'de lifetime of this trait is the lifetime of data that may be borrowed from the input when deserializing. See the page Understanding deserializer lifetimes for a more detailed explanation of these lifetimes.

Example implementation

The example data format presented on the website contains example code for a basic JSON Deserializer.

Associated Types

type Error: TraitBound { trait_: Path { path: "Error", id: Id(217), args: None }, generic_params: [], modifier: None }

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

Required Methods

fn deserialize_any<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

When implementing Deserialize, you should avoid relying on Deserializer::deserialize_any unless you need to be told by the Deserializer what type is in the input. Know that relying on Deserializer::deserialize_any means your data type will be able to deserialize from self-describing formats only, ruling out Postcard and many others.

fn deserialize_bool<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting a bool value.

fn deserialize_i8<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting an i8 value.

fn deserialize_i16<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting an i16 value.

fn deserialize_i32<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting an i32 value.

fn deserialize_i64<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting an i64 value.

fn deserialize_u8<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting a u8 value.

fn deserialize_u16<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting a u16 value.

fn deserialize_u32<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting a u32 value.

fn deserialize_u64<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting a u64 value.

fn deserialize_f32<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting a f32 value.

fn deserialize_f64<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting a f64 value.

fn deserialize_char<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting a char value.

fn deserialize_str<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

If the Visitor would benefit from taking ownership of String data, indicate this to the Deserializer by using deserialize_string instead.

fn deserialize_string<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

If the Visitor would not benefit from taking ownership of String data, indicate that to the Deserializer by using deserialize_str instead.

fn deserialize_bytes<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

If the Visitor would benefit from taking ownership of Vec<u8> data, indicate this to the Deserializer by using deserialize_byte_buf instead.

fn deserialize_byte_buf<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

If the Visitor would not benefit from taking ownership of Vec<u8> data, indicate that to the Deserializer by using deserialize_bytes instead.

fn deserialize_option<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting an optional value.

This allows deserializers that encode an optional value as a nullable value to convert the null value into None and a regular value into Some(value).

fn deserialize_unit<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting a unit value.

fn deserialize_unit_struct<V>(self: Self, name: &'static str, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

fn deserialize_newtype_struct<V>(self: Self, name: &'static str, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

fn deserialize_seq<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

fn deserialize_tuple<V>(self: Self, len: usize, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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_tuple_struct<V>(self: Self, name: &'static str, len: usize, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

fn deserialize_map<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

fn deserialize_struct<V>(self: Self, name: &'static str, fields: &'static [&'static str], visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

fn deserialize_enum<V>(self: Self, name: &'static str, variants: &'static [&'static str], visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

fn deserialize_identifier<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting the name of a struct field or the discriminant of an enum variant.

fn deserialize_ignored_any<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

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

Deserializers for non-self-describing formats may not support this mode.

Provided Methods

fn deserialize_i128<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting an i128 value.

The default behavior unconditionally returns an error.

fn deserialize_u128<V>(self: Self, visitor: V) -> Result<<V as >::Value, <Self as >::Error>
where
    V: Visitor<'de>

Hint that the Deserialize type is expecting an u128 value.

The default behavior unconditionally returns an error.

fn is_human_readable(self: &Self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form.

Some types have a human-readable form that may be somewhat expensive to construct, as well as a binary form that is compact and efficient. Generally text-based formats like JSON and YAML will prefer to use the human-readable one and binary formats like Postcard will prefer the compact one.

# use std::ops::Add;
# use std::str::FromStr;
#
# struct Timestamp;
#
# impl Timestamp {
#     const EPOCH: Timestamp = Timestamp;
# }
#
# impl FromStr for Timestamp {
#     type Err = String;
#     fn from_str(_: &str) -> Result<Self, Self::Err> {
#         unimplemented!()
#     }
# }
#
# struct Duration;
#
# impl Duration {
#     fn seconds(_: u64) -> Self { unimplemented!() }
# }
#
# impl Add<Duration> for Timestamp {
#     type Output = Timestamp;
#     fn add(self, _: Duration) -> Self::Output {
#         unimplemented!()
#     }
# }
#
use serde::de::{self, Deserialize, Deserializer};

impl<'de> Deserialize<'de> for Timestamp {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        if deserializer.is_human_readable() {
            // Deserialize from a human-readable string like "2015-05-15T17:01:00Z".
            let s = String::deserialize(deserializer)?;
            Timestamp::from_str(&s).map_err(de::Error::custom)
        } else {
            // Deserialize from a compact binary representation, seconds since
            // the Unix epoch.
            let n = u64::deserialize(deserializer)?;
            Ok(Timestamp::EPOCH + Duration::seconds(n))
        }
    }
}

The default implementation of this method returns true. Data formats may override this to false to request a compact form for types that support one. Note that modifying this method to change a format from human-readable to compact or vice versa should be regarded as a breaking change, as a value serialized in human-readable mode is not required to deserialize from the same data in compact mode.

Implementors