Trait SerializeAs 

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

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 type 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

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

where S: Serializer,

Serialize this value into the given Serde serializer.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'a, T, U> SerializeAs<&'a T> for &'a U

where U: SerializeAs<T> + ?Sized, T: ?Sized,

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

where S: Serializer,

impl<'a, T, U> SerializeAs<&'a mut T> for &'a mut U

where 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<'a, T, U> SerializeAs<Pin<&'a T>> for Pin<&'a U>

where U: SerializeAs<T>,

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

where S: Serializer,

impl<'a, T, U> SerializeAs<Pin<&'a mut T>> for Pin<&'a mut U>

where U: SerializeAs<T>,

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

where S: Serializer,

impl<Idx, IdxAs> SerializeAs<Range<Idx>> for Range<IdxAs>

where IdxAs: SerializeAs<Idx>,

fn serialize_as<S>(value: &Range<Idx>, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

impl<Idx, IdxAs> SerializeAs<RangeFrom<Idx>> for RangeFrom<IdxAs>

where IdxAs: SerializeAs<Idx>,

fn serialize_as<S>( value: &RangeFrom<Idx>, serializer: S, ) -> Result<S::Ok, S::Error>

where S: Serializer,

impl<Idx, IdxAs> SerializeAs<RangeInclusive<Idx>> for RangeInclusive<IdxAs>

where IdxAs: SerializeAs<Idx>,

fn serialize_as<S>( value: &RangeInclusive<Idx>, serializer: S, ) -> Result<S::Ok, S::Error>

where S: Serializer,

impl<Idx, IdxAs> SerializeAs<RangeTo<Idx>> for RangeTo<IdxAs>

where IdxAs: SerializeAs<Idx>,

fn serialize_as<S>( value: &RangeTo<Idx>, serializer: S, ) -> Result<S::Ok, S::Error>

where S: Serializer,

impl<K, KAs, V, VAs, H> SerializeAs<HashMap<K, V, H>> for Vec<(KAs, VAs)>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized,

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

where S: Serializer,

impl<K, KAs, V, VAs, H> SerializeAs<HashSet<(K, V), H>> for BTreeMap<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized,

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

where S: Serializer,

impl<K, KAs, V, VAs, H> SerializeAs<HashSet<(K, V), H>> for HashMap<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized,

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

where S: Serializer,

impl<K, KAs, V, VAs, const N: usize> SerializeAs<[(K, V); N]> for BTreeMap<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<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<K, KAs, V, VAs> SerializeAs<BTreeMap<K, V>> 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,

impl<K, KAs, V, VAs> SerializeAs<BTreeSet<(K, V)>> 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<K, KAs, V, VAs> SerializeAs<BTreeSet<(K, V)>> for HashMap<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<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<K, KAs, V, VAs> SerializeAs<BinaryHeap<(K, V)>> for HashMap<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<K, KAs, V, VAs> SerializeAs<Box<[(K, V)]>> for BTreeMap<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

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

where S: Serializer,

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

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

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

where S: Serializer,

impl<K, KAs, V, VAs> SerializeAs<LinkedList<(K, V)>> for BTreeMap<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

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

where S: Serializer,

impl<K, KAs, V, VAs> SerializeAs<LinkedList<(K, V)>> for HashMap<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

fn serialize_as<S>( source: &LinkedList<(K, V)>, 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<K, KAs, V, VAs> SerializeAs<Option<(K, V)>> for HashMap<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<K, KAs, V, VAs> SerializeAs<Vec<(K, V)>> 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<K, KAs, V, VAs> SerializeAs<Vec<(K, V)>> for HashMap<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<K, KAs, V, VAs> SerializeAs<VecDeque<(K, V)>> for BTreeMap<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<K, KAs, V, VAs> SerializeAs<VecDeque<(K, V)>> 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<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<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, KU, V, VU, H> SerializeAs<HashMap<K, V, H>> for HashMap<KU, VU, H>

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

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

where S: Serializer,

impl<K, KU, V, VU> SerializeAs<BTreeMap<K, V>> for BTreeMap<KU, VU>

where KU: SerializeAs<K>, VU: SerializeAs<V>,

fn serialize_as<S>( source: &BTreeMap<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, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10, T11, As11, T12, As12, T13, As13, T14, As14, T15, As15> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10, As11, As12, As13, As14, As15)

where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>, As6: SerializeAs<T6>, As7: SerializeAs<T7>, As8: SerializeAs<T8>, As9: SerializeAs<T9>, As10: SerializeAs<T10>, As11: SerializeAs<T11>, As12: SerializeAs<T12>, As13: SerializeAs<T13>, As14: SerializeAs<T14>, As15: SerializeAs<T15>,

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<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10, T11, As11, T12, As12, T13, As13, T14, As14> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10, As11, As12, As13, As14)

where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>, As6: SerializeAs<T6>, As7: SerializeAs<T7>, As8: SerializeAs<T8>, As9: SerializeAs<T9>, As10: SerializeAs<T10>, As11: SerializeAs<T11>, As12: SerializeAs<T12>, As13: SerializeAs<T13>, As14: SerializeAs<T14>,

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<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10, T11, As11, T12, As12, T13, As13> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10, As11, As12, As13)

