Trait serde_with::DeserializeAs

source ·

pub trait DeserializeAs<'de, T>: Sized {
    // Required method
    fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
       where D: Deserializer<'de>;
}

Expand description

A data structure that can be deserialized from any data format supported by Serde, analogue to Deserialize.

The trait is analogue to the serde::Deserialize trait, with the same meaning of input and output arguments. It can and should be implemented using the same code structure as the Deserialize trait. As such, the same advice for implementing Deserialize applies here.

Differences to `Deserialize`

The trait is only required for container-like types or types implementing specific conversion functions. Container-like types are Vec, BTreeMap, but also Option and Box. Conversion types deserialize into a different Rust type. For example, DisplayFromStr uses the FromStr trait after deserializing a string and DurationSeconds creates a Duration from either String or integer values.

This code shows how to implement Deserialize for Box:

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<T> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        Ok(Box::new(Deserialize::deserialize(deserializer)?))
    }
}

and this code shows how to do the same using DeserializeAs:

impl<'de, T, U> DeserializeAs<'de, Box<T>> for Box<U>
where
    U: DeserializeAs<'de, T>,
{
    fn deserialize_as<D>(deserializer: D) -> Result<Box<T>, D::Error>
    where
        D: Deserializer<'de>,
    {
        Ok(Box::new(
            DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(),
        ))
    }
}

It uses two type parameters, T and U instead of only one and performs the deserialization step using the DeserializeAsWrap type. The T type is the on the Rust side after deserialization, whereas the U type determines how the value will be deserialized. These two changes are usually enough to make a container type implement DeserializeAs.

DeserializeAsWrap is a piece of glue code which turns DeserializeAs into a serde compatible datatype, by converting all calls to deserialize into deserialize_as. This allows us to implement DeserializeAs such that it can be applied recursively throughout the whole data structure. This is mostly important for container types, such as Vec or BTreeMap. In a BTreeMap this allows us to specify two different serialization behaviors, one for key and one for value, using the DeserializeAs trait.

Implementing a converter Type

This shows a simplified implementation for DisplayFromStr.

struct DisplayFromStr;

impl<'de, T> DeserializeAs<'de, T> for DisplayFromStr
where
    T: FromStr,
    T::Err: Display,
{
    fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = String::deserialize(deserializer).map_err(Error::custom)?;
        s.parse().map_err(Error::custom)
    }
}

Required Methods§

source

fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

Trait serde_with::DeserializeAs

Differences to Deserialize

Implementing a converter Type

Required Methods§

fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>where D: Deserializer<'de>,

Implementations on Foreign Types§

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, Option<(K, V)>> for BTreeMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>,

fn deserialize_as<D>(deserializer: D) -> Result<Option<(K, V)>, D::Error>where D: Deserializer<'de>,

