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 .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#[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 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#[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#[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#[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}