where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>, As6: SerializeAs<T6>, As7: SerializeAs<T7>, As8: SerializeAs<T8>, As9: SerializeAs<T9>, As10: SerializeAs<T10>, As11: SerializeAs<T11>, As12: SerializeAs<T12>, As13: SerializeAs<T13>,

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

where S: Serializer,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10, T11, As11, T12, As12> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10, As11, As12)

where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>, As6: SerializeAs<T6>, As7: SerializeAs<T7>, As8: SerializeAs<T8>, As9: SerializeAs<T9>, As10: SerializeAs<T10>, As11: SerializeAs<T11>, As12: SerializeAs<T12>,

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<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10, T11, As11> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10, As11)

where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>, As6: SerializeAs<T6>, As7: SerializeAs<T7>, As8: SerializeAs<T8>, As9: SerializeAs<T9>, As10: SerializeAs<T10>, As11: SerializeAs<T11>,

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<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10)

where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>, As6: SerializeAs<T6>, As7: SerializeAs<T7>, As8: SerializeAs<T8>, As9: SerializeAs<T9>, As10: SerializeAs<T10>,

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

where S: Serializer,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9)

where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>, As6: SerializeAs<T6>, As7: SerializeAs<T7>, As8: SerializeAs<T8>, As9: SerializeAs<T9>,

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

where S: Serializer,

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8)

where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>, As6: SerializeAs<T6>, As7: SerializeAs<T7>, As8: SerializeAs<T8>,

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<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7)> for (As0, As1, As2, As3, As4, As5, As6, As7)

where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>, As6: SerializeAs<T6>, As7: SerializeAs<T7>,

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

where S: Serializer,

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

where As0: SerializeAs<T0>, As1: SerializeAs<T1>, As2: SerializeAs<T2>, As3: SerializeAs<T3>, As4: SerializeAs<T4>, As5: SerializeAs<T5>, As6: SerializeAs<T6>,

