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

serde_with/ser/
impls.rs
