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            .expect("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        #[allow(deprecated)]
637        let mut buffer: [u8; $max] = unsafe { mem::uninitialized() };
638        let remaining_len = {
639            let mut remaining = &mut buffer[..];
640            write!(remaining, "{}", $value).unwrap();
641            remaining.len()
642        };
643        let written_len = buffer.len() - remaining_len;
644        let written = &buffer[..written_len];
645
646        // write! only provides fmt::Formatter to Display implementations, which
647        // has methods write_str and write_char but no method to write arbitrary
648        // bytes. Therefore `written` must be valid UTF-8.
649        let written_str = unsafe { str::from_utf8_unchecked(written) };
650        $serializer.serialize_str(written_str)
651    }};
652}
653
654#[cfg(feature = "std")]
655impl Serialize for net::IpAddr {
656    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
657    where
658        S: Serializer,
659    {
660        if serializer.is_human_readable() {
661            match *self {
662                net::IpAddr::V4(ref a) => a.serialize(serializer),
663                net::IpAddr::V6(ref a) => a.serialize(serializer),
664            }
665        } else {
666            match *self {
667                net::IpAddr::V4(ref a) => {
668                    serializer.serialize_newtype_variant("IpAddr", 0, "V4", a)
669                }
670                net::IpAddr::V6(ref a) => {
671                    serializer.serialize_newtype_variant("IpAddr", 1, "V6", a)
672                }
673            }
674        }
675    }
676}
677
678#[cfg(feature = "std")]
679impl Serialize for net::Ipv4Addr {
680    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
681    where
682        S: Serializer,
683    {
684        if serializer.is_human_readable() {
685            const MAX_LEN: usize = 15;
686            debug_assert_eq!(MAX_LEN, "101.102.103.104".len());
687            serialize_display_bounded_length!(self, MAX_LEN, serializer)
688        } else {
689            self.octets().serialize(serializer)
690        }
691    }
692}
693
694#[cfg(feature = "std")]
695impl Serialize for net::Ipv6Addr {
696    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
697    where
698        S: Serializer,
699    {
700        if serializer.is_human_readable() {
701            const MAX_LEN: usize = 39;
702            debug_assert_eq!(MAX_LEN, "1001:1002:1003:1004:1005:1006:1007:1008".len());
703            serialize_display_bounded_length!(self, MAX_LEN, serializer)
704        } else {
705            self.octets().serialize(serializer)
706        }
707    }
708}
709
710#[cfg(feature = "std")]
711impl Serialize for net::SocketAddr {
712    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
713    where
714        S: Serializer,
715    {
716        if serializer.is_human_readable() {
717            match *self {
718                net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
719                net::SocketAddr::V6(ref addr) => addr.serialize(serializer),
720            }
721        } else {
722            match *self {
723                net::SocketAddr::V4(ref addr) => {
724                    serializer.serialize_newtype_variant("SocketAddr", 0, "V4", addr)
725                }
726                net::SocketAddr::V6(ref addr) => {
727                    serializer.serialize_newtype_variant("SocketAddr", 1, "V6", addr)
728                }
729            }
730        }
731    }
732}
733
734#[cfg(feature = "std")]
735impl Serialize for net::SocketAddrV4 {
736    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
737    where
738        S: Serializer,
739    {
740        if serializer.is_human_readable() {
741            const MAX_LEN: usize = 21;
742            debug_assert_eq!(MAX_LEN, "101.102.103.104:65000".len());
743            serialize_display_bounded_length!(self, MAX_LEN, serializer)
744        } else {
745            (self.ip(), self.port()).serialize(serializer)
746        }
747    }
748}
749
750#[cfg(feature = "std")]
751impl Serialize for net::SocketAddrV6 {
752    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
753    where
754        S: Serializer,
755    {
756        if serializer.is_human_readable() {
757            const MAX_LEN: usize = 47;
758            debug_assert_eq!(
759                MAX_LEN,
760                "[1001:1002:1003:1004:1005:1006:1007:1008]:65000".len()
761            );
762            serialize_display_bounded_length!(self, MAX_LEN, serializer)
763        } else {
764            (self.ip(), self.port()).serialize(serializer)
765        }
766    }
767}
768
769////////////////////////////////////////////////////////////////////////////////
770
771#[cfg(feature = "std")]
772impl Serialize for Path {
773    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
774    where
775        S: Serializer,
776    {
777        match self.to_str() {
778            Some(s) => s.serialize(serializer),
779            None => Err(Error::custom("path contains invalid UTF-8 characters")),
780        }
781    }
782}
783
784#[cfg(feature = "std")]
785impl Serialize for PathBuf {
786    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
787    where
788        S: Serializer,
789    {
790        self.as_path().serialize(serializer)
791    }
792}
793
794#[cfg(all(feature = "std", any(unix, windows)))]
795impl Serialize for OsStr {
796    #[cfg(unix)]
797    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
798    where
799        S: Serializer,
800    {
801        use std::os::unix::ffi::OsStrExt;
802        serializer.serialize_newtype_variant("OsString", 0, "Unix", self.as_bytes())
803    }
804
805    #[cfg(windows)]
806    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
807    where
808        S: Serializer,
809    {
810        use std::os::windows::ffi::OsStrExt;
811        let val = self.encode_wide().collect::<Vec<_>>();
812        serializer.serialize_newtype_variant("OsString", 1, "Windows", &val)
813    }
814}
815
816#[cfg(all(feature = "std", any(unix, windows)))]
817impl Serialize for OsString {
818    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
819    where
820        S: Serializer,
821    {
822        self.as_os_str().serialize(serializer)
823    }
824}
825
826////////////////////////////////////////////////////////////////////////////////
827
828#[cfg(feature = "std")]
829impl<T> Serialize for Wrapping<T>
830where
831    T: Serialize,
832{
833    #[inline]
834    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
835    where
836        S: Serializer,
837    {
838        self.0.serialize(serializer)
839    }
840}
841
842#[cfg(core_reverse)]
843impl<T> Serialize for Reverse<T>
844where
845    T: Serialize,
846{
847    #[inline]
848    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
849    where
850        S: Serializer,
851    {
852        self.0.serialize(serializer)
853    }
854}
855
856////////////////////////////////////////////////////////////////////////////////
857
858#[cfg(all(feature = "std", std_atomic))]
859macro_rules! atomic_impl {
860    ($($ty:ident)*) => {
861        $(
862            impl Serialize for $ty {
863                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
864                where
865                    S: Serializer,
866                {
867                    self.load(Ordering::SeqCst).serialize(serializer)
868                }
869            }
870        )*
871    }
872}
873
874#[cfg(all(feature = "std", std_atomic))]
875atomic_impl! {
876    AtomicBool
877    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
878    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
879}
880
881#[cfg(all(feature = "std", std_atomic64))]
882atomic_impl! {
883    AtomicI64 AtomicU64
884}