serde_with/ser/
impls.rs

1pub(crate) use self::macros::*;
2use crate::{formats::Strictness, prelude::*};
3#[cfg(feature = "hashbrown_0_14")]
4use hashbrown_0_14::{HashMap as HashbrownMap014, HashSet as HashbrownSet014};
5#[cfg(feature = "hashbrown_0_15")]
6use hashbrown_0_15::{HashMap as HashbrownMap015, HashSet as HashbrownSet015};
7#[cfg(feature = "hashbrown_0_16")]
8use hashbrown_0_16::{HashMap as HashbrownMap016, HashSet as HashbrownSet016};
9#[cfg(feature = "indexmap_1")]
10use indexmap_1::{IndexMap, IndexSet};
11#[cfg(feature = "indexmap_2")]
12use indexmap_2::{IndexMap as IndexMap2, IndexSet as IndexSet2};
13#[cfg(feature = "smallvec_1")]
14use smallvec_1::SmallVec;
15
16///////////////////////////////////////////////////////////////////////////////
17// Helper macro used internally
18
19#[cfg(feature = "alloc")]
20type BoxedSlice<T> = Box<[T]>;
21type Slice<T> = [T];
22type Ref<'a, T> = &'a T;
23type RefMut<'a, T> = &'a mut T;
24
25pub(crate) mod macros {
26    // The unused_imports lint has false-positives around macros
27    // https://github.com/rust-lang/rust/issues/78894
28    #![allow(unused_imports)]
29
30    macro_rules! foreach_map {
31    ($m:ident) => {
32        #[cfg(feature = "alloc")]
33        $m!(BTreeMap<K, V>);
34        #[cfg(feature = "std")]
35        $m!(HashMap<K, V, H: Sized>);
36        #[cfg(feature = "hashbrown_0_14")]
37        $m!(HashbrownMap014<K, V, H: Sized>);
38        #[cfg(feature = "hashbrown_0_15")]
39        $m!(HashbrownMap015<K, V, H: Sized>);
40        #[cfg(feature = "hashbrown_0_16")]
41        $m!(HashbrownMap016<K, V, H: Sized>);
42        #[cfg(feature = "indexmap_1")]
43        $m!(IndexMap<K, V, H: Sized>);
44        #[cfg(feature = "indexmap_2")]
45        $m!(IndexMap2<K, V, H: Sized>);
46    };
47}
48
49    macro_rules! foreach_set {
50    ($m:ident, $T:tt) => {
51        #[cfg(feature = "alloc")]
52        $m!(BTreeSet<$T>);
53        #[cfg(feature = "std")]
54        $m!(HashSet<$T, H: Sized>);
55        #[cfg(feature = "hashbrown_0_14")]
56        $m!(HashbrownSet014<$T, H: Sized>);
57        #[cfg(feature = "hashbrown_0_15")]
58        $m!(HashbrownSet015<$T, H: Sized>);
59        #[cfg(feature = "hashbrown_0_16")]
60        $m!(HashbrownSet016<$T, H: Sized>);
61        #[cfg(feature = "indexmap_1")]
62        $m!(IndexSet<$T, H: Sized>);
63        #[cfg(feature = "indexmap_2")]
64        $m!(IndexSet2<$T, H: Sized>);
65    };
66    ($m:ident) => {
67        foreach_set!($m, T);
68    };
69}
70
71    macro_rules! foreach_seq {
72        ($m:ident, $T:tt) => {
73            foreach_set!($m, $T);
74
75            $m!(Slice<$T>);
76
77            #[cfg(feature = "alloc")]
78            $m!(BinaryHeap<$T>);
79            #[cfg(feature = "alloc")]
80            $m!(BoxedSlice<$T>);
81            #[cfg(feature = "alloc")]
82            $m!(LinkedList<$T>);
83            #[cfg(feature = "alloc")]
84            $m!(Vec<$T>);
85            #[cfg(feature = "alloc")]
86            $m!(VecDeque<$T>);
87        };
88        ($m:
89            ident) => {
90            foreach_seq!($m, T);
91        };
92    }
93
94    // Make the macros available to the rest of the crate
95    pub(crate) use foreach_map;
96    pub(crate) use foreach_seq;
97    pub(crate) use foreach_set;
98}
99
100///////////////////////////////////////////////////////////////////////////////
101// region: Simple Wrapper types (e.g., Box, Option)
102
103#[allow(unused_macros)]
104macro_rules! pinned_wrapper {
105    ($wrapper:ident $($lifetime:lifetime)?) => {
106        impl<$($lifetime,)? T, U> SerializeAs<Pin<$wrapper<$($lifetime,)? T>>> for Pin<$wrapper<$($lifetime,)? U>>
107        where
108            U: SerializeAs<T>,
109        {
110            fn serialize_as<S>(source: &Pin<$wrapper<$($lifetime,)? T>>, serializer: S) -> Result<S::Ok, S::Error>
111            where
112                S: Serializer,
113            {
114                SerializeAsWrap::<T, U>::new(source).serialize(serializer)
115            }
116        }
117    };
118}
119
120impl<'a, T, U> SerializeAs<&'a T> for &'a U
121where
122    U: SerializeAs<T>,
123    T: ?Sized,
124    U: ?Sized,
125{
126    fn serialize_as<S>(source: &&'a T, serializer: S) -> Result<S::Ok, S::Error>
127    where
128        S: Serializer,
129    {
130        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
131    }
132}
133
134impl<'a, T, U> SerializeAs<&'a mut T> for &'a mut U
135where
136    U: SerializeAs<T>,
137    T: ?Sized,
138    U: ?Sized,
139{
140    fn serialize_as<S>(source: &&'a mut T, serializer: S) -> Result<S::Ok, S::Error>
141    where
142        S: Serializer,
143    {
144        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
145    }
146}
147
148impl<'a, T, U> SerializeAs<Pin<Ref<'a, T>>> for Pin<Ref<'a, U>> where
    U: SerializeAs<T> {
    fn serialize_as<S>(source: &Pin<Ref<'a, T>>, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
    }
}pinned_wrapper!(Ref 'a);
149impl<'a, T, U> SerializeAs<Pin<RefMut<'a, T>>> for Pin<RefMut<'a, U>> where
    U: SerializeAs<T> {
    fn serialize_as<S>(source: &Pin<RefMut<'a, T>>, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
    }
}pinned_wrapper!(RefMut 'a);
150
151#[cfg(feature = "alloc")]
152impl<T, U> SerializeAs<Box<T>> for Box<U>
153where
154    U: SerializeAs<T>,
155{
156    fn serialize_as<S>(source: &Box<T>, serializer: S) -> Result<S::Ok, S::Error>
157    where
158        S: Serializer,
159    {
160        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
161    }
162}
163
164#[cfg(feature = "alloc")]
165impl<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 {
        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
    }
}pinned_wrapper!(Box);
166
167impl<T, U> SerializeAs<Option<T>> for Option<U>
168where
169    U: SerializeAs<T>,
170{
171    fn serialize_as<S>(source: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
172    where
173        S: Serializer,
174    {
175        match *source {
176            Some(ref value) => serializer.serialize_some(&SerializeAsWrap::<T, U>::new(value)),
177            None => serializer.serialize_none(),
178        }
179    }
180}
181
182impl<T, U> SerializeAs<Bound<T>> for Bound<U>
183where
184    U: SerializeAs<T>,
185    T: Sized,
186{
187    fn serialize_as<S>(source: &Bound<T>, serializer: S) -> Result<S::Ok, S::Error>
188    where
189        S: Serializer,
190    {
191        match source {
192            Bound::Unbounded => Bound::Unbounded,
193            Bound::Included(v) => Bound::Included(SerializeAsWrap::<T, U>::new(v)),
194            Bound::Excluded(v) => Bound::Excluded(SerializeAsWrap::<T, U>::new(v)),
195        }
196        .serialize(serializer)
197    }
198}
199
200#[cfg(feature = "alloc")]
201impl<T, U> SerializeAs<Rc<T>> for Rc<U>
202where
203    U: SerializeAs<T>,
204{
205    fn serialize_as<S>(source: &Rc<T>, serializer: S) -> Result<S::Ok, S::Error>
206    where
207        S: Serializer,
208    {
209        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
210    }
211}
212
213#[cfg(feature = "alloc")]
214impl<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 {
        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
    }
}pinned_wrapper!(Rc);
215
216#[cfg(feature = "alloc")]
217impl<T, U> SerializeAs<RcWeak<T>> for RcWeak<U>
218where
219    U: SerializeAs<T>,
220{
221    fn serialize_as<S>(source: &RcWeak<T>, serializer: S) -> Result<S::Ok, S::Error>
222    where
223        S: Serializer,
224    {
225        SerializeAsWrap::<Option<Rc<T>>, Option<Rc<U>>>::new(&source.upgrade())
226            .serialize(serializer)
227    }
228}
229
230#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
231impl<T, U> SerializeAs<Arc<T>> for Arc<U>
232where
233    U: SerializeAs<T>,
234{
235    fn serialize_as<S>(source: &Arc<T>, serializer: S) -> Result<S::Ok, S::Error>
236    where
237        S: Serializer,
238    {
239        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
240    }
241}
242
243#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
244impl<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 {
        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
    }
}pinned_wrapper!(Arc);
245
246#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
247impl<T, U> SerializeAs<ArcWeak<T>> for ArcWeak<U>
248where
249    U: SerializeAs<T>,
250{
251    fn serialize_as<S>(source: &ArcWeak<T>, serializer: S) -> Result<S::Ok, S::Error>
252    where
253        S: Serializer,
254    {
255        SerializeAsWrap::<Option<Arc<T>>, Option<Arc<U>>>::new(&source.upgrade())
256            .serialize(serializer)
257    }
258}
259
260impl<T, U> SerializeAs<Cell<T>> for Cell<U>
261where
262    U: SerializeAs<T>,
263    T: Copy,
264{
265    fn serialize_as<S>(source: &Cell<T>, serializer: S) -> Result<S::Ok, S::Error>
266    where
267        S: Serializer,
268    {
269        SerializeAsWrap::<T, U>::new(&source.get()).serialize(serializer)
270    }
271}
272
273impl<T, U> SerializeAs<RefCell<T>> for RefCell<U>
274where
275    U: SerializeAs<T>,
276{
277    fn serialize_as<S>(source: &RefCell<T>, serializer: S) -> Result<S::Ok, S::Error>
278    where
279        S: Serializer,
280    {
281        match source.try_borrow() {
282            Ok(source) => SerializeAsWrap::<T, U>::new(&*source).serialize(serializer),
283            Err(_) => Err(S::Error::custom("already mutably borrowed")),
284        }
285    }
286}
287
288#[cfg(feature = "std")]
289impl<T, U> SerializeAs<Mutex<T>> for Mutex<U>
290where
291    U: SerializeAs<T>,
292{
293    fn serialize_as<S>(source: &Mutex<T>, serializer: S) -> Result<S::Ok, S::Error>
294    where
295        S: Serializer,
296    {
297        match source.lock() {
298            Ok(source) => SerializeAsWrap::<T, U>::new(&*source).serialize(serializer),
299            Err(_) => Err(S::Error::custom("lock poison error while serializing")),
300        }
301    }
302}
303
304#[cfg(feature = "std")]
305impl<T, U> SerializeAs<RwLock<T>> for RwLock<U>
306where
307    U: SerializeAs<T>,
308{
309    fn serialize_as<S>(source: &RwLock<T>, serializer: S) -> Result<S::Ok, S::Error>
310    where
311        S: Serializer,
312    {
313        match source.read() {
314            Ok(source) => SerializeAsWrap::<T, U>::new(&*source).serialize(serializer),
315            Err(_) => Err(S::Error::custom("lock poison error while serializing")),
316        }
317    }
318}
319
320impl<T, TAs, E, EAs> SerializeAs<Result<T, E>> for Result<TAs, EAs>
321where
322    TAs: SerializeAs<T>,
323    EAs: SerializeAs<E>,
324{
325    fn serialize_as<S>(source: &Result<T, E>, serializer: S) -> Result<S::Ok, S::Error>
326    where
327        S: Serializer,
328    {
329        source
330            .as_ref()
331            .map(SerializeAsWrap::<T, TAs>::new)
332            .map_err(SerializeAsWrap::<E, EAs>::new)
333            .serialize(serializer)
334    }
335}
336
337impl<T, As, const N: usize> SerializeAs<[T; N]> for [As; N]
338where
339    As: SerializeAs<T>,
340{
341    fn serialize_as<S>(array: &[T; N], serializer: S) -> Result<S::Ok, S::Error>
342    where
343        S: Serializer,
344    {
345        let mut arr = serializer.serialize_tuple(N)?;
346        for elem in array {
347            arr.serialize_element(&SerializeAsWrap::<T, As>::new(elem))?;
348        }
349        arr.end()
350    }
351}
352
353// endregion
354///////////////////////////////////////////////////////////////////////////////
355// region: More complex wrappers that are not just a single value
356
357impl<Idx, IdxAs> SerializeAs<Range<Idx>> for Range<IdxAs>
358where
359    IdxAs: SerializeAs<Idx>,
360{
361    fn serialize_as<S>(value: &Range<Idx>, serializer: S) -> Result<S::Ok, S::Error>
362    where
363        S: Serializer,
364    {
365        Range {
366            start: SerializeAsWrap::<Idx, IdxAs>::new(&value.start),
367            end: SerializeAsWrap::<Idx, IdxAs>::new(&value.end),
368        }
369        .serialize(serializer)
370    }
371}
372
373impl<Idx, IdxAs> SerializeAs<RangeFrom<Idx>> for RangeFrom<IdxAs>
374where
375    IdxAs: SerializeAs<Idx>,
376{
377    fn serialize_as<S>(value: &RangeFrom<Idx>, serializer: S) -> Result<S::Ok, S::Error>
378    where
379        S: Serializer,
380    {
381        RangeFrom {
382            start: SerializeAsWrap::<Idx, IdxAs>::new(&value.start),
383        }
384        .serialize(serializer)
385    }
386}
387
388impl<Idx, IdxAs> SerializeAs<RangeInclusive<Idx>> for RangeInclusive<IdxAs>
389where
390    IdxAs: SerializeAs<Idx>,
391{
392    fn serialize_as<S>(value: &RangeInclusive<Idx>, serializer: S) -> Result<S::Ok, S::Error>
393    where
394        S: Serializer,
395    {
396        RangeInclusive::new(
397            SerializeAsWrap::<Idx, IdxAs>::new(value.start()),
398            SerializeAsWrap::<Idx, IdxAs>::new(value.end()),
399        )
400        .serialize(serializer)
401    }
402}
403
404impl<Idx, IdxAs> SerializeAs<RangeTo<Idx>> for RangeTo<IdxAs>
405where
406    IdxAs: SerializeAs<Idx>,
407{
408    fn serialize_as<S>(value: &RangeTo<Idx>, serializer: S) -> Result<S::Ok, S::Error>
409    where
410        S: Serializer,
411    {
412        RangeTo {
413            end: SerializeAsWrap::<Idx, IdxAs>::new(&value.end),
414        }
415        .serialize(serializer)
416    }
417}
418
419// endregion
420///////////////////////////////////////////////////////////////////////////////
421// region: Collection Types (e.g., Maps, Sets, Vec)
422
423macro_rules! seq_impl {
424    ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident )* >) => {
425        impl<T, U $(, $typaram)*> SerializeAs<$ty<T $(, $typaram)*>> for $ty<U $(, $typaram)*>
426        where
427            U: SerializeAs<T>,
428            $(T: ?Sized + $tbound1 $(+ $tbound2)*,)*
429            $($typaram: ?Sized + $bound,)*
430        {
431            fn serialize_as<S>(source: &$ty<T $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error>
432            where
433                S: Serializer,
434            {
435                serializer.collect_seq(source.iter().map(|item| SerializeAsWrap::<T, U>::new(item)))
436            }
437        }
438    }
439}
440impl<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 {
        serializer.collect_seq(source.iter().map(|item|
                    SerializeAsWrap::<T, U>::new(item)))
    }
}foreach_seq!(seq_impl);
441
442// SmallVec implementation
443#[cfg(feature = "smallvec_1")]
444impl<A, B> SerializeAs<SmallVec<A>> for SmallVec<B>
445where
446    A: smallvec_1::Array,
447    B: smallvec_1::Array,
448    B::Item: SerializeAs<A::Item>,
449{
450    fn serialize_as<S>(source: &SmallVec<A>, serializer: S) -> Result<S::Ok, S::Error>
451    where
452        S: Serializer,
453    {
454        serializer.collect_seq(source.iter().map(SerializeAsWrap::<A::Item, B::Item>::new))
455    }
456}
457
458#[cfg(feature = "alloc")]
459macro_rules! map_impl {
460    ($ty:ident < K, V $(, $typaram:ident : $bound:ident)* >) => {
461        impl<K, KU, V, VU $(, $typaram)*> SerializeAs<$ty<K, V $(, $typaram)*>> for $ty<KU, VU $(, $typaram)*>
462        where
463            KU: SerializeAs<K>,
464            VU: SerializeAs<V>,
465            $($typaram: ?Sized + $bound,)*
466        {
467            fn serialize_as<S>(source: &$ty<K, V $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error>
468            where
469                S: Serializer,
470            {
471                serializer.collect_map(source.iter().map(|(k, v)| (SerializeAsWrap::<K, KU>::new(k), SerializeAsWrap::<V, VU>::new(v))))
472            }
473        }
474    }
475}
476impl<K, KU, V, VU, H> SerializeAs<IndexMap2<K, V, H>> for IndexMap2<KU, VU, H>
    where KU: SerializeAs<K>, VU: SerializeAs<V>, H: ?Sized + Sized {
    fn serialize_as<S>(source: &IndexMap2<K, V, H>, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        serializer.collect_map(source.iter().map(|(k, v)|
                    (SerializeAsWrap::<K, KU>::new(k),
                        SerializeAsWrap::<V, VU>::new(v))))
    }
}foreach_map!(map_impl);
477
478macro_rules! tuple_impl {
479    ($len:literal $($n:tt $t:ident $tas:ident)+) => {
480        impl<$($t, $tas,)+> SerializeAs<($($t,)+)> for ($($tas,)+)
481        where
482            $($tas: SerializeAs<$t>,)+
483        {
484            fn serialize_as<S>(tuple: &($($t,)+), serializer: S) -> Result<S::Ok, S::Error>
485            where
486                S: Serializer,
487            {
488                let mut tup = serializer.serialize_tuple($len)?;
489                $(
490                    tup.serialize_element(&SerializeAsWrap::<$t, $tas>::new(&tuple.$n))?;
491                )+
492                tup.end()
493            }
494        }
495    };
496}
497
498impl<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 {
        let mut tup = serializer.serialize_tuple(1)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.end()
    }
}tuple_impl!(1 0 T0 As0);
499impl<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 {
        let mut tup = serializer.serialize_tuple(2)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.end()
    }
}tuple_impl!(2 0 T0 As0 1 T1 As1);
500impl<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 {
        let mut tup = serializer.serialize_tuple(3)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.end()
    }
}tuple_impl!(3 0 T0 As0 1 T1 As1 2 T2 As2);
501impl<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 {
        let mut tup = serializer.serialize_tuple(4)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.end()
    }
}tuple_impl!(4 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3);
502impl<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 {
        let mut tup = serializer.serialize_tuple(5)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.end()
    }
}tuple_impl!(5 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4);
503impl<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 {
        let mut tup = serializer.serialize_tuple(6)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.end()
    }
}tuple_impl!(6 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5);
504impl<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 {
        let mut tup = serializer.serialize_tuple(7)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.serialize_element(&SerializeAsWrap::<T6, As6>::new(&tuple.6))?;
        tup.end()
    }
}tuple_impl!(7 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6);
505impl<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 {
        let mut tup = serializer.serialize_tuple(8)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.serialize_element(&SerializeAsWrap::<T6, As6>::new(&tuple.6))?;
        tup.serialize_element(&SerializeAsWrap::<T7, As7>::new(&tuple.7))?;
        tup.end()
    }
}tuple_impl!(8 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7);
506impl<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 {
        let mut tup = serializer.serialize_tuple(9)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.serialize_element(&SerializeAsWrap::<T6, As6>::new(&tuple.6))?;
        tup.serialize_element(&SerializeAsWrap::<T7, As7>::new(&tuple.7))?;
        tup.serialize_element(&SerializeAsWrap::<T8, As8>::new(&tuple.8))?;
        tup.end()
    }
}tuple_impl!(9 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8);
507impl<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 {
        let mut tup = serializer.serialize_tuple(10)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.serialize_element(&SerializeAsWrap::<T6, As6>::new(&tuple.6))?;
        tup.serialize_element(&SerializeAsWrap::<T7, As7>::new(&tuple.7))?;
        tup.serialize_element(&SerializeAsWrap::<T8, As8>::new(&tuple.8))?;
        tup.serialize_element(&SerializeAsWrap::<T9, As9>::new(&tuple.9))?;
        tup.end()
    }
}tuple_impl!(10 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9);
508impl<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 {
        let mut tup = serializer.serialize_tuple(11)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.serialize_element(&SerializeAsWrap::<T6, As6>::new(&tuple.6))?;
        tup.serialize_element(&SerializeAsWrap::<T7, As7>::new(&tuple.7))?;
        tup.serialize_element(&SerializeAsWrap::<T8, As8>::new(&tuple.8))?;
        tup.serialize_element(&SerializeAsWrap::<T9, As9>::new(&tuple.9))?;
        tup.serialize_element(&SerializeAsWrap::<T10, As10>::new(&tuple.10))?;
        tup.end()
    }
}tuple_impl!(11 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10);
509impl<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 {
        let mut tup = serializer.serialize_tuple(12)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.serialize_element(&SerializeAsWrap::<T6, As6>::new(&tuple.6))?;
        tup.serialize_element(&SerializeAsWrap::<T7, As7>::new(&tuple.7))?;
        tup.serialize_element(&SerializeAsWrap::<T8, As8>::new(&tuple.8))?;
        tup.serialize_element(&SerializeAsWrap::<T9, As9>::new(&tuple.9))?;
        tup.serialize_element(&SerializeAsWrap::<T10, As10>::new(&tuple.10))?;
        tup.serialize_element(&SerializeAsWrap::<T11, As11>::new(&tuple.11))?;
        tup.end()
    }
}tuple_impl!(12 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11);
510impl<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 {
        let mut tup = serializer.serialize_tuple(13)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.serialize_element(&SerializeAsWrap::<T6, As6>::new(&tuple.6))?;
        tup.serialize_element(&SerializeAsWrap::<T7, As7>::new(&tuple.7))?;
        tup.serialize_element(&SerializeAsWrap::<T8, As8>::new(&tuple.8))?;
        tup.serialize_element(&SerializeAsWrap::<T9, As9>::new(&tuple.9))?;
        tup.serialize_element(&SerializeAsWrap::<T10, As10>::new(&tuple.10))?;
        tup.serialize_element(&SerializeAsWrap::<T11, As11>::new(&tuple.11))?;
        tup.serialize_element(&SerializeAsWrap::<T12, As12>::new(&tuple.12))?;
        tup.end()
    }
}tuple_impl!(13 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12);
511impl<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 {
        let mut tup = serializer.serialize_tuple(14)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.serialize_element(&SerializeAsWrap::<T6, As6>::new(&tuple.6))?;
        tup.serialize_element(&SerializeAsWrap::<T7, As7>::new(&tuple.7))?;
        tup.serialize_element(&SerializeAsWrap::<T8, As8>::new(&tuple.8))?;
        tup.serialize_element(&SerializeAsWrap::<T9, As9>::new(&tuple.9))?;
        tup.serialize_element(&SerializeAsWrap::<T10, As10>::new(&tuple.10))?;
        tup.serialize_element(&SerializeAsWrap::<T11, As11>::new(&tuple.11))?;
        tup.serialize_element(&SerializeAsWrap::<T12, As12>::new(&tuple.12))?;
        tup.serialize_element(&SerializeAsWrap::<T13, As13>::new(&tuple.13))?;
        tup.end()
    }
}tuple_impl!(14 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13);
512impl<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 {
        let mut tup = serializer.serialize_tuple(15)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.serialize_element(&SerializeAsWrap::<T6, As6>::new(&tuple.6))?;
        tup.serialize_element(&SerializeAsWrap::<T7, As7>::new(&tuple.7))?;
        tup.serialize_element(&SerializeAsWrap::<T8, As8>::new(&tuple.8))?;
        tup.serialize_element(&SerializeAsWrap::<T9, As9>::new(&tuple.9))?;
        tup.serialize_element(&SerializeAsWrap::<T10, As10>::new(&tuple.10))?;
        tup.serialize_element(&SerializeAsWrap::<T11, As11>::new(&tuple.11))?;
        tup.serialize_element(&SerializeAsWrap::<T12, As12>::new(&tuple.12))?;
        tup.serialize_element(&SerializeAsWrap::<T13, As13>::new(&tuple.13))?;
        tup.serialize_element(&SerializeAsWrap::<T14, As14>::new(&tuple.14))?;
        tup.end()
    }
}tuple_impl!(15 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13 14 T14 As14);
513impl<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 {
        let mut tup = serializer.serialize_tuple(16)?;
        tup.serialize_element(&SerializeAsWrap::<T0, As0>::new(&tuple.0))?;
        tup.serialize_element(&SerializeAsWrap::<T1, As1>::new(&tuple.1))?;
        tup.serialize_element(&SerializeAsWrap::<T2, As2>::new(&tuple.2))?;
        tup.serialize_element(&SerializeAsWrap::<T3, As3>::new(&tuple.3))?;
        tup.serialize_element(&SerializeAsWrap::<T4, As4>::new(&tuple.4))?;
        tup.serialize_element(&SerializeAsWrap::<T5, As5>::new(&tuple.5))?;
        tup.serialize_element(&SerializeAsWrap::<T6, As6>::new(&tuple.6))?;
        tup.serialize_element(&SerializeAsWrap::<T7, As7>::new(&tuple.7))?;
        tup.serialize_element(&SerializeAsWrap::<T8, As8>::new(&tuple.8))?;
        tup.serialize_element(&SerializeAsWrap::<T9, As9>::new(&tuple.9))?;
        tup.serialize_element(&SerializeAsWrap::<T10, As10>::new(&tuple.10))?;
        tup.serialize_element(&SerializeAsWrap::<T11, As11>::new(&tuple.11))?;
        tup.serialize_element(&SerializeAsWrap::<T12, As12>::new(&tuple.12))?;
        tup.serialize_element(&SerializeAsWrap::<T13, As13>::new(&tuple.13))?;
        tup.serialize_element(&SerializeAsWrap::<T14, As14>::new(&tuple.14))?;
        tup.serialize_element(&SerializeAsWrap::<T15, As15>::new(&tuple.15))?;
        tup.end()
    }
}tuple_impl!(16 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13 14 T14 As14 15 T15 As15);
514
515#[cfg(feature = "alloc")]
516macro_rules! map_as_tuple_seq_intern {
517    ($tyorig:ident < K, V $(, $typaram:ident : $bound:ident)* >, $ty:ident <(K, V)>) => {
518        impl<K, KAs, V, VAs $(, $typaram)*> SerializeAs<$tyorig<K, V $(, $typaram)*>> for $ty<(KAs, VAs)>
519        where
520            KAs: SerializeAs<K>,
521            VAs: SerializeAs<V>,
522            $($typaram: ?Sized + $bound,)*
523        {
524            fn serialize_as<S>(source: &$tyorig<K, V $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error>
525            where
526                S: Serializer,
527            {
528                serializer.collect_seq(source.iter().map(|(k, v)| {
529                    (
530                        SerializeAsWrap::<K, KAs>::new(k),
531                        SerializeAsWrap::<V, VAs>::new(v),
532                    )
533                }))
534            }
535        }
536    };
537}
538#[cfg(feature = "alloc")]
539macro_rules! map_as_tuple_seq {
540    ($tyorig:ident < K, V $(, $typaram:ident : $bound:ident)* >) => {
541        map_as_tuple_seq_intern!($tyorig<K, V $(, $typaram: $bound)* >, Seq<(K, V)>);
542        #[cfg(feature = "alloc")]
543        map_as_tuple_seq_intern!($tyorig<K, V $(, $typaram: $bound)* >, Vec<(K, V)>);
544    }
545}
546impl<K, KAs, V, VAs, H> SerializeAs<IndexMap2<K, V, H>> for Vec<(KAs, VAs)>
    where KAs: SerializeAs<K>, VAs: SerializeAs<V>, H: ?Sized + Sized {
    fn serialize_as<S>(source: &IndexMap2<K, V, H>, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        serializer.collect_seq(source.iter().map(|(k, v)|
                    {
                        (SerializeAsWrap::<K, KAs>::new(k),
                            SerializeAsWrap::<V, VAs>::new(v))
                    }))
    }
}foreach_map!(map_as_tuple_seq);
547
548macro_rules! tuple_seq_as_map_impl_intern {
549    ($tyorig:ident < (K, V) $(, $typaram:ident : $bound:ident)* >, $ty:ident <K, V>) => {
550        #[allow(clippy::implicit_hasher)]
551        impl<K, KAs, V, VAs $(, $typaram)*> SerializeAs<$tyorig<(K, V) $(, $typaram)*>> for $ty<KAs, VAs>
552        where
553            KAs: SerializeAs<K>,
554            VAs: SerializeAs<V>,
555            $($typaram: ?Sized + $bound,)*
556        {
557            fn serialize_as<S>(source: &$tyorig<(K, V) $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error>
558            where
559                S: Serializer,
560            {
561                serializer.collect_map(source.iter().map(|(k, v)| {
562                    (
563                        SerializeAsWrap::<K, KAs>::new(k),
564                        SerializeAsWrap::<V, VAs>::new(v),
565                    )
566                }))
567            }
568        }
569    };
570}
571macro_rules! tuple_seq_as_map_impl {
572    ($tyorig:ident < (K, V) $(, $typaram:ident : $bound:ident)* >) => {
573        tuple_seq_as_map_impl_intern!($tyorig<(K, V) $(, $typaram: $bound)* >, Map<K, V>);
574        #[cfg(feature = "alloc")]
575        tuple_seq_as_map_impl_intern!($tyorig<(K, V) $(, $typaram: $bound)* >, BTreeMap<K, V>);
576        #[cfg(feature = "std")]
577        tuple_seq_as_map_impl_intern!($tyorig<(K, V) $(, $typaram: $bound)* >, HashMap<K, V>);
578    }
579}
580#[allow(clippy :: implicit_hasher)]
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 {
        serializer.collect_map(source.iter().map(|(k, v)|
                    {
                        (SerializeAsWrap::<K, KAs>::new(k),
                            SerializeAsWrap::<V, VAs>::new(v))
                    }))
    }
}foreach_seq!(tuple_seq_as_map_impl, (K, V));
581#[allow(clippy :: implicit_hasher)]
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 {
        serializer.collect_map(source.iter().map(|(k, v)|
                    {
                        (SerializeAsWrap::<K, KAs>::new(k),
                            SerializeAsWrap::<V, VAs>::new(v))
                    }))
    }
}tuple_seq_as_map_impl!(Option<(K, V)>);
582
583macro_rules! tuple_seq_as_map_arr {
584    ($tyorig:ty, $ty:ident <K, V>) => {
585        #[allow(clippy::implicit_hasher)]
586        impl<K, KAs, V, VAs, const N: usize> SerializeAs<$tyorig> for $ty<KAs, VAs>
587        where
588            KAs: SerializeAs<K>,
589            VAs: SerializeAs<V>,
590        {
591            fn serialize_as<S>(source: &$tyorig, serializer: S) -> Result<S::Ok, S::Error>
592            where
593                S: Serializer,
594            {
595                serializer.collect_map(source.iter().map(|(k, v)| {
596                    (
597                        SerializeAsWrap::<K, KAs>::new(k),
598                        SerializeAsWrap::<V, VAs>::new(v),
599                    )
600                }))
601            }
602        }
603    };
604}
605#[allow(clippy :: implicit_hasher)]
impl<K, KAs, V, VAs, const N : usize> SerializeAs<[(K, V); N]> for
    Map<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 {
        serializer.collect_map(source.iter().map(|(k, v)|
                    {
                        (SerializeAsWrap::<K, KAs>::new(k),
                            SerializeAsWrap::<V, VAs>::new(v))
                    }))
    }
}tuple_seq_as_map_arr!([(K, V); N], Map<K, V>);
606#[cfg(feature = "alloc")]
607#[allow(clippy :: implicit_hasher)]
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 {
        serializer.collect_map(source.iter().map(|(k, v)|
                    {
                        (SerializeAsWrap::<K, KAs>::new(k),
                            SerializeAsWrap::<V, VAs>::new(v))
                    }))
    }
}tuple_seq_as_map_arr!([(K, V); N], BTreeMap<K, V>);
608#[cfg(feature = "std")]
609#[allow(clippy :: implicit_hasher)]
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 {
        serializer.collect_map(source.iter().map(|(k, v)|
                    {
                        (SerializeAsWrap::<K, KAs>::new(k),
                            SerializeAsWrap::<V, VAs>::new(v))
                    }))
    }
}tuple_seq_as_map_arr!([(K, V); N], HashMap<K, V>);
610
611// endregion
612///////////////////////////////////////////////////////////////////////////////
613// region: Conversion types which cause different serialization behavior
614
615impl<T> SerializeAs<T> for Same
616where
617    T: Serialize + ?Sized,
618{
619    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
620    where
621        S: Serializer,
622    {
623        source.serialize(serializer)
624    }
625}
626
627impl<T> SerializeAs<T> for DisplayFromStr
628where
629    T: Display,
630{
631    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
632    where
633        S: Serializer,
634    {
635        serializer.collect_str(source)
636    }
637}
638
639impl<T, H, F> SerializeAs<T> for IfIsHumanReadable<H, F>
640where
641    T: ?Sized,
642    H: SerializeAs<T>,
643    F: SerializeAs<T>,
644{
645    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
646    where
647        S: Serializer,
648    {
649        if serializer.is_human_readable() {
650            H::serialize_as(source, serializer)
651        } else {
652            F::serialize_as(source, serializer)
653        }
654    }
655}
656
657impl<T> SerializeAs<Option<T>> for NoneAsEmptyString
658where
659    T: Display,
660{
661    fn serialize_as<S>(source: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
662    where
663        S: Serializer,
664    {
665        if let Some(value) = source {
666            serializer.collect_str(value)
667        } else {
668            serializer.serialize_str("")
669        }
670    }
671}
672
673#[cfg(feature = "alloc")]
674impl<T, TAs> SerializeAs<T> for DefaultOnError<TAs>
675where
676    TAs: SerializeAs<T>,
677{
678    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
679    where
680        S: Serializer,
681    {
682        TAs::serialize_as(source, serializer)
683    }
684}
685
686#[cfg(feature = "alloc")]
687impl SerializeAs<Vec<u8>> for BytesOrString {
688    fn serialize_as<S>(source: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
689    where
690        S: Serializer,
691    {
692        source.serialize(serializer)
693    }
694}
695
696impl<SEPARATOR, I, T> SerializeAs<I> for StringWithSeparator<SEPARATOR, T>
697where
698    SEPARATOR: formats::Separator,
699    for<'x> &'x I: IntoIterator<Item = &'x T>,
700    T: Display,
701    // This set of bounds is enough to make the function compile but has inference issues
702    // making it unusable at the moment.
703    // https://github.com/rust-lang/rust/issues/89196#issuecomment-932024770
704    // for<'x> &'x I: IntoIterator,
705    // for<'x> <&'x I as IntoIterator>::Item: Display,
706{
707    fn serialize_as<S>(source: &I, serializer: S) -> Result<S::Ok, S::Error>
708    where
709        S: Serializer,
710    {
711        pub(crate) struct DisplayWithSeparator<'a, I, SEPARATOR>(&'a I, PhantomData<SEPARATOR>);
712
713        impl<'a, I, SEPARATOR> DisplayWithSeparator<'a, I, SEPARATOR> {
714            pub(crate) fn new(iter: &'a I) -> Self {
715                Self(iter, PhantomData)
716            }
717        }
718
719        impl<'a, I, SEPARATOR> Display for DisplayWithSeparator<'a, I, SEPARATOR>
720        where
721            SEPARATOR: formats::Separator,
722            &'a I: IntoIterator,
723            <&'a I as IntoIterator>::Item: Display,
724        {
725            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
726                let mut iter = self.0.into_iter();
727
728                if let Some(first) = iter.next() {
729                    first.fmt(f)?;
730                }
731                for elem in iter {
732                    f.write_str(SEPARATOR::separator())?;
733                    elem.fmt(f)?;
734                }
735
736                Ok(())
737            }
738        }
739
740        serializer.collect_str(&DisplayWithSeparator::<I, SEPARATOR>::new(source))
741    }
742}
743
744macro_rules! use_signed_duration {
745    (
746        $main_trait:ident $internal_trait:ident =>
747        {
748            $ty:ty =>
749            $({
750                $format:ty, $strictness:ty =>
751                $($tbound:ident: $bound:ident $(,)?)*
752            })*
753        }
754    ) => {
755        $(
756            impl<$($tbound,)*> SerializeAs<$ty> for $main_trait<$format, $strictness>
757            where
758                $($tbound: $bound,)*
759            {
760                fn serialize_as<S>(source: &$ty, serializer: S) -> Result<S::Ok, S::Error>
761                where
762                    S: Serializer,
763                {
764                    $internal_trait::<$format, $strictness>::serialize_as(
765                        &DurationSigned::from(source),
766                        serializer,
767                    )
768                }
769            }
770        )*
771    };
772    (
773        $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt
774    ) => {
775        $( use_signed_duration!($main_trait $internal_trait => $rest); )+
776    };
777}
778
779impl<STRICTNESS> SerializeAs<Duration> for
    DurationNanoSeconds<f64, STRICTNESS> where STRICTNESS: Strictness {
    fn serialize_as<S>(source: &Duration, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        DurationNanoSeconds::<f64,
                STRICTNESS>::serialize_as(&DurationSigned::from(source),
            serializer)
    }
}use_signed_duration!(
780    DurationSeconds DurationSeconds,
781    DurationMilliSeconds DurationMilliSeconds,
782    DurationMicroSeconds DurationMicroSeconds,
783    DurationNanoSeconds DurationNanoSeconds,
784    => {
785        Duration =>
786        {u64, STRICTNESS => STRICTNESS: Strictness}
787        {f64, STRICTNESS => STRICTNESS: Strictness}
788    }
789);
790#[cfg(feature = "alloc")]
791impl<STRICTNESS> SerializeAs<Duration> for
    DurationNanoSeconds<String, STRICTNESS> where STRICTNESS: Strictness {
    fn serialize_as<S>(source: &Duration, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        DurationNanoSeconds::<String,
                STRICTNESS>::serialize_as(&DurationSigned::from(source),
            serializer)
    }
}use_signed_duration!(
792    DurationSeconds DurationSeconds,
793    DurationMilliSeconds DurationMilliSeconds,
794    DurationMicroSeconds DurationMicroSeconds,
795    DurationNanoSeconds DurationNanoSeconds,
796    => {
797        Duration =>
798        {String, STRICTNESS => STRICTNESS: Strictness}
799    }
800);
801impl<STRICTNESS> SerializeAs<Duration> for
    DurationNanoSecondsWithFrac<f64, STRICTNESS> where STRICTNESS: Strictness
    {
    fn serialize_as<S>(source: &Duration, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        DurationNanoSecondsWithFrac::<f64,
                STRICTNESS>::serialize_as(&DurationSigned::from(source),
            serializer)
    }
}use_signed_duration!(
802    DurationSecondsWithFrac DurationSecondsWithFrac,
803    DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac,
804    DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac,
805    DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac,
806    => {
807        Duration =>
808        {f64, STRICTNESS => STRICTNESS: Strictness}
809    }
810);
811#[cfg(feature = "alloc")]
812impl<STRICTNESS> SerializeAs<Duration> for
    DurationNanoSecondsWithFrac<String, STRICTNESS> where
    STRICTNESS: Strictness {
    fn serialize_as<S>(source: &Duration, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        DurationNanoSecondsWithFrac::<String,
                STRICTNESS>::serialize_as(&DurationSigned::from(source),
            serializer)
    }
}use_signed_duration!(
813    DurationSecondsWithFrac DurationSecondsWithFrac,
814    DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac,
815    DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac,
816    DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac,
817    => {
818        Duration =>
819        {String, STRICTNESS => STRICTNESS: Strictness}
820    }
821);
822
823#[cfg(feature = "std")]
824impl<STRICTNESS> SerializeAs<SystemTime> for
    TimestampNanoSeconds<String, STRICTNESS> where STRICTNESS: Strictness {
    fn serialize_as<S>(source: &SystemTime, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        DurationNanoSeconds::<String,
                STRICTNESS>::serialize_as(&DurationSigned::from(source),
            serializer)
    }
}use_signed_duration!(
825    TimestampSeconds DurationSeconds,
826    TimestampMilliSeconds DurationMilliSeconds,
827    TimestampMicroSeconds DurationMicroSeconds,
828    TimestampNanoSeconds DurationNanoSeconds,
829    => {
830        SystemTime =>
831        {i64, STRICTNESS => STRICTNESS: Strictness}
832        {f64, STRICTNESS => STRICTNESS: Strictness}
833        {String, STRICTNESS => STRICTNESS: Strictness}
834    }
835);
836#[cfg(feature = "std")]
837impl<STRICTNESS> SerializeAs<SystemTime> for
    TimestampNanoSecondsWithFrac<String, STRICTNESS> where
    STRICTNESS: Strictness {
    fn serialize_as<S>(source: &SystemTime, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        DurationNanoSecondsWithFrac::<String,
                STRICTNESS>::serialize_as(&DurationSigned::from(source),
            serializer)
    }
}use_signed_duration!(
838    TimestampSecondsWithFrac DurationSecondsWithFrac,
839    TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
840    TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
841    TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
842    => {
843        SystemTime =>
844        {f64, STRICTNESS => STRICTNESS: Strictness}
845        {String, STRICTNESS => STRICTNESS: Strictness}
846    }
847);
848
849impl<T, U> SerializeAs<T> for DefaultOnNull<U>
850where
851    U: SerializeAs<T>,
852{
853    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
854    where
855        S: Serializer,
856    {
857        serializer.serialize_some(&SerializeAsWrap::<T, U>::new(source))
858    }
859}
860
861impl SerializeAs<&[u8]> for Bytes {
862    fn serialize_as<S>(bytes: &&[u8], serializer: S) -> Result<S::Ok, S::Error>
863    where
864        S: Serializer,
865    {
866        serializer.serialize_bytes(bytes)
867    }
868}
869
870#[cfg(feature = "alloc")]
871impl SerializeAs<Vec<u8>> for Bytes {
872    fn serialize_as<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
873    where
874        S: Serializer,
875    {
876        serializer.serialize_bytes(bytes)
877    }
878}
879
880#[cfg(feature = "alloc")]
881impl SerializeAs<Box<[u8]>> for Bytes {
882    fn serialize_as<S>(bytes: &Box<[u8]>, serializer: S) -> Result<S::Ok, S::Error>
883    where
884        S: Serializer,
885    {
886        serializer.serialize_bytes(bytes)
887    }
888}
889
890#[cfg(feature = "alloc")]
891impl<'a> SerializeAs<Cow<'a, [u8]>> for Bytes {
892    fn serialize_as<S>(bytes: &Cow<'a, [u8]>, serializer: S) -> Result<S::Ok, S::Error>
893    where
894        S: Serializer,
895    {
896        serializer.serialize_bytes(bytes)
897    }
898}
899
900impl<const N: usize> SerializeAs<[u8; N]> for Bytes {
901    fn serialize_as<S>(bytes: &[u8; N], serializer: S) -> Result<S::Ok, S::Error>
902    where
903        S: Serializer,
904    {
905        serializer.serialize_bytes(bytes)
906    }
907}
908
909impl<const N: usize> SerializeAs<&[u8; N]> for Bytes {
910    fn serialize_as<S>(bytes: &&[u8; N], serializer: S) -> Result<S::Ok, S::Error>
911    where
912        S: Serializer,
913    {
914        serializer.serialize_bytes(*bytes)
915    }
916}
917
918#[cfg(feature = "alloc")]
919impl<const N: usize> SerializeAs<Box<[u8; N]>> for Bytes {
920    fn serialize_as<S>(bytes: &Box<[u8; N]>, serializer: S) -> Result<S::Ok, S::Error>
921    where
922        S: Serializer,
923    {
924        serializer.serialize_bytes(&**bytes)
925    }
926}
927
928#[cfg(feature = "alloc")]
929impl<'a, const N: usize> SerializeAs<Cow<'a, [u8; N]>> for Bytes {
930    fn serialize_as<S>(bytes: &Cow<'a, [u8; N]>, serializer: S) -> Result<S::Ok, S::Error>
931    where
932        S: Serializer,
933    {
934        serializer.serialize_bytes(bytes.as_ref())
935    }
936}
937
938#[cfg(feature = "alloc")]
939macro_rules! one_or_many_impl {
940    ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident )* >) => {
941        impl<T, U $(, $typaram)*> SerializeAs<$ty<T $(, $typaram)*>> for OneOrMany<U, formats::PreferOne>
942        where
943            U: SerializeAs<T>,
944            $(T: ?Sized + $tbound1 $(+ $tbound2)*,)*
945            $($typaram: ?Sized + $bound,)*
946        {
947            fn serialize_as<S>(source: &$ty<T $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error>
948            where
949                S: Serializer,
950            {
951                match source.len() {
952                    1 => SerializeAsWrap::<T, U>::new(source.iter().next().expect("Cannot be empty"))
953                        .serialize(serializer),
954                    _ => serializer.collect_seq(source.iter().map(|item| SerializeAsWrap::<T, U>::new(item))),
955                }
956            }
957        }
958
959        impl<T, U $(, $typaram)*> SerializeAs<$ty<T $(, $typaram)*>> for OneOrMany<U, formats::PreferMany>
960        where
961            U: SerializeAs<T>,
962            $(T: ?Sized + $tbound1 $(+ $tbound2)*,)*
963            $($typaram: ?Sized + $bound,)*
964        {
965            fn serialize_as<S>(source: &$ty<T $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error>
966            where
967                S: Serializer,
968            {
969                serializer.collect_seq(source.iter().map(|item| SerializeAsWrap::<T, U>::new(item)))
970            }
971        }
972    }
973}
974#[cfg(feature = "alloc")]
975impl<T, U> SerializeAs<VecDeque<T>> for OneOrMany<U, formats::PreferOne> where
    U: SerializeAs<T> {
    fn serialize_as<S>(source: &VecDeque<T>, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        match source.len() {
            1 =>
                SerializeAsWrap::<T,
                            U>::new(source.iter().next().expect("Cannot be empty")).serialize(serializer),
            _ =>
                serializer.collect_seq(source.iter().map(|item|
                            SerializeAsWrap::<T, U>::new(item))),
        }
    }
}
impl<T, U> SerializeAs<VecDeque<T>> for OneOrMany<U, formats::PreferMany>
    where U: SerializeAs<T> {
    fn serialize_as<S>(source: &VecDeque<T>, serializer: S)
        -> Result<S::Ok, S::Error> where S: Serializer {
        serializer.collect_seq(source.iter().map(|item|
                    SerializeAsWrap::<T, U>::new(item)))
    }
}foreach_seq!(one_or_many_impl);
976
977#[cfg(all(feature = "alloc", feature = "smallvec_1"))]
978impl<T, TAs, A> SerializeAs<smallvec_1::SmallVec<A>> for OneOrMany<TAs, formats::PreferOne>
979where
980    A: smallvec_1::Array<Item = T>,
981    TAs: SerializeAs<T>,
982{
983    fn serialize_as<S>(source: &smallvec_1::SmallVec<A>, serializer: S) -> Result<S::Ok, S::Error>
984    where
985        S: Serializer,
986    {
987        match source.len() {
988            1 => SerializeAsWrap::<T, TAs>::new(source.iter().next().expect("Cannot be empty"))
989                .serialize(serializer),
990            _ => SerializeAsWrap::<&[T], &[TAs]>::new(&source.as_slice()).serialize(serializer),
991        }
992    }
993}
994
995#[cfg(all(feature = "alloc", feature = "smallvec_1"))]
996impl<T, TAs, A> SerializeAs<smallvec_1::SmallVec<A>> for OneOrMany<TAs, formats::PreferMany>
997where
998    A: smallvec_1::Array<Item = T>,
999    TAs: SerializeAs<T>,
1000{
1001    fn serialize_as<S>(source: &smallvec_1::SmallVec<A>, serializer: S) -> Result<S::Ok, S::Error>
1002    where
1003        S: Serializer,
1004    {
1005        SerializeAsWrap::<&[T], &[TAs]>::new(&source.as_slice()).serialize(serializer)
1006    }
1007}
1008
1009#[cfg(feature = "alloc")]
1010impl<T, TAs1> SerializeAs<T> for PickFirst<(TAs1,)>
1011where
1012    TAs1: SerializeAs<T>,
1013{
1014    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
1015    where
1016        S: Serializer,
1017    {
1018        SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer)
1019    }
1020}
1021
1022#[cfg(feature = "alloc")]
1023impl<T, TAs1, TAs2> SerializeAs<T> for PickFirst<(TAs1, TAs2)>
1024where
1025    TAs1: SerializeAs<T>,
1026{
1027    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
1028    where
1029        S: Serializer,
1030    {
1031        SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer)
1032    }
1033}
1034
1035#[cfg(feature = "alloc")]
1036impl<T, TAs1, TAs2, TAs3> SerializeAs<T> for PickFirst<(TAs1, TAs2, TAs3)>
1037where
1038    TAs1: SerializeAs<T>,
1039{
1040    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
1041    where
1042        S: Serializer,
1043    {
1044        SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer)
1045    }
1046}
1047
1048#[cfg(feature = "alloc")]
1049impl<T, TAs1, TAs2, TAs3, TAs4> SerializeAs<T> for PickFirst<(TAs1, TAs2, TAs3, TAs4)>
1050where
1051    TAs1: SerializeAs<T>,
1052{
1053    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
1054    where
1055        S: Serializer,
1056    {
1057        SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer)
1058    }
1059}
1060
1061impl<T, U> SerializeAs<T> for FromInto<U>
1062where
1063    T: Into<U> + Clone,
1064    U: Serialize,
1065{
1066    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
1067    where
1068        S: Serializer,
1069    {
1070        source.clone().into().serialize(serializer)
1071    }
1072}
1073
1074impl<T, U> SerializeAs<T> for TryFromInto<U>
1075where
1076    T: TryInto<U> + Clone,
1077    <T as TryInto<U>>::Error: Display,
1078    U: Serialize,
1079{
1080    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
1081    where
1082        S: Serializer,
1083    {
1084        source
1085            .clone()
1086            .try_into()
1087            .map_err(S::Error::custom)?
1088            .serialize(serializer)
1089    }
1090}
1091
1092impl<T, U> SerializeAs<T> for FromIntoRef<U>
1093where
1094    for<'a> &'a T: Into<U>,
1095    U: Serialize,
1096{
1097    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
1098    where
1099        S: Serializer,
1100    {
1101        source.into().serialize(serializer)
1102    }
1103}
1104
1105impl<T, U> SerializeAs<T> for TryFromIntoRef<U>
1106where
1107    for<'a> &'a T: TryInto<U>,
1108    for<'a> <&'a T as TryInto<U>>::Error: Display,
1109    U: Serialize,
1110{
1111    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
1112    where
1113        S: Serializer,
1114    {
1115        source
1116            .try_into()
1117            .map_err(S::Error::custom)?
1118            .serialize(serializer)
1119    }
1120}
1121
1122#[cfg(feature = "alloc")]
1123impl<'a> SerializeAs<Cow<'a, str>> for BorrowCow {
1124    fn serialize_as<S>(source: &Cow<'a, str>, serializer: S) -> Result<S::Ok, S::Error>
1125    where
1126        S: Serializer,
1127    {
1128        serializer.serialize_str(source)
1129    }
1130}
1131
1132#[cfg(feature = "alloc")]
1133impl<'a> SerializeAs<Cow<'a, [u8]>> for BorrowCow {
1134    fn serialize_as<S>(value: &Cow<'a, [u8]>, serializer: S) -> Result<S::Ok, S::Error>
1135    where
1136        S: Serializer,
1137    {
1138        serializer.collect_seq(value.iter())
1139    }
1140}
1141
1142#[cfg(feature = "alloc")]
1143impl<'a, const N: usize> SerializeAs<Cow<'a, [u8; N]>> for BorrowCow {
1144    fn serialize_as<S>(value: &Cow<'a, [u8; N]>, serializer: S) -> Result<S::Ok, S::Error>
1145    where
1146        S: Serializer,
1147    {
1148        serializer.collect_seq(value.iter())
1149    }
1150}
1151
1152impl<STRICTNESS: Strictness> SerializeAs<bool> for BoolFromInt<STRICTNESS> {
1153    fn serialize_as<S>(source: &bool, serializer: S) -> Result<S::Ok, S::Error>
1154    where
1155        S: Serializer,
1156    {
1157        serializer.serialize_u8(u8::from(*source))
1158    }
1159}
1160
1161// endregion
serde_with/ser/impls.rs

serde_with/ser/
impls.rs