fn deserialize_as<D>( deserializer: D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs, const N: usize> DeserializeAs<'de, [(K, V); N]> for BTreeMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>,

fn deserialize_as<D>(deserializer: D) -> Result<[(K, V); N], D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs, S> DeserializeAs<'de, IndexSet<(K, V), S>> for HashMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>, (K, V): Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>(deserializer: D) -> Result<IndexSet2<(K, V), S>, D::Error>where D: Deserializer<'de>,

impl<'de, T, U> DeserializeAs<'de, Box<T, Global>> for Box<U>where U: DeserializeAs<'de, T>,

fn deserialize_as<D>(deserializer: D) -> Result<Box<T>, D::Error>where D: Deserializer<'de>,

impl<'de, T, As, const N: usize> DeserializeAs<'de, [T; N]> for [As; N]where As: DeserializeAs<'de, T>,

fn deserialize_as<D>(deserializer: D) -> Result<[T; N], D::Error>where D: Deserializer<'de>,

impl<'de, K, V, KU, VU> DeserializeAs<'de, BTreeMap<K, V, Global>> for BTreeMap<KU, VU>where KU: DeserializeAs<'de, K>, VU: DeserializeAs<'de, V>, K: Ord,

fn deserialize_as<D>(deserializer: D) -> Result<BTreeMap<K, V>, D::Error>where D: Deserializer<'de>,

impl<'de, T, U> DeserializeAs<'de, Rc<T, Global>> for Rc<U>where U: DeserializeAs<'de, T>,

fn deserialize_as<D>(deserializer: D) -> Result<Rc<T>, D::Error>where D: Deserializer<'de>,

impl<'de, T, U, S> DeserializeAs<'de, IndexSet<T, S>> for IndexSet2<U, S>where U: DeserializeAs<'de, T>, T: Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>(deserializer: D) -> Result<IndexSet2<T, S>, D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs, S> DeserializeAs<'de, HashSet<(K, V), S, Global>> for BTreeMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>, (K, V): Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>( deserializer: D ) -> Result<HashbrownSet014<(K, V), S>, D::Error>where D: Deserializer<'de>,

impl<'de, T0, As0, T1, As1, T2, As2, T3, As3, T4, As4> DeserializeAs<'de, (T0, T1, T2, T3, T4)> for (As0, As1, As2, As3, As4)where As0: DeserializeAs<'de, T0>, As1: DeserializeAs<'de, T1>, As2: DeserializeAs<'de, T2>, As3: DeserializeAs<'de, T3>, As4: DeserializeAs<'de, T4>,

fn deserialize_as<D>(deserializer: D) -> Result<(T0, T1, T2, T3, T4), D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, LinkedList<(K, V), Global>> for BTreeMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>,

fn deserialize_as<D>(deserializer: D) -> Result<LinkedList<(K, V)>, D::Error>where D: Deserializer<'de>,

impl<'de> DeserializeAs<'de, OffsetDateTime> for Rfc2822

fn deserialize_as<D>(deserializer: D) -> Result<OffsetDateTime, D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, LinkedList<(K, V), Global>> for HashMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>,

fn deserialize_as<D>(deserializer: D) -> Result<LinkedList<(K, V)>, D::Error>where D: Deserializer<'de>,

impl<'de, T0, As0, T1, As1, T2, As2, T3, As3> DeserializeAs<'de, (T0, T1, T2, T3)> for (As0, As1, As2, As3)where As0: DeserializeAs<'de, T0>, As1: DeserializeAs<'de, T1>, As2: DeserializeAs<'de, T2>, As3: DeserializeAs<'de, T3>,

fn deserialize_as<D>(deserializer: D) -> Result<(T0, T1, T2, T3), D::Error>where D: Deserializer<'de>,

impl<'de, T, U> DeserializeAs<'de, Option<T>> for Option<U>where U: DeserializeAs<'de, T>,

fn deserialize_as<D>(deserializer: D) -> Result<Option<T>, D::Error>where D: Deserializer<'de>,

impl<'de, K, V, KU, VU, S> DeserializeAs<'de, IndexMap<K, V, S>> for IndexMap<KU, VU, S>where KU: DeserializeAs<'de, K>, VU: DeserializeAs<'de, V>, K: Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>(deserializer: D) -> Result<IndexMap<K, V, S>, D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs, const N: usize> DeserializeAs<'de, [(K, V); N]> for HashMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>,

fn deserialize_as<D>(deserializer: D) -> Result<[(K, V); N], D::Error>where D: Deserializer<'de>,

impl<'de, T, U> DeserializeAs<'de, VecDeque<T, Global>> for VecDeque<U>where U: DeserializeAs<'de, T>,

fn deserialize_as<D>(deserializer: D) -> Result<VecDeque<T>, D::Error>where D: Deserializer<'de>,

impl<'de, T0, As0> DeserializeAs<'de, (T0,)> for (As0,)where As0: DeserializeAs<'de, T0>,

fn deserialize_as<D>(deserializer: D) -> Result<(T0,), D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, BTreeSet<(K, V), Global>> for BTreeMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>, (K, V): Ord,

fn deserialize_as<D>(deserializer: D) -> Result<BTreeSet<(K, V)>, D::Error>where D: Deserializer<'de>,

impl<'de, T, U, S> DeserializeAs<'de, HashSet<T, S>> for HashSet<U, S>where U: DeserializeAs<'de, T>, T: Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>(deserializer: D) -> Result<HashSet<T, S>, D::Error>where D: Deserializer<'de>,

impl<'de, K, V, KU, VU, S> DeserializeAs<'de, HashMap<K, V, S, Global>> for HashbrownMap014<KU, VU, S>where KU: DeserializeAs<'de, K>, VU: DeserializeAs<'de, V>, K: Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>( deserializer: D ) -> Result<HashbrownMap014<K, V, S>, D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs, S> DeserializeAs<'de, IndexSet<(K, V), S>> for BTreeMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>, (K, V): Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>(deserializer: D) -> Result<IndexSet2<(K, V), S>, D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs, S> DeserializeAs<'de, HashSet<(K, V), S, Global>> for HashMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>, (K, V): Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>( deserializer: D ) -> Result<HashbrownSet014<(K, V), S>, D::Error>where D: Deserializer<'de>,

fn deserialize_as<D>( deserializer: D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), D::Error>where D: Deserializer<'de>,

fn deserialize_as<D>( deserializer: D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), D::Error>where D: Deserializer<'de>,

impl<'de, T, U> DeserializeAs<'de, BinaryHeap<T, Global>> for BinaryHeap<U>where U: DeserializeAs<'de, T>, T: Ord,

fn deserialize_as<D>(deserializer: D) -> Result<BinaryHeap<T>, D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, BinaryHeap<(K, V), Global>> for BTreeMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>, (K, V): Ord,

fn deserialize_as<D>(deserializer: D) -> Result<BinaryHeap<(K, V)>, D::Error>where D: Deserializer<'de>,

fn deserialize_as<D>( deserializer: D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), D::Error>where D: Deserializer<'de>,

impl<'de, T, U> DeserializeAs<'de, LinkedList<T, Global>> for LinkedList<U>where U: DeserializeAs<'de, T>,

fn deserialize_as<D>(deserializer: D) -> Result<LinkedList<T>, D::Error>where D: Deserializer<'de>,

impl<'de, T, U, S> DeserializeAs<'de, IndexSet<T, S>> for IndexSet<U, S>where U: DeserializeAs<'de, T>, T: Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>(deserializer: D) -> Result<IndexSet<T, S>, D::Error>where D: Deserializer<'de>,

fn deserialize_as<D>( deserializer: D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs, S> DeserializeAs<'de, HashSet<(K, V), S>> for BTreeMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>, (K, V): Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>(deserializer: D) -> Result<HashSet<(K, V), S>, D::Error>where D: Deserializer<'de>,

fn deserialize_as<D>( deserializer: D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), D::Error>where D: Deserializer<'de>,

fn deserialize_as<D>( deserializer: D ) -> Result<(T0, T1, T2, T3, T4, T5, T6), D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs, S> DeserializeAs<'de, HashMap<K, V, S>> for Vec<(KAs, VAs)>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>, K: Eq + Hash, S: BuildHasher + Default,

fn deserialize_as<D>(deserializer: D) -> Result<HashMap<K, V, S>, D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, BTreeSet<(K, V), Global>> for HashMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>, (K, V): Ord,

fn deserialize_as<D>(deserializer: D) -> Result<BTreeSet<(K, V)>, D::Error>where D: Deserializer<'de>,

impl<'de, T, TAs, E, EAs> DeserializeAs<'de, Result<T, E>> for Result<TAs, EAs>where TAs: DeserializeAs<'de, T>, EAs: DeserializeAs<'de, E>,

fn deserialize_as<D>(deserializer: D) -> Result<Result<T, E>, D::Error>where D: Deserializer<'de>,

impl<'de, K, KAs, V, VAs> DeserializeAs<'de, Option<(K, V)>> for HashMap<KAs, VAs>where KAs: DeserializeAs<'de, K>, VAs: DeserializeAs<'de, V>,

fn deserialize_as<D>(deserializer: D) -> Result<Option<(K, V)>, D::Error>where D: Deserializer<'de>,

impl<'de, T, U> DeserializeAs<'de, Cell<T>> for Cell<U>where U: DeserializeAs<'de, T>,

Differences to `Deserialize`