fn serialize_as<S>( tuple: &(T0, T1, T2, T3, T4, T5, T6), 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<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<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,

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<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,

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<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<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<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<T, U> SerializeAs<Arc<T>> for Arc<U>

where U: SerializeAs<T>,

Available on target_has_atomic=ptr and crate feature alloc only.

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

where S: Serializer,

impl<T, U> SerializeAs<BTreeSet<T>> for BTreeSet<U>

where U: SerializeAs<T>,

fn serialize_as<S>( source: &BTreeSet<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> SerializeAs<Bound<T>> for Bound<U>

where U: SerializeAs<T>, T: Sized,

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

where S: Serializer,

impl<T, U> SerializeAs<Box<T>> for Box<U>

where U: SerializeAs<T>,

Available on crate feature alloc only.

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

where S: Serializer,

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,

impl<T, U> SerializeAs<Cell<T>> for Cell<U>

where U: SerializeAs<T>, T: Copy,

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

where S: Serializer,

impl<T, U> SerializeAs<LinkedList<T>> 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<T, U> SerializeAs<Mutex<T>> for Mutex<U>

where U: SerializeAs<T>,

Available on crate feature std only.

fn serialize_as<S>(source: &Mutex<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,

impl<T, U> SerializeAs<Pin<Arc<T>>> for Pin<Arc<U>>

where U: SerializeAs<T>,

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

where S: Serializer,

impl<T, U> SerializeAs<Pin<Box<T>>> for Pin<Box<U>>

where U: SerializeAs<T>,

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

where S: Serializer,

impl<T, U> SerializeAs<Pin<Rc<T>>> for Pin<Rc<U>>

where U: SerializeAs<T>,

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

where S: Serializer,

impl<T, U> SerializeAs<Rc<T>> for Rc<U>

where U: SerializeAs<T>,

Available on crate feature alloc only.

fn serialize_as<S>(source: &Rc<T>, 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<T, U> SerializeAs<RwLock<T>> for RwLock<U>

where U: SerializeAs<T>,

Available on crate feature std only.

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

where S: Serializer,

impl<T, U> SerializeAs<Vec<T>> for Vec<U>

where U: SerializeAs<T>,

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

where S: Serializer,

impl<T, U> SerializeAs<VecDeque<T>> for VecDeque<U>

where U: SerializeAs<T>,

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

where S: Serializer,

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

where U: SerializeAs<T>,

Available on target_has_atomic=ptr and crate feature alloc only.

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

where S: Serializer,

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

where U: SerializeAs<T>,

Available on crate feature alloc only.

fn serialize_as<S>(source: &RcWeak<T>, 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,

Implementors

impl SerializeAs<&[u8]> for Bytes

impl SerializeAs<Box<[u8]>> for Bytes

Available on crate feature alloc only.

impl SerializeAs<Vec<u8>> for Bytes

Available on crate feature alloc only.

impl SerializeAs<Vec<u8>> for BytesOrString

Available on crate feature alloc only.

impl<'a, const N: usize> SerializeAs<Cow<'a, [u8; N]>> for BorrowCow

Available on crate feature alloc only.

impl<'a, const N: usize> SerializeAs<Cow<'a, [u8; N]>> for Bytes

Available on crate feature alloc only.

impl<'a> SerializeAs<Cow<'a, [u8]>> for BorrowCow

Available on crate feature alloc only.

impl<'a> SerializeAs<Cow<'a, [u8]>> for Bytes

Available on crate feature alloc only.

impl<'a> SerializeAs<Cow<'a, str>> for BorrowCow

Available on crate feature alloc only.

impl<K, KAs, V, VAs, H> SerializeAs<HashMap<K, V, H>> for MapFirstKeyWins<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized,

impl<K, KAs, V, VAs, H> SerializeAs<HashMap<K, V, H>> for MapPreventDuplicates<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized,

impl<K, KAs, V, VAs, H> SerializeAs<HashMap<K, V, H>> for Seq<(KAs, VAs)>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized,

impl<K, KAs, V, VAs, H> SerializeAs<HashSet<(K, V), H>> for Map<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized,

impl<K, KAs, V, VAs, I, H> SerializeAs<HashMap<K, V, H>> for MapSkipError<KAs, VAs, I>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized,

impl<K, KAs, V, VAs, I> SerializeAs<BTreeMap<K, V>> for MapSkipError<KAs, VAs, I>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

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

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<BTreeMap<K, V>> for MapFirstKeyWins<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<BTreeMap<K, V>> for MapPreventDuplicates<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<BTreeMap<K, V>> for Seq<(KAs, VAs)>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<BTreeSet<(K, V)>> for Map<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<BinaryHeap<(K, V)>> for Map<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<Box<[(K, V)]>> for Map<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<LinkedList<(K, V)>> for Map<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<Option<(K, V)>> for Map<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<Vec<(K, V)>> for Map<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<VecDeque<(K, V)>> for Map<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<K, KAs, V, VAs> SerializeAs<[(K, V)]> for Map<KAs, VAs>

where KAs: SerializeAs<K>, VAs: SerializeAs<V>,

impl<SEPARATOR, I, T> SerializeAs<I> for StringWithSeparator<SEPARATOR, T>

where SEPARATOR: Separator, for<'x> &'x I: IntoIterator<Item = &'x T>, T: Display,

impl<STRICTNESS: Strictness> SerializeAs<bool> for BoolFromInt<STRICTNESS>

impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSeconds<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSeconds<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSeconds<u64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSecondsWithFrac<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSecondsWithFrac<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSeconds<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSeconds<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSeconds<u64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSecondsWithFrac<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSecondsWithFrac<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSeconds<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSeconds<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSeconds<u64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSecondsWithFrac<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSecondsWithFrac<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<u64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMicroSeconds<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMicroSeconds<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMicroSeconds<i64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMicroSecondsWithFrac<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMicroSecondsWithFrac<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMilliSeconds<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMilliSeconds<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMilliSeconds<i64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMilliSecondsWithFrac<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMilliSecondsWithFrac<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampNanoSeconds<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampNanoSeconds<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampNanoSeconds<i64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampNanoSecondsWithFrac<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampNanoSecondsWithFrac<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<i64, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSecondsWithFrac<String, STRICTNESS>

where STRICTNESS: Strictness,

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSecondsWithFrac<f64, STRICTNESS>

where STRICTNESS: Strictness,

impl<T, H, F> SerializeAs<T> for IfIsHumanReadable<H, F>

where T: ?Sized, H: SerializeAs<T>, F: SerializeAs<T>,

impl<T, TAs1, TAs2, TAs3, TAs4> SerializeAs<T> for PickFirst<(TAs1, TAs2, TAs3, TAs4)>

where TAs1: SerializeAs<T>,

Available on crate feature alloc only.

impl<T, TAs1, TAs2, TAs3> SerializeAs<T> for PickFirst<(TAs1, TAs2, TAs3)>

where TAs1: SerializeAs<T>,

Available on crate feature alloc only.

impl<T, TAs1, TAs2> SerializeAs<T> for PickFirst<(TAs1, TAs2)>

where TAs1: SerializeAs<T>,

Available on crate feature alloc only.

impl<T, TAs1> SerializeAs<T> for PickFirst<(TAs1,)>

where TAs1: SerializeAs<T>,

Available on crate feature alloc only.

impl<T, TAs, H> SerializeAs<HashSet<T, H>> for SetLastValueWins<TAs>

where TAs: SerializeAs<T>, H: ?Sized + Sized,

impl<T, TAs, H> SerializeAs<HashSet<T, H>> for SetPreventDuplicates<TAs>

where TAs: SerializeAs<T>, H: ?Sized + Sized,

impl<T, TAs> SerializeAs<BTreeSet<T>> for SetLastValueWins<TAs>

where TAs: SerializeAs<T>,

impl<T, TAs> SerializeAs<BTreeSet<T>> for SetPreventDuplicates<TAs>

where TAs: SerializeAs<T>,

impl<T, TAs> SerializeAs<T> for DefaultOnError<TAs>

where TAs: SerializeAs<T>,

Available on crate feature alloc only.

impl<T, TAs> SerializeAs<Vec<T>> for KeyValueMap<TAs>

where TAs: SerializeAs<T>,

impl<T, U, H> SerializeAs<HashSet<T, H>> for OneOrMany<U, PreferMany>

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

impl<T, U, H> SerializeAs<HashSet<T, H>> for OneOrMany<U, PreferOne>

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

impl<T, U, I> SerializeAs<Vec<T>> for VecSkipError<U, I>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<BTreeSet<T>> for OneOrMany<U, PreferMany>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<BTreeSet<T>> for OneOrMany<U, PreferOne>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<BinaryHeap<T>> for OneOrMany<U, PreferMany>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<BinaryHeap<T>> for OneOrMany<U, PreferOne>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<Box<[T]>> for OneOrMany<U, PreferMany>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<Box<[T]>> for OneOrMany<U, PreferOne>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<LinkedList<T>> for OneOrMany<U, PreferMany>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<LinkedList<T>> for OneOrMany<U, PreferOne>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<T> for DefaultOnNull<U>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<T> for FromInto<U>

where T: Into<U> + Clone, U: Serialize,

impl<T, U> SerializeAs<T> for FromIntoRef<U>

where for<'a> &'a T: Into<U>, U: Serialize,

impl<T, U> SerializeAs<T> for TryFromInto<U>

where T: TryInto<U> + Clone, <T as TryInto<U>>::Error: Display, U: Serialize,

impl<T, U> SerializeAs<T> for TryFromIntoRef<U>

where for<'a> &'a T: TryInto<U>, for<'a> <&'a T as TryInto<U>>::Error: Display, U: Serialize,

impl<T, U> SerializeAs<Vec<T>> for OneOrMany<U, PreferMany>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<Vec<T>> for OneOrMany<U, PreferOne>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<VecDeque<T>> for OneOrMany<U, PreferMany>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<VecDeque<T>> for OneOrMany<U, PreferOne>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<[T]> for OneOrMany<U, PreferMany>

where U: SerializeAs<T>,

impl<T, U> SerializeAs<[T]> for OneOrMany<U, PreferOne>

where U: SerializeAs<T>,

impl<T> SerializeAs<Option<T>> for NoneAsEmptyString

where T: Display,

impl<T> SerializeAs<T> for DisplayFromStr

where T: Display,

impl<T> SerializeAs<T> for Same

where T: Serialize + ?Sized,

impl<T> SerializeAs<Vec<T>> for EnumMap

where T: Serialize,

impl<const N: usize> SerializeAs<&[u8; N]> for Bytes

impl<const N: usize> SerializeAs<Box<[u8; N]>> for Bytes

Available on crate feature alloc only.

impl<const N: usize> SerializeAs<[u8; N]> for Bytes