Trait serde_with::ser::SerializeAs

source ·

pub trait SerializeAs<T: ?Sized> {
    // Required method
    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
       where S: Serializer;
}

Expand description

A data structure that can be serialized into any data format supported by Serde, analogue to Serialize.

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

Differences to `Serialize`

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 serialize into a different serde data type. For example, DisplayFromStr uses the Display trait to serialize a String and DurationSeconds converts a Duration into either String or integer values.

This code shows how to implement Serialize for Box:

impl<T> Serialize for Box<T>
where
    T: Serialize,
{
    #[inline]
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        (**self).serialize(serializer)
    }
}

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

impl<T, U> SerializeAs<Box<T>> for Box<U>
where
    U: SerializeAs<T>,
{
    fn serialize_as<S>(source: &Box<T>, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
    }
}

It uses two type parameters, T and U instead of only one and performs the serialization step using the SerializeAsWrap type. The T type is the on the Rust side before serialization, whereas the U type determines how the value will be serialized. These two changes are usually enough to make a container type implement SerializeAs.

SerializeAsWrap is a piece of glue code which turns SerializeAs into a serde compatible datatype, by converting all calls to serialize into serialize_as. This allows us to implement SerializeAs 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 SerializeAs trait.

Implementing a converter Type

This shows a simplified implementation for DisplayFromStr.

struct DisplayFromStr;

impl<T> SerializeAs<T> for DisplayFromStr
where
    T: Display,
{
    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.collect_str(&source)
    }
}

Required Methods§

source

fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

Trait serde_with::ser::SerializeAs

Differences to Serialize

Implementing a converter Type

Required Methods§

fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Implementations on Foreign Types§

impl<K, KAs, V, VAs> SerializeAs<[(K, V)]> for HashMap<KAs, VAs>where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

