[−][src]Trait serde_with::SerializeAs
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 the 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.serialize_str(&source.to_string()) } }
Required methods
pub fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
Serialize this value into the given Serde serializer.
Implementations on Foreign Types
impl SerializeAs<NaiveDateTime> for DateTime<Utc>
[src]
pub fn serialize_as<S>(
source: &NaiveDateTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &NaiveDateTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<'a, T, U> SerializeAs<&'a T> for &'a U where
U: SerializeAs<T>,
T: ?Sized,
U: ?Sized,
[src]
U: SerializeAs<T>,
T: ?Sized,
U: ?Sized,
pub fn serialize_as<S>(source: &&'a T, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, U> SerializeAs<Box<T, Global>> for Box<U> where
U: SerializeAs<T>,
[src]
U: SerializeAs<T>,
pub fn serialize_as<S>(
source: &Box<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Box<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, U> SerializeAs<Option<T>> for Option<U> where
U: SerializeAs<T>,
[src]
U: SerializeAs<T>,
pub fn serialize_as<S>(
source: &Option<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Option<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T: ?Sized, U> SerializeAs<BinaryHeap<T>> for BinaryHeap<U> where
U: SerializeAs<T>,
T: Ord + Sized,
[src]
U: SerializeAs<T>,
T: Ord + Sized,
pub fn serialize_as<S>(
source: &BinaryHeap<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &BinaryHeap<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>,
[src]
U: SerializeAs<T>,
pub fn serialize_as<S>(
source: &Box<[T]>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Box<[T]>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T: ?Sized, U> SerializeAs<BTreeSet<T>> for BTreeSet<U> where
U: SerializeAs<T>,
T: Ord + Sized,
[src]
U: SerializeAs<T>,
T: Ord + Sized,
pub fn serialize_as<S>(
source: &BTreeSet<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &BTreeSet<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T: ?Sized, U, H: ?Sized> SerializeAs<HashSet<T, H>> for HashSet<U, H> where
U: SerializeAs<T>,
T: Eq + Hash + Sized,
H: BuildHasher + Sized,
[src]
U: SerializeAs<T>,
T: Eq + Hash + Sized,
H: BuildHasher + Sized,
pub fn serialize_as<S>(
source: &HashSet<T, H>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &HashSet<T, H>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, U> SerializeAs<LinkedList<T>> for LinkedList<U> where
U: SerializeAs<T>,
[src]
U: SerializeAs<T>,
pub fn serialize_as<S>(
source: &LinkedList<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &LinkedList<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, U> SerializeAs<[T]> for [U] where
U: SerializeAs<T>,
[src]
U: SerializeAs<T>,
pub fn serialize_as<S>(source: &[T], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, U> SerializeAs<Vec<T, Global>> for Vec<U> where
U: SerializeAs<T>,
[src]
U: SerializeAs<T>,
pub fn serialize_as<S>(
source: &Vec<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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>,
[src]
U: SerializeAs<T>,
pub fn serialize_as<S>(
source: &VecDeque<T>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &VecDeque<T>,
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>,
K: Ord,
[src]
KU: SerializeAs<K>,
VU: SerializeAs<V>,
K: Ord,
pub fn serialize_as<S>(
source: &BTreeMap<K, V>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &BTreeMap<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>,
K: Eq + Hash,
H: BuildHasher,
[src]
KU: SerializeAs<K>,
VU: SerializeAs<V>,
K: Eq + Hash,
H: BuildHasher,
pub fn serialize_as<S>(
source: &HashMap<K, V, H>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &HashMap<K, V, H>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T0, As0> SerializeAs<(T0,)> for (As0,) where
As0: SerializeAs<T0>,
[src]
As0: SerializeAs<T0>,
pub fn serialize_as<S>(tuple: &(T0,), serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T0, As0, T1, As1> SerializeAs<(T0, T1)> for (As0, As1) where
As0: SerializeAs<T0>,
As1: SerializeAs<T1>,
[src]
As0: SerializeAs<T0>,
As1: SerializeAs<T1>,
pub fn serialize_as<S>(
tuple: &(T0, T1),
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
tuple: &(T0, T1),
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>,
[src]
As0: SerializeAs<T0>,
As1: SerializeAs<T1>,
As2: SerializeAs<T2>,
pub fn serialize_as<S>(
tuple: &(T0, T1, T2),
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
tuple: &(T0, T1, T2),
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>,
[src]
As0: SerializeAs<T0>,
As1: SerializeAs<T1>,
As2: SerializeAs<T2>,
As3: SerializeAs<T3>,
pub fn serialize_as<S>(
tuple: &(T0, T1, T2, T3),
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
tuple: &(T0, T1, T2, T3),
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>,
[src]
As0: SerializeAs<T0>,
As1: SerializeAs<T1>,
As2: SerializeAs<T2>,
As3: SerializeAs<T3>,
As4: SerializeAs<T4>,
pub fn serialize_as<S>(
tuple: &(T0, T1, T2, T3, T4),
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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, 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>,
[src]
As0: SerializeAs<T0>,
As1: SerializeAs<T1>,
As2: SerializeAs<T2>,
As3: SerializeAs<T3>,
As4: SerializeAs<T4>,
As5: SerializeAs<T5>,
pub fn serialize_as<S>(
tuple: &(T0, T1, T2, T3, T4, T5),
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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, 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>,
[src]
As0: SerializeAs<T0>,
As1: SerializeAs<T1>,
As2: SerializeAs<T2>,
As3: SerializeAs<T3>,
As4: SerializeAs<T4>,
As5: SerializeAs<T5>,
As6: SerializeAs<T6>,
pub fn serialize_as<S>(
tuple: &(T0, T1, T2, T3, T4, T5, T6),
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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, 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>,
[src]
As0: SerializeAs<T0>,
As1: SerializeAs<T1>,
As2: SerializeAs<T2>,
As3: SerializeAs<T3>,
As4: SerializeAs<T4>,
As5: SerializeAs<T5>,
As6: SerializeAs<T6>,
As7: SerializeAs<T7>,
pub fn serialize_as<S>(
tuple: &(T0, T1, T2, T3, T4, T5, T6, T7),
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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, 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>,
[src]
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>,
pub fn serialize_as<S>(
tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8),
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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, 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>,
[src]
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>,
pub 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,
[src]
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, 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>,
[src]
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>,
pub 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,
[src]
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, 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>,
[src]
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>,
pub 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,
[src]
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, 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>,
[src]
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>,
pub 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,
[src]
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, 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>,
[src]
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>,
pub 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,
[src]
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, 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>,
[src]
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>,
pub 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,
[src]
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, 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>,
[src]
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>,
pub 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,
[src]
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> SerializeAs<[T; 0]> for [As; 0] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(array: &[T; 0], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, As> SerializeAs<[T; 1]> for [As; 1] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(array: &[T; 1], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, As> SerializeAs<[T; 2]> for [As; 2] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(array: &[T; 2], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, As> SerializeAs<[T; 3]> for [As; 3] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(array: &[T; 3], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, As> SerializeAs<[T; 4]> for [As; 4] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(array: &[T; 4], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, As> SerializeAs<[T; 5]> for [As; 5] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(array: &[T; 5], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, As> SerializeAs<[T; 6]> for [As; 6] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(array: &[T; 6], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, As> SerializeAs<[T; 7]> for [As; 7] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(array: &[T; 7], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, As> SerializeAs<[T; 8]> for [As; 8] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(array: &[T; 8], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, As> SerializeAs<[T; 9]> for [As; 9] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(array: &[T; 9], serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, As> SerializeAs<[T; 10]> for [As; 10] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 10],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 10],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 11]> for [As; 11] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 11],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 11],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 12]> for [As; 12] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 12],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 12],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 13]> for [As; 13] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 13],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 13],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 14]> for [As; 14] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 14],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 14],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 15]> for [As; 15] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 15],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 15],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 16]> for [As; 16] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 16],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 16],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 17]> for [As; 17] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 17],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 17],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 18]> for [As; 18] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 18],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 18],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 19]> for [As; 19] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 19],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 19],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 20]> for [As; 20] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 20],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 20],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 21]> for [As; 21] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 21],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 21],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 22]> for [As; 22] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 22],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 22],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 23]> for [As; 23] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 23],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 23],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 24]> for [As; 24] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 24],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 24],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 25]> for [As; 25] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 25],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 25],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 26]> for [As; 26] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 26],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 26],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 27]> for [As; 27] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 27],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 27],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 28]> for [As; 28] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 28],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 28],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 29]> for [As; 29] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 29],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 29],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 30]> for [As; 30] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 30],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 30],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 31]> for [As; 31] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 31],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 31],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T, As> SerializeAs<[T; 32]> for [As; 32] where
As: SerializeAs<T>,
[src]
As: SerializeAs<T>,
pub fn serialize_as<S>(
array: &[T; 32],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
array: &[T; 32],
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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &BTreeMap<K, V>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &BTreeMap<K, V>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<HashMap<K, V, RandomState>> for Vec<(KAs, VAs)> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &HashMap<K, V>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &HashMap<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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &BinaryHeap<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &BinaryHeap<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &BinaryHeap<(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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &BTreeSet<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &BTreeSet<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &BTreeSet<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<HashSet<(K, V), RandomState>> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &HashSet<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &HashSet<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<HashSet<(K, V), RandomState>> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &HashSet<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &HashSet<(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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &LinkedList<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &LinkedList<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &Option<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &Option<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Option<(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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &Vec<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Vec<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<Vec<(K, V), Global>> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &Vec<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &VecDeque<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
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>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &VecDeque<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &VecDeque<(K, V)>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 0]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 0],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 0],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 0]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 0],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 0],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 1]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 1],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 1],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 1]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 1],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 1],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 2]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 2],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 2],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 2]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 2],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 2],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 3]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 3],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 3],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 3]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 3],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 3],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 4]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 4],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 4],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 4]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 4],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 4],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 5]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 5],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 5],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 5]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 5],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 5],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 6]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 6],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 6],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 6]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 6],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 6],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 7]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 7],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 7],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 7]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 7],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 7],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 8]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 8],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 8],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 8]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 8],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 8],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 9]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 9],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 9],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 9]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 9],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 9],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 10]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 10],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 10],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 10]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 10],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 10],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 11]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 11],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 11],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 11]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 11],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 11],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 12]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 12],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 12],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 12]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 12],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 12],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 13]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 13],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 13],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 13]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 13],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 13],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 14]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 14],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 14],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 14]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 14],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 14],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 15]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 15],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 15],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 15]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 15],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 15],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 16]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 16],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 16],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 16]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 16],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 16],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 17]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 17],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 17],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 17]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 17],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 17],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 18]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 18],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 18],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 18]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 18],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 18],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 19]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 19],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 19],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 19]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 19],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 19],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 20]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 20],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 20],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 20]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 20],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 20],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 21]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 21],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 21],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 21]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 21],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 21],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 22]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 22],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 22],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 22]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 22],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 22],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 23]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 23],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 23],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 23]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 23],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 23],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 24]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 24],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 24],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 24]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 24],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 24],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 25]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 25],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 25],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 25]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 25],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 25],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 26]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 26],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 26],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 26]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 26],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 26],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 27]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 27],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 27],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 27]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 27],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 27],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 28]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 28],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 28],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 28]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 28],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 28],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 29]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 29],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 29],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 29]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 29],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 29],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 30]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 30],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 30],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 30]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 30],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 30],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 31]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 31],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 31],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 31]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 31],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 31],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 32]> for BTreeMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 32],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 32],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<K, KAs, V, VAs> SerializeAs<[(K, V); 32]> for HashMap<KAs, VAs> where
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
[src]
KAs: SerializeAs<K>,
VAs: SerializeAs<V>,
pub fn serialize_as<S>(
source: &[(K, V); 32],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &[(K, V); 32],
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
Implementors
impl SerializeAs<Vec<u8, Global>> for BytesOrString
[src]
pub fn serialize_as<S>(
source: &Vec<u8>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Vec<u8>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<AsRefStr> SerializeAs<Option<AsRefStr>> for NoneAsEmptyString where
AsRefStr: AsRef<str>,
[src]
AsRefStr: AsRef<str>,
pub fn serialize_as<S>(
source: &Option<AsRefStr>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Option<AsRefStr>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<SEPARATOR, I, T> SerializeAs<I> for StringWithSeparator<SEPARATOR, T> where
SEPARATOR: Separator,
&'a I: IntoIterator<Item = &'a T>,
T: ToString,
[src]
SEPARATOR: Separator,
&'a I: IntoIterator<Item = &'a T>,
T: ToString,
pub fn serialize_as<S>(source: &I, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSeconds<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSeconds<u64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSeconds<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSecondsWithFrac<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationMicroSecondsWithFrac<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSeconds<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSeconds<u64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSeconds<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSecondsWithFrac<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationMilliSecondsWithFrac<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSeconds<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSeconds<u64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSeconds<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSecondsWithFrac<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationNanoSecondsWithFrac<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<u64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMicroSeconds<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMicroSeconds<i64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMicroSeconds<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMicroSecondsWithFrac<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMicroSecondsWithFrac<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMilliSeconds<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMilliSeconds<i64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMilliSeconds<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMilliSecondsWithFrac<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampMilliSecondsWithFrac<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampNanoSeconds<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampNanoSeconds<i64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampNanoSeconds<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampNanoSecondsWithFrac<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampNanoSecondsWithFrac<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<i64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSecondsWithFrac<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSecondsWithFrac<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &SystemTime,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<i64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<f64, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<String, STRICTNESS> where
STRICTNESS: Strictness,
[src]
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &Duration,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<T> SerializeAs<T> for Hex<Lowercase> where
T: AsRef<[u8]>,
[src]
T: AsRef<[u8]>,
pub fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T> SerializeAs<T> for Hex<Uppercase> where
T: AsRef<[u8]>,
[src]
T: AsRef<[u8]>,
pub fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T> SerializeAs<T> for JsonString where
T: Serialize,
[src]
T: Serialize,
pub fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T> SerializeAs<T> for DisplayFromStr where
T: Display,
[src]
T: Display,
pub fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, TAs> SerializeAs<T> for DefaultOnError<TAs> where
TAs: SerializeAs<T>,
[src]
TAs: SerializeAs<T>,
pub fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T, U> SerializeAs<T> for DefaultOnNull<U> where
U: SerializeAs<T>,
[src]
U: SerializeAs<T>,
pub fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<T: ?Sized> SerializeAs<T> for Same where
T: Serialize,
[src]
T: Serialize,
pub fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSeconds<f64, STRICTNESS> where
TZ: TimeZone,
STRICTNESS: Strictness,
[src]
TZ: TimeZone,
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSeconds<i64, STRICTNESS> where
TZ: TimeZone,
STRICTNESS: Strictness,
[src]
TZ: TimeZone,
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSeconds<String, STRICTNESS> where
TZ: TimeZone,
STRICTNESS: Strictness,
[src]
TZ: TimeZone,
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSecondsWithFrac<f64, STRICTNESS> where
TZ: TimeZone,
STRICTNESS: Strictness,
[src]
TZ: TimeZone,
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSecondsWithFrac<String, STRICTNESS> where
TZ: TimeZone,
STRICTNESS: Strictness,
[src]
TZ: TimeZone,
STRICTNESS: Strictness,
pub fn serialize_as<S>(
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
source: &DateTime<TZ>,
serializer: S
) -> Result<S::Ok, S::Error> where
S: Serializer,