serde/ser/
impls.rs

1use lib::*;
2
3use ser::{Error, Serialize, SerializeTuple, Serializer};
4
5////////////////////////////////////////////////////////////////////////////////
6
7macro_rules! primitive_impl {
8    ($ty:ident, $method:ident $($cast:tt)*) => {
9        impl Serialize for $ty {
10            #[inline]
11            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
12            where
13                S: Serializer,
14            {
15                serializer.$method(*self $($cast)*)
16            }
17        }
18    }
19}
20
21primitive_impl!(bool, serialize_bool);
22primitive_impl!(isize, serialize_i64 as i64);
23primitive_impl!(i8, serialize_i8);
24primitive_impl!(i16, serialize_i16);
25primitive_impl!(i32, serialize_i32);
26primitive_impl!(i64, serialize_i64);
27primitive_impl!(usize, serialize_u64 as u64);
28primitive_impl!(u8, serialize_u8);
29primitive_impl!(u16, serialize_u16);
30primitive_impl!(u32, serialize_u32);
31primitive_impl!(u64, serialize_u64);
32primitive_impl!(f32, serialize_f32);
33primitive_impl!(f64, serialize_f64);
34primitive_impl!(char, serialize_char);
35
36serde_if_integer128! {
37    primitive_impl!(i128, serialize_i128);
38    primitive_impl!(u128, serialize_u128);
39}
40
41////////////////////////////////////////////////////////////////////////////////
42
43impl Serialize for str {
44    #[inline]
45    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
46    where
47        S: Serializer,
48    {
49        serializer.serialize_str(self)
50    }
51}
52
53#[cfg(any(feature = "std", feature = "alloc"))]
54impl Serialize for String {
55    #[inline]
56    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
57    where
58        S: Serializer,
59    {
60        serializer.serialize_str(self)
61    }
62}
63
64impl<'a> Serialize for fmt::Arguments<'a> {
65    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
66    where
67        S: Serializer,
68    {
69        serializer.collect_str(self)
70    }
71}
72
73////////////////////////////////////////////////////////////////////////////////
74
75#[cfg(feature = "std")]
76impl Serialize for CStr {
77    #[inline]
78    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
79    where
80        S: Serializer,
81    {
82        serializer.serialize_bytes(self.to_bytes())
83    }
84}
85
86#[cfg(feature = "std")]
87impl Serialize for CString {
88    #[inline]
89    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
90    where
91        S: Serializer,
92    {
93        serializer.serialize_bytes(self.to_bytes())
94    }
95}
96
97////////////////////////////////////////////////////////////////////////////////
98
99impl<T> Serialize for Option<T>
100where
101    T: Serialize,
102{
103    #[inline]
104    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
105    where
106        S: Serializer,
107    {
108        match *self {
109            Some(ref value) => serializer.serialize_some(value),
110            None => serializer.serialize_none(),
111        }
112    }
113}
114
115////////////////////////////////////////////////////////////////////////////////
116
117impl<T: ?Sized> Serialize for PhantomData<T> {
118    #[inline]
119    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
120    where
121        S: Serializer,
122    {
123        serializer.serialize_unit_struct("PhantomData")
124    }
125}
126
127////////////////////////////////////////////////////////////////////////////////
128
129// Does not require T: Serialize.
130impl<T> Serialize for [T; 0] {
131    #[inline]
132    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
133    where
134        S: Serializer,
135    {
136        try!(serializer.serialize_tuple(0)).end()
137    }
138}
139
140macro_rules! array_impls {
141    ($($len:tt)+) => {
142        $(
143            impl<T> Serialize for [T; $len]
144            where
145                T: Serialize,
146            {
147                #[inline]
148                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
149                where
150                    S: Serializer,
151                {
152                    let mut seq = try!(serializer.serialize_tuple($len));
153                    for e in self {
154                        try!(seq.serialize_element(e));
155                    }
156                    seq.end()
157                }
158            }
159        )+
160    }
161}
162
163array_impls! {
164    01 02 03 04 05 06 07 08 09 10
165    11 12 13 14 15 16 17 18 19 20
166    21 22 23 24 25 26 27 28 29 30
167    31 32
168}
169
170////////////////////////////////////////////////////////////////////////////////
171
172impl<T> Serialize for [T]
173where
174    T: Serialize,
175{
176    #[inline]
177    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
178    where
179        S: Serializer,
180    {
181        serializer.collect_seq(self)
182    }
183}
184
185#[cfg(any(feature = "std", feature = "alloc"))]
186macro_rules! seq_impl {
187    ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)* >) => {
188        impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
189        where
190            T: Serialize $(+ $tbound1 $(+ $tbound2)*)*,
191            $($typaram: $bound,)*
192        {
193            #[inline]
194            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
195            where
196                S: Serializer,
197            {
198                serializer.collect_seq(self)
199            }
200        }
201    }
202}
203
204#[cfg(any(feature = "std", feature = "alloc"))]
205seq_impl!(BinaryHeap<T: Ord>);
206
207#[cfg(any(feature = "std", feature = "alloc"))]
208seq_impl!(BTreeSet<T: Ord>);
209
210#[cfg(feature = "std")]
211seq_impl!(HashSet<T: Eq + Hash, H: BuildHasher>);
212
213#[cfg(any(feature = "std", feature = "alloc"))]
214seq_impl!(LinkedList<T>);
215
216#[cfg(any(feature = "std", feature = "alloc"))]
217seq_impl!(Vec<T>);
218
219#[cfg(any(feature = "std", feature = "alloc"))]
220seq_impl!(VecDeque<T>);
221
222////////////////////////////////////////////////////////////////////////////////
223
224impl<Idx> Serialize for Range<Idx>
225where
226    Idx: Serialize,
227{
228    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
229    where
230        S: Serializer,
231    {
232        use super::SerializeStruct;
233        let mut state = try!(serializer.serialize_struct("Range", 2));
234        try!(state.serialize_field("start", &self.start));
235        try!(state.serialize_field("end", &self.end));
236        state.end()
237    }
238}
239
240////////////////////////////////////////////////////////////////////////////////
241
242#[cfg(range_inclusive)]
243impl<Idx> Serialize for RangeInclusive<Idx>
244where
245    Idx: Serialize,
246{
247    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
248    where
249        S: Serializer,
250    {
251        use super::SerializeStruct;
252        let mut state = try!(serializer.serialize_struct("RangeInclusive", 2));
253        try!(state.serialize_field("start", &self.start()));
254        try!(state.serialize_field("end", &self.end()));
255        state.end()
256    }
257}
258
259////////////////////////////////////////////////////////////////////////////////
260
261#[cfg(any(ops_bound, collections_bound))]
262impl<T> Serialize for Bound<T>
263where
264    T: Serialize,
265{
266    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
267    where
268        S: Serializer,
269    {
270        match *self {
271            Bound::Unbounded => serializer.serialize_unit_variant("Bound", 0, "Unbounded"),
272            Bound::Included(ref value) => {
273                serializer.serialize_newtype_variant("Bound", 1, "Included", value)
274            }
275            Bound::Excluded(ref value) => {
276                serializer.serialize_newtype_variant("Bound", 2, "Excluded", value)
277            }
278        }
279    }
280}
281
282////////////////////////////////////////////////////////////////////////////////
283
284impl Serialize for () {
285    #[inline]
286    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
287    where
288        S: Serializer,
289    {
290        serializer.serialize_unit()
291    }
292}
293
294#[cfg(feature = "unstable")]
295impl Serialize for ! {
296    fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
297    where
298        S: Serializer,
299    {
300        *self
301    }
302}
303
304////////////////////////////////////////////////////////////////////////////////
305
306macro_rules! tuple_impls {
307    ($($len:expr => ($($n:tt $name:ident)+))+) => {
308        $(
309            impl<$($name),+> Serialize for ($($name,)+)
310            where
311                $($name: Serialize,)+
312            {
313                #[inline]
314                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
315                where
316                    S: Serializer,
317                {
318                    let mut tuple = try!(serializer.serialize_tuple($len));
319                    $(
320                        try!(tuple.serialize_element(&self.$n));
321                    )+
322                    tuple.end()
323                }
324            }
325        )+
326    }
327}
328
329tuple_impls! {
330    1 => (0 T0)
331    2 => (0 T0 1 T1)
332    3 => (0 T0 1 T1 2 T2)
333    4 => (0 T0 1 T1 2 T2 3 T3)
334    5 => (0 T0 1 T1 2 T2 3 T3 4 T4)
335    6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
336    7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
337    8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
338    9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
339    10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
340    11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
341    12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
342    13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
343    14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
344    15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
345    16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
346}
347
348////////////////////////////////////////////////////////////////////////////////
349
350#[cfg(any(feature = "std", feature = "alloc"))]
351macro_rules! map_impl {
352    ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)* >) => {
353        impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
354        where
355            K: Serialize $(+ $kbound1 $(+ $kbound2)*)*,
356            V: Serialize,
357            $($typaram: $bound,)*
358        {
359            #[inline]
360            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
361            where
362                S: Serializer,
363            {
364                serializer.collect_map(self)
365            }
366        }
367    }
368}
369
370#[cfg(any(feature = "std", feature = "alloc"))]
371map_impl!(BTreeMap<K: Ord, V>);
372
373#[cfg(feature = "std")]
374map_impl!(HashMap<K: Eq + Hash, V, H: BuildHasher>);
375
376////////////////////////////////////////////////////////////////////////////////
377
378macro_rules! deref_impl {
379    (
380        $(#[doc = $doc:tt])*
381        <$($desc:tt)+
382    ) => {
383        $(#[doc = $doc])*
384        impl <$($desc)+ {
385            #[inline]
386            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
387            where
388                S: Serializer,
389            {
390                (**self).serialize(serializer)
391            }
392        }
393    };
394}
395
396deref_impl!(<'a, T: ?Sized> Serialize for &'a T where T: Serialize);
397deref_impl!(<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize);
398
399#[cfg(any(feature = "std", feature = "alloc"))]
400deref_impl!(<T: ?Sized> Serialize for Box<T> where T: Serialize);
401
402#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
403deref_impl! {
404    /// This impl requires the [`"rc"`] Cargo feature of Serde.
405    ///
406    /// Serializing a data structure containing `Rc` will serialize a copy of
407    /// the contents of the `Rc` each time the `Rc` is referenced within the
408    /// data structure. Serialization will not attempt to deduplicate these
409    /// repeated data.
410    ///
411    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
412    <T: ?Sized> Serialize for Rc<T> where T: Serialize
413}
414
415#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
416deref_impl! {
417    /// This impl requires the [`"rc"`] Cargo feature of Serde.
418    ///
419    /// Serializing a data structure containing `Arc` will serialize a copy of
420    /// the contents of the `Arc` each time the `Arc` is referenced within the
421    /// data structure. Serialization will not attempt to deduplicate these
422    /// repeated data.
423    ///
424    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
425    <T: ?Sized> Serialize for Arc<T> where T: Serialize
426}
427
428#[cfg(any(feature = "std", feature = "alloc"))]
429deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned);
430
431////////////////////////////////////////////////////////////////////////////////
432
433/// This impl requires the [`"rc"`] Cargo feature of Serde.
434///
435/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
436#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
437impl<T: ?Sized> Serialize for RcWeak<T>
438where
439    T: Serialize,
440{
441    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
442    where
443        S: Serializer,
444    {
445        self.upgrade().serialize(serializer)
446    }
447}
448
449/// This impl requires the [`"rc"`] Cargo feature of Serde.
450///
451/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
452#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
453impl<T: ?Sized> Serialize for ArcWeak<T>
454where
455    T: Serialize,
456{
457    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
458    where
459        S: Serializer,
460    {
461        self.upgrade().serialize(serializer)
462    }
463}
464
465////////////////////////////////////////////////////////////////////////////////
466
467macro_rules! nonzero_integers {
468    ( $( $T: ident, )+ ) => {
469        $(
470            #[cfg(num_nonzero)]
471            impl Serialize for num::$T {
472                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
473                where
474                    S: Serializer,
475                {
476                    self.get().serialize(serializer)
477                }
478            }
479        )+
480    }
481}
482
483nonzero_integers! {
484    NonZeroU8,
485    NonZeroU16,
486    NonZeroU32,
487    NonZeroU64,
488    NonZeroUsize,
489}
490
491#[cfg(num_nonzero_signed)]
492nonzero_integers! {
493    NonZeroI8,
494    NonZeroI16,
495    NonZeroI32,
496    NonZeroI64,
497    NonZeroIsize,
498}
499
500// Currently 128-bit integers do not work on Emscripten targets so we need an
501// additional `#[cfg]`
502serde_if_integer128! {
503    nonzero_integers! {
504        NonZeroU128,
505    }
506
507    #[cfg(num_nonzero_signed)]
508    nonzero_integers! {
509        NonZeroI128,
510    }
511}
512
513impl<T> Serialize for Cell<T>
514where
515    T: Serialize + Copy,
516{
517    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
518    where
519        S: Serializer,
520    {
521        self.get().serialize(serializer)
522    }
523}
524
525impl<T> Serialize for RefCell<T>
526where
527    T: Serialize,
528{
529    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
530    where
531        S: Serializer,
532    {
533        match self.try_borrow() {
534            Ok(value) => value.serialize(serializer),
535            Err(_) => Err(S::Error::custom("already mutably borrowed")),
536        }
537    }
538}
539
540#[cfg(feature = "std")]
541impl<T> Serialize for Mutex<T>
542where
543    T: Serialize,
544{
545    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
546    where
547        S: Serializer,
548    {
549        match self.lock() {
550            Ok(locked) => locked.serialize(serializer),
551            Err(_) => Err(S::Error::custom("lock poison error while serializing")),
552        }
553    }
554}
555
556#[cfg(feature = "std")]
557impl<T> Serialize for RwLock<T>
558where
559    T: Serialize,
560{
561    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
562    where
563        S: Serializer,
564    {
565        match self.read() {
566            Ok(locked) => locked.serialize(serializer),
567            Err(_) => Err(S::Error::custom("lock poison error while serializing")),
568        }
569    }
570}
571
572////////////////////////////////////////////////////////////////////////////////
573
574impl<T, E> Serialize for Result<T, E>
575where
576    T: Serialize,
577    E: Serialize,
578{
579    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
580    where
581        S: Serializer,
582    {
583        match *self {
584            Result::Ok(ref value) => serializer.serialize_newtype_variant("Result", 0, "Ok", value),
585            Result::Err(ref value) => {
586                serializer.serialize_newtype_variant("Result", 1, "Err", value)
587            }
588        }
589    }
590}
591
592////////////////////////////////////////////////////////////////////////////////
593
594#[cfg(any(core_duration, feature = "std"))]
595impl Serialize for Duration {
596    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
597    where
598        S: Serializer,
599    {
600        use super::SerializeStruct;
601        let mut state = try!(serializer.serialize_struct("Duration", 2));
602        try!(state.serialize_field("secs", &self.as_secs()));
603        try!(state.serialize_field("nanos", &self.subsec_nanos()));
604        state.end()
605    }
606}
607
608////////////////////////////////////////////////////////////////////////////////
609
610#[cfg(feature = "std")]
611impl Serialize for SystemTime {
612    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
613    where
614        S: Serializer,
615    {
616        use super::SerializeStruct;
617        let duration_since_epoch = self
618            .duration_since(UNIX_EPOCH)
619            .map_err(|_| S::Error::custom("SystemTime must be later than UNIX_EPOCH"))?;
620        let mut state = try!(serializer.serialize_struct("SystemTime", 2));
621        try!(state.serialize_field("secs_since_epoch", &duration_since_epoch.as_secs()));
622        try!(state.serialize_field("nanos_since_epoch", &duration_since_epoch.subsec_nanos()));
623        state.end()
624    }
625}
626
627////////////////////////////////////////////////////////////////////////////////
628
629/// Serialize a value that implements `Display` as a string, when that string is
630/// statically known to never have more than a constant `MAX_LEN` bytes.
631///
632/// Panics if the `Display` impl tries to write more than `MAX_LEN` bytes.
633#[cfg(feature = "std")]
634macro_rules! serialize_display_bounded_length {
635    ($value:expr, $max:expr, $serializer:expr) => {{
636        let mut buffer = [0u8; $max];
637        let remaining_len = {
638            let mut remaining = &mut buffer[..];
639            write!(remaining, "{}", $value).unwrap();
640            remaining.len()
641        };
642        let written_len = buffer.len() - remaining_len;
643        let written = &buffer[..written_len];
644
645        // write! only provides fmt::Formatter to Display implementations, which
646        // has methods write_str and write_char but no method to write arbitrary
647        // bytes. Therefore `written` must be valid UTF-8.
648        let written_str = str::from_utf8(written).expect("must be valid UTF-8");
649        $serializer.serialize_str(written_str)
650    }};
651}
652
653#[cfg(feature = "std")]
654impl Serialize for net::IpAddr {
655    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
656    where
657        S: Serializer,
658    {
659        if serializer.is_human_readable() {
660            match *self {
661                net::IpAddr::V4(ref a) => a.serialize(serializer),
662                net::IpAddr::V6(ref a) => a.serialize(serializer),
663            }
664        } else {
665            match *self {
666                net::IpAddr::V4(ref a) => {
667                    serializer.serialize_newtype_variant("IpAddr", 0, "V4", a)
668                }
669                net::IpAddr::V6(ref a) => {
670                    serializer.serialize_newtype_variant("IpAddr", 1, "V6", a)
671                }
672            }
673        }
674    }
675}
676
677#[cfg(feature = "std")]
678impl Serialize for net::Ipv4Addr {
679    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
680    where
681        S: Serializer,
682    {
683        if serializer.is_human_readable() {
684            const MAX_LEN: usize = 15;
685            debug_assert_eq!(MAX_LEN, "101.102.103.104".len());
686            serialize_display_bounded_length!(self, MAX_LEN, serializer)
687        } else {
688            self.octets().serialize(serializer)
689        }
690    }
691}
692
693#[cfg(feature = "std")]
694impl Serialize for net::Ipv6Addr {
695    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
696    where
697        S: Serializer,
698    {
699        if serializer.is_human_readable() {
700            const MAX_LEN: usize = 39;
701            debug_assert_eq!(MAX_LEN, "1001:1002:1003:1004:1005:1006:1007:1008".len());
702            serialize_display_bounded_length!(self, MAX_LEN, serializer)
703        } else {
704            self.octets().serialize(serializer)
705        }
706    }
707}
708
709#[cfg(feature = "std")]
710impl Serialize for net::SocketAddr {
711    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
712    where
713        S: Serializer,
714    {
715        if serializer.is_human_readable() {
716            match *self {
717                net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
718                net::SocketAddr::V6(ref addr) => addr.serialize(serializer),
719            }
720        } else {
721            match *self {
722                net::SocketAddr::V4(ref addr) => {
723                    serializer.serialize_newtype_variant("SocketAddr", 0, "V4", addr)
724                }
725                net::SocketAddr::V6(ref addr) => {
726                    serializer.serialize_newtype_variant("SocketAddr", 1, "V6", addr)
727                }
728            }
729        }
730    }
731}
732
733#[cfg(feature = "std")]
734impl Serialize for net::SocketAddrV4 {
735    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
736    where
737        S: Serializer,
738    {
739        if serializer.is_human_readable() {
740            const MAX_LEN: usize = 21;
741            debug_assert_eq!(MAX_LEN, "101.102.103.104:65000".len());
742            serialize_display_bounded_length!(self, MAX_LEN, serializer)
743        } else {
744            (self.ip(), self.port()).serialize(serializer)
745        }
746    }
747}
748
749#[cfg(feature = "std")]
750impl Serialize for net::SocketAddrV6 {
751    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
752    where
753        S: Serializer,
754    {
755        if serializer.is_human_readable() {
756            const MAX_LEN: usize = 47;
757            debug_assert_eq!(
758                MAX_LEN,
759                "[1001:1002:1003:1004:1005:1006:1007:1008]:65000".len()
760            );
761            serialize_display_bounded_length!(self, MAX_LEN, serializer)
762        } else {
763            (self.ip(), self.port()).serialize(serializer)
764        }
765    }
766}
767
768////////////////////////////////////////////////////////////////////////////////
769
770#[cfg(feature = "std")]
771impl Serialize for Path {
772    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
773    where
774        S: Serializer,
775    {
776        match self.to_str() {
777            Some(s) => s.serialize(serializer),
778            None => Err(Error::custom("path contains invalid UTF-8 characters")),
779        }
780    }
781}
782
783#[cfg(feature = "std")]
784impl Serialize for PathBuf {
785    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
786    where
787        S: Serializer,
788    {
789        self.as_path().serialize(serializer)
790    }
791}
792
793#[cfg(all(feature = "std", any(unix, windows)))]
794impl Serialize for OsStr {
795    #[cfg(unix)]
796    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
797    where
798        S: Serializer,
799    {
800        use std::os::unix::ffi::OsStrExt;
801        serializer.serialize_newtype_variant("OsString", 0, "Unix", self.as_bytes())
802    }
803
804    #[cfg(windows)]
805    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
806    where
807        S: Serializer,
808    {
809        use std::os::windows::ffi::OsStrExt;
810        let val = self.encode_wide().collect::<Vec<_>>();
811        serializer.serialize_newtype_variant("OsString", 1, "Windows", &val)
812    }
813}
814
815#[cfg(all(feature = "std", any(unix, windows)))]
816impl Serialize for OsString {
817    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
818    where
819        S: Serializer,
820    {
821        self.as_os_str().serialize(serializer)
822    }
823}
824
825////////////////////////////////////////////////////////////////////////////////
826
827#[cfg(feature = "std")]
828impl<T> Serialize for Wrapping<T>
829where
830    T: Serialize,
831{
832    #[inline]
833    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
834    where
835        S: Serializer,
836    {
837        self.0.serialize(serializer)
838    }
839}
840
841#[cfg(core_reverse)]
842impl<T> Serialize for Reverse<T>
843where
844    T: Serialize,
845{
846    #[inline]
847    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
848    where
849        S: Serializer,
850    {
851        self.0.serialize(serializer)
852    }
853}
854
855////////////////////////////////////////////////////////////////////////////////
856
857#[cfg(all(feature = "std", std_atomic))]
858macro_rules! atomic_impl {
859    ($($ty:ident)*) => {
860        $(
861            impl Serialize for $ty {
862                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
863                where
864                    S: Serializer,
865                {
866                    self.load(Ordering::SeqCst).serialize(serializer)
867                }
868            }
869        )*
870    }
871}
872
873#[cfg(all(feature = "std", std_atomic))]
874atomic_impl! {
875    AtomicBool
876    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
877    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
878}
879
880#[cfg(all(feature = "std", std_atomic64))]
881atomic_impl! {
882    AtomicI64 AtomicU64
883}