fn serialize_as<S>(source: &[(K, V)], serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

impl<K, KAs, V, VAs> SerializeAs<Vec<(K, V), Global>> for BTreeMap<KAs, VAs>where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

fn serialize_as<S>( source: &Vec<(K, V)>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T0, As0> SerializeAs<(T0,)> for (As0,)where As0: SerializeAs<T0>,

fn serialize_as<S>(tuple: &(T0,), serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T0, As0, T1, As1, T2, As2> SerializeAs<(T0, T1, T2)> for (As0, As1, As2)where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>,

fn serialize_as<S>( tuple: &(T0, T1, T2), serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<'a, T, U> SerializeAs<&'a mut T> for &'a mut Uwhere U: SerializeAs<T> + ?Sized, T: ?Sized,

fn serialize_as<S>(source: &&'a mut T, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U> SerializeAs<Option<T>> for Option<U>where U: SerializeAs<T>,

fn serialize_as<S>(source: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

fn serialize_as<S>( tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<K, KU, V, VU, H> SerializeAs<IndexMap<K, V, H>> for IndexMap<KU, VU, H>where KU: SerializeAs<K>, VU: SerializeAs<V>, H: ?Sized + Sized,

fn serialize_as<S>( source: &IndexMap<K, V, H>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<K, KAs, V, VAs> SerializeAs<Option<(K, V)>> for BTreeMap<KAs, VAs>where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

fn serialize_as<S>( source: &Option<(K, V)>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5> SerializeAs<(T0, T1, T2, T3, T4, T5)> for (As0, As1, As2, As3, As4, As5)where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>,

fn serialize_as<S>( tuple: &(T0, T1, T2, T3, T4, T5), serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<K, KAs, V, VAs> SerializeAs<BTreeSet<(K, V), Global>> for BTreeMap<KAs, VAs>where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

fn serialize_as<S>( source: &BTreeSet<(K, V)>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U> SerializeAs<RefCell<T>> for RefCell<U>where U: SerializeAs<T>,

fn serialize_as<S>( source: &RefCell<T>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<K, KAs, V, VAs, H> SerializeAs<IndexSet<(K, V), H>> for BTreeMap<KAs, VAs>where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized,

fn serialize_as<S>( source: &IndexSet<(K, V), H>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<K, KAs, V, VAs> SerializeAs<VecDeque<(K, V), Global>> for HashMap<KAs, VAs>where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

fn serialize_as<S>( source: &VecDeque<(K, V)>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U> SerializeAs<LinkedList<T, Global>> for LinkedList<U>where U: SerializeAs<T>,

fn serialize_as<S>( source: &LinkedList<T>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

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

fn serialize_as<S>( source: &[(K, V); N], serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

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

fn serialize_as<S>( tuple: &(T0, T1, T2, T3), serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

fn serialize_as<S>( tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<K, KAs, V, VAs> SerializeAs<BTreeMap<K, V, Global>> for Vec<(KAs, VAs)>where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

fn serialize_as<S>( source: &BTreeMap<K, V>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

fn serialize_as<S>( tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, As, const N: usize> SerializeAs<[T; N]> for [As; N]where As: SerializeAs<T>,

fn serialize_as<S>(array: &[T; N], serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

impl<K, KAs, V, VAs> SerializeAs<[(K, V)]> for BTreeMap<KAs, VAs>where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

fn serialize_as<S>(source: &[(K, V)], serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

impl<const CONFIG: EncodedConfig> SerializeAs<OffsetDateTime> for Iso8601<CONFIG>

fn serialize_as<S>( datetime: &OffsetDateTime, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<K, KAs, V, VAs> SerializeAs<BinaryHeap<(K, V)>> for BTreeMap<KAs, VAs>where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

fn serialize_as<S>( source: &BinaryHeap<(K, V)>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

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

fn serialize_as<S>( tuple: &(T0, T1, T2, T3, T4), serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U> SerializeAs<[T]> for [U]where U: SerializeAs<T>,

fn serialize_as<S>(source: &[T], serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, TAs, E, EAs> SerializeAs<Result<T, E>> for Result<TAs, EAs>where TAs: SerializeAs<T>, EAs: SerializeAs<E>,

fn serialize_as<S>( source: &Result<T, E>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl SerializeAs<OffsetDateTime> for Rfc3339

fn serialize_as<S>( datetime: &OffsetDateTime, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U> SerializeAs<Arc<T>> for Arc<U>where U: SerializeAs<T>,

fn serialize_as<S>(source: &Arc<T>, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U> SerializeAs<Box<[T], Global>> for Box<[U]>where U: SerializeAs<T>,

fn serialize_as<S>(source: &Box<[T]>, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

impl<K, KAs, V, VAs, H> SerializeAs<IndexMap<K, V, H>> for Vec<(KAs, VAs)>where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized,

fn serialize_as<S>( source: &IndexMap<K, V, H>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

fn serialize_as<S>( tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8), serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U> SerializeAs<Mutex<T>> for Mutex<U>where U: SerializeAs<T>,

fn serialize_as<S>(source: &Mutex<T>, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U> SerializeAs<Weak<T>> for RcWeak<U>where U: SerializeAs<T>,

fn serialize_as<S>(source: &RcWeak<T>, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U> SerializeAs<BinaryHeap<T>> for BinaryHeap<U>where U: SerializeAs<T>,

fn serialize_as<S>( source: &BinaryHeap<T>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U, H> SerializeAs<HashSet<T, H>> for HashSet<U, H>where U: SerializeAs<T>, H: ?Sized + Sized,

fn serialize_as<S>( source: &HashSet<T, H>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T0, As0, T1, As1> SerializeAs<(T0, T1)> for (As0, As1)where As0: SerializeAs<T0>, As1: SerializeAs<T1>,

fn serialize_as<S>(tuple: &(T0, T1), serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

fn serialize_as<S>( tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<T, U> SerializeAs<Weak<T>> for ArcWeak<U>where U: SerializeAs<T>,

fn serialize_as<S>( source: &ArcWeak<T>, serializer: S ) -> Result<S::Ok, S::Error>where S: Serializer,

impl<'a, T, U> SerializeAs<&'a T> for &'a Uwhere U: SerializeAs<T> + ?Sized, T: ?Sized,

Differences to `Serialize`