1use lib::*;
2
3use ser::{Error, Serialize, SerializeTuple, Serializer};
4
5macro_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
41impl 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#[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
97impl<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
115impl<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
127impl<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
170impl<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
222impl<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#[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#[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
282impl 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
304macro_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#[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
376macro_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 <T: ?Sized> Serialize for Rc<T> where T: Serialize
413}
414
415#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
416deref_impl! {
417 <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#[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#[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
465macro_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
500serde_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
572impl<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#[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#[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#[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 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#[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#[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#[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}