# Trait serde::de::Deserializer

source · [−]

    pub trait Deserializer<'de>: Sized {
        type Error: Error;

    Show 32 methods    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_unit_struct<V>(
            self,
            name: &'static str,
            visitor: V
        ) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_newtype_struct<V>(
            self,
            name: &'static str,
            visitor: V
        ) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_tuple<V>(
            self,
            len: usize,
            visitor: V
        ) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_tuple_struct<V>(
            self,
            name: &'static str,
            len: usize,
            visitor: V
        ) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_struct<V>(
            self,
            name: &'static str,
            fields: &'static [&'static str],
            visitor: V
        ) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_enum<V>(
            self,
            name: &'static str,
            variants: &'static [&'static str],
            visitor: V
        ) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_identifier<V>(
            self,
            visitor: V
        ) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;
        fn deserialize_ignored_any<V>(
            self,
            visitor: V
        ) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>;

        fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>,
        { ... }
        fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>,
        { ... }
        fn is_human_readable(&self) -> bool { ... }
    }

Expand description

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:

- 14 primitive types
  - bool
  - i8, i16, i32, i64, i128
  - u8, u16, u32, u64, u128
  - f32, f64
  - char
- string
  - UTF-8 bytes with a length and no null terminator.
  - When serializing, all strings are handled equally. When deserializing, there are three flavors of strings: transient, owned, and borrowed.
- byte array - [u8]
  - Similar to strings, during deserialization byte arrays can be transient, owned, or borrowed.
- option
  - Either none or some value.
- unit
  - The type of `()` in Rust. It represents an anonymous value containing no data.
- unit_struct
  - For example `struct Unit` or `PhantomData<T>`. It represents a named value containing no data.
- unit_variant
  - For example the `E::A` and `E::B` in `enum E { A, B }`.
- newtype_struct
  - For example `struct Millimeters(u8)`.
- newtype_variant
  - For example the `E::N` in `enum E { N(u8) }`.
- seq
  - A variably sized heterogeneous sequence of values, for example `Vec<T>` or `HashSet<T>`. When serializing, the length may or may not be known before iterating through all the data. When deserializing, the length is determined by looking at the serialized data.
- tuple
  - A statically sized heterogeneous sequence of values for which the length will be known at deserialization time without looking at the serialized data, for example `(u8,)` or `(String, u64, Vec<T>)` or `[u64; 10]`.
- tuple_struct
  - A named tuple, for example `struct Rgb(u8, u8, u8)`.
- tuple_variant
  - For example the `E::T` in `enum E { T(u8, u8) }`.
- map
  - A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.
- struct
  - A heterogeneous key-value pairing in which the keys are strings and will be known at deserialization time without looking at the serialized data, for example `struct S { r: u8, g: u8, b: u8 }`.
- struct_variant
  - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.

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`.

## Required Associated Types

source

#### type Error: Error

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

## Required Methods

source

#### fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::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.

source

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

Hint that the `Deserialize` type is expecting a `bool` value.

source

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

Hint that the `Deserialize` type is expecting an `i8` value.

source

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

Hint that the `Deserialize` type is expecting an `i16` value.

source

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

Hint that the `Deserialize` type is expecting an `i32` value.

source

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

Hint that the `Deserialize` type is expecting an `i64` value.

source

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

Hint that the `Deserialize` type is expecting a `u8` value.

source

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

Hint that the `Deserialize` type is expecting a `u16` value.

source

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

Hint that the `Deserialize` type is expecting a `u32` value.

source

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

Hint that the `Deserialize` type is expecting a `u64` value.

source

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

Hint that the `Deserialize` type is expecting a `f32` value.

source

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

Hint that the `Deserialize` type is expecting a `f64` value.

source

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

Hint that the `Deserialize` type is expecting a `char` value.

source

#### fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::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.

source

#### fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::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.

source

#### fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::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.

source

#### fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::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.

source

#### fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::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)`.

source

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

Hint that the `Deserialize` type is expecting a unit value.

source

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

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

source

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

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

source

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

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

source

#### fn deserialize_tuple<V>(
self,
len: usize,
visitor: V
) -> Result<V::Value, Self::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.

source

#### fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'de>,

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

source

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

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

source

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

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

source

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

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

source

#### fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::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.

source

#### fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::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

source

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

Hint that the `Deserialize` type is expecting an `i128` value.

This method is available only on Rust compiler versions >=1.26. The default behavior unconditionally returns an error.

source

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

Hint that the `Deserialize` type is expecting an `u128` value.

This method is available only on Rust compiler versions >=1.26. The default behavior unconditionally returns an error.

source

#### fn is_human_readable(&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 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

source

### impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E> where
E: Error,

#### type Error = E

source

### impl<'de, 'a, E> Deserializer<'de> for CowStrDeserializer<'a, E> where
E: Error,

#### type Error = E

source

### impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E> where
E: Error,

#### type Error = E

source

### impl<'de, A> Deserializer<'de> for EnumAccessDeserializer<A> where
A: EnumAccess<'de>,

#### type Error = <A as EnumAccess<'de>>::Error

source

### impl<'de, A> Deserializer<'de> for MapAccessDeserializer<A> where
A: MapAccess<'de>,

#### type Error = <A as MapAccess<'de>>::Error

source

### impl<'de, A> Deserializer<'de> for SeqAccessDeserializer<A> where
A: SeqAccess<'de>,

#### type Error = <A as SeqAccess<'de>>::Error

source

### impl<'de, E> Deserializer<'de> for BoolDeserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for BorrowedBytesDeserializer<'de, E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for CharDeserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for F32Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for F64Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for I8Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for I16Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for I32Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for I64Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for I128Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for IsizeDeserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for StringDeserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for U8Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for U16Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for U32Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for U64Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for U128Deserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for UnitDeserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, E> Deserializer<'de> for UsizeDeserializer<E> where
E: Error,

#### type Error = E

source

### impl<'de, I, E> Deserializer<'de> for MapDeserializer<'de, I, E> where
I: Iterator,
I::Item: Pair,
<I::Item as Pair>::First: IntoDeserializer<'de, E>,
<I::Item as Pair>::Second: IntoDeserializer<'de, E>,
E: Error,

#### type Error = E

source

### impl<'de, I, T, E> Deserializer<'de> for SeqDeserializer<I, E> where
I: Iterator<Item = T>,
T: IntoDeserializer<'de, E>,
E: Error,

#### type Error = E