1use crate::lib::*;
2
3use crate::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!(i128, serialize_i128);
28primitive_impl!(usize, serialize_u64 as u64);
29primitive_impl!(u8, serialize_u8);
30primitive_impl!(u16, serialize_u16);
31primitive_impl!(u32, serialize_u32);
32primitive_impl!(u64, serialize_u64);
33primitive_impl!(u128, serialize_u128);
34primitive_impl!(f32, serialize_f32);
35primitive_impl!(f64, serialize_f64);
36primitive_impl!(char, serialize_char);
37
38////////////////////////////////////////////////////////////////////////////////
39
40impl Serialize for str {
41 #[inline]
42 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
43 where
44 S: Serializer,
45 {
46 serializer.serialize_str(self)
47 }
48}
49
50#[cfg(any(feature = "std", feature = "alloc"))]
51#[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
52impl Serialize for String {
53 #[inline]
54 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
55 where
56 S: Serializer,
57 {
58 serializer.serialize_str(self)
59 }
60}
61
62impl<'a> Serialize for fmt::Arguments<'a> {
63 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
64 where
65 S: Serializer,
66 {
67 serializer.collect_str(self)
68 }
69}
70
71////////////////////////////////////////////////////////////////////////////////
72
73#[cfg(any(feature = "std", not(no_core_cstr)))]
74#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
75impl Serialize for CStr {
76 #[inline]
77 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
78 where
79 S: Serializer,
80 {
81 serializer.serialize_bytes(self.to_bytes())
82 }
83}
84
85#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
86#[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
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: &T) => serializer.serialize_some(value),
110 None => serializer.serialize_none(),
111 }
112 }
113}
114
115////////////////////////////////////////////////////////////////////////////////
116
117impl<T> Serialize for PhantomData<T>
118where
119 T: ?Sized,
120{
121 #[inline]
122 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
123 where
124 S: Serializer,
125 {
126 serializer.serialize_unit_struct(name:"PhantomData")
127 }
128}
129
130////////////////////////////////////////////////////////////////////////////////
131
132// Does not require T: Serialize.
133impl<T> Serialize for [T; 0] {
134 #[inline]
135 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
136 where
137 S: Serializer,
138 {
139 tri!(serializer.serialize_tuple(0)).end()
140 }
141}
142
143macro_rules! array_impls {
144 ($($len:tt)+) => {
145 $(
146 impl<T> Serialize for [T; $len]
147 where
148 T: Serialize,
149 {
150 #[inline]
151 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
152 where
153 S: Serializer,
154 {
155 let mut seq = tri!(serializer.serialize_tuple($len));
156 for e in self {
157 tri!(seq.serialize_element(e));
158 }
159 seq.end()
160 }
161 }
162 )+
163 }
164}
165
166array_impls! {
167 01 02 03 04 05 06 07 08 09 10
168 11 12 13 14 15 16 17 18 19 20
169 21 22 23 24 25 26 27 28 29 30
170 31 32
171}
172
173////////////////////////////////////////////////////////////////////////////////
174
175impl<T> Serialize for [T]
176where
177 T: Serialize,
178{
179 #[inline]
180 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
181 where
182 S: Serializer,
183 {
184 serializer.collect_seq(self)
185 }
186}
187
188#[cfg(not(no_relaxed_trait_bounds))]
189macro_rules! seq_impl {
190 (
191 $(#[$attr:meta])*
192 $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>
193 ) => {
194 $(#[$attr])*
195 impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
196 where
197 T: Serialize,
198 {
199 #[inline]
200 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
201 where
202 S: Serializer,
203 {
204 serializer.collect_seq(self)
205 }
206 }
207 }
208}
209
210#[cfg(no_relaxed_trait_bounds)]
211macro_rules! seq_impl {
212 (
213 $(#[$attr:meta])*
214 $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>
215 ) => {
216 $(#[$attr])*
217 impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
218 where
219 T: Serialize $(+ $tbound1 $(+ $tbound2)*)*,
220 $($typaram: $bound,)*
221 {
222 #[inline]
223 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
224 where
225 S: Serializer,
226 {
227 serializer.collect_seq(self)
228 }
229 }
230 }
231}
232
233seq_impl! {
234 #[cfg(any(feature = "std", feature = "alloc"))]
235 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
236 BinaryHeap<T: Ord>
237}
238
239seq_impl! {
240 #[cfg(any(feature = "std", feature = "alloc"))]
241 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
242 BTreeSet<T: Ord>
243}
244
245seq_impl! {
246 #[cfg(feature = "std")]
247 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
248 HashSet<T: Eq + Hash, H: BuildHasher>
249}
250
251seq_impl! {
252 #[cfg(any(feature = "std", feature = "alloc"))]
253 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
254 LinkedList<T>
255}
256
257seq_impl! {
258 #[cfg(any(feature = "std", feature = "alloc"))]
259 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
260 Vec<T>
261}
262
263seq_impl! {
264 #[cfg(any(feature = "std", feature = "alloc"))]
265 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
266 VecDeque<T>
267}
268
269////////////////////////////////////////////////////////////////////////////////
270
271impl<Idx> Serialize for Range<Idx>
272where
273 Idx: Serialize,
274{
275 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
276 where
277 S: Serializer,
278 {
279 use super::SerializeStruct;
280 let mut state: ::SerializeStruct = tri!(serializer.serialize_struct("Range", 2));
281 tri!(state.serialize_field("start", &self.start));
282 tri!(state.serialize_field("end", &self.end));
283 state.end()
284 }
285}
286
287////////////////////////////////////////////////////////////////////////////////
288
289impl<Idx> Serialize for RangeFrom<Idx>
290where
291 Idx: Serialize,
292{
293 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
294 where
295 S: Serializer,
296 {
297 use super::SerializeStruct;
298 let mut state: ::SerializeStruct = tri!(serializer.serialize_struct("RangeFrom", 1));
299 tri!(state.serialize_field("start", &self.start));
300 state.end()
301 }
302}
303
304////////////////////////////////////////////////////////////////////////////////
305
306impl<Idx> Serialize for RangeInclusive<Idx>
307where
308 Idx: Serialize,
309{
310 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
311 where
312 S: Serializer,
313 {
314 use super::SerializeStruct;
315 let mut state: ::SerializeStruct = tri!(serializer.serialize_struct("RangeInclusive", 2));
316 tri!(state.serialize_field("start", &self.start()));
317 tri!(state.serialize_field("end", &self.end()));
318 state.end()
319 }
320}
321
322////////////////////////////////////////////////////////////////////////////////
323
324impl<Idx> Serialize for RangeTo<Idx>
325where
326 Idx: Serialize,
327{
328 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
329 where
330 S: Serializer,
331 {
332 use super::SerializeStruct;
333 let mut state: ::SerializeStruct = tri!(serializer.serialize_struct("RangeTo", 1));
334 tri!(state.serialize_field("end", &self.end));
335 state.end()
336 }
337}
338
339////////////////////////////////////////////////////////////////////////////////
340
341impl<T> Serialize for Bound<T>
342where
343 T: Serialize,
344{
345 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
346 where
347 S: Serializer,
348 {
349 match *self {
350 Bound::Unbounded => serializer.serialize_unit_variant(name:"Bound", variant_index:0, variant:"Unbounded"),
351 Bound::Included(ref value: &T) => {
352 serializer.serialize_newtype_variant(name:"Bound", variant_index:1, variant:"Included", value)
353 }
354 Bound::Excluded(ref value: &T) => {
355 serializer.serialize_newtype_variant(name:"Bound", variant_index:2, variant:"Excluded", value)
356 }
357 }
358 }
359}
360
361////////////////////////////////////////////////////////////////////////////////
362
363impl Serialize for () {
364 #[inline]
365 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
366 where
367 S: Serializer,
368 {
369 serializer.serialize_unit()
370 }
371}
372
373#[cfg(feature = "unstable")]
374#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
375impl Serialize for ! {
376 fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
377 where
378 S: Serializer,
379 {
380 *self
381 }
382}
383
384////////////////////////////////////////////////////////////////////////////////
385
386macro_rules! tuple_impls {
387 ($($len:expr => ($($n:tt $name:ident)+))+) => {
388 $(
389 #[cfg_attr(docsrs, doc(hidden))]
390 impl<$($name),+> Serialize for ($($name,)+)
391 where
392 $($name: Serialize,)+
393 {
394 tuple_impl_body!($len => ($($n)+));
395 }
396 )+
397 };
398}
399
400macro_rules! tuple_impl_body {
401 ($len:expr => ($($n:tt)+)) => {
402 #[inline]
403 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
404 where
405 S: Serializer,
406 {
407 let mut tuple = tri!(serializer.serialize_tuple($len));
408 $(
409 tri!(tuple.serialize_element(&self.$n));
410 )+
411 tuple.end()
412 }
413 };
414}
415
416#[cfg_attr(docsrs, doc(fake_variadic))]
417#[cfg_attr(
418 docsrs,
419 doc = "This trait is implemented for tuples up to 16 items long."
420)]
421impl<T> Serialize for (T,)
422where
423 T: Serialize,
424{
425 tuple_impl_body!(1 => (0));
426}
427
428tuple_impls! {
429 2 => (0 T0 1 T1)
430 3 => (0 T0 1 T1 2 T2)
431 4 => (0 T0 1 T1 2 T2 3 T3)
432 5 => (0 T0 1 T1 2 T2 3 T3 4 T4)
433 6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
434 7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
435 8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
436 9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
437 10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
438 11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
439 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)
440 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)
441 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)
442 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)
443 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)
444}
445
446////////////////////////////////////////////////////////////////////////////////
447
448#[cfg(not(no_relaxed_trait_bounds))]
449macro_rules! map_impl {
450 (
451 $(#[$attr:meta])*
452 $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>
453 ) => {
454 $(#[$attr])*
455 impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
456 where
457 K: Serialize,
458 V: Serialize,
459 {
460 #[inline]
461 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
462 where
463 S: Serializer,
464 {
465 serializer.collect_map(self)
466 }
467 }
468 }
469}
470
471#[cfg(no_relaxed_trait_bounds)]
472macro_rules! map_impl {
473 (
474 $(#[$attr:meta])*
475 $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>
476 ) => {
477 $(#[$attr])*
478 impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
479 where
480 K: Serialize $(+ $kbound1 $(+ $kbound2)*)*,
481 V: Serialize,
482 $($typaram: $bound,)*
483 {
484 #[inline]
485 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
486 where
487 S: Serializer,
488 {
489 serializer.collect_map(self)
490 }
491 }
492 }
493}
494
495map_impl! {
496 #[cfg(any(feature = "std", feature = "alloc"))]
497 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
498 BTreeMap<K: Ord, V>
499}
500
501map_impl! {
502 #[cfg(feature = "std")]
503 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
504 HashMap<K: Eq + Hash, V, H: BuildHasher>
505}
506
507////////////////////////////////////////////////////////////////////////////////
508
509macro_rules! deref_impl {
510 (
511 $(#[$attr:meta])*
512 <$($desc:tt)+
513 ) => {
514 $(#[$attr])*
515 impl <$($desc)+ {
516 #[inline]
517 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
518 where
519 S: Serializer,
520 {
521 (**self).serialize(serializer)
522 }
523 }
524 };
525}
526
527deref_impl! {
528 <'a, T> Serialize for &'a T where T: ?Sized + Serialize
529}
530
531deref_impl! {
532 <'a, T> Serialize for &'a mut T where T: ?Sized + Serialize
533}
534
535deref_impl! {
536 #[cfg(any(feature = "std", feature = "alloc"))]
537 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
538 <T> Serialize for Box<T> where T: ?Sized + Serialize
539}
540
541deref_impl! {
542 /// This impl requires the [`"rc"`] Cargo feature of Serde.
543 ///
544 /// Serializing a data structure containing `Rc` will serialize a copy of
545 /// the contents of the `Rc` each time the `Rc` is referenced within the
546 /// data structure. Serialization will not attempt to deduplicate these
547 /// repeated data.
548 ///
549 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
550 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
551 #[cfg_attr(docsrs, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
552 <T> Serialize for Rc<T> where T: ?Sized + Serialize
553}
554
555deref_impl! {
556 /// This impl requires the [`"rc"`] Cargo feature of Serde.
557 ///
558 /// Serializing a data structure containing `Arc` will serialize a copy of
559 /// the contents of the `Arc` each time the `Arc` is referenced within the
560 /// data structure. Serialization will not attempt to deduplicate these
561 /// repeated data.
562 ///
563 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
564 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
565 #[cfg_attr(docsrs, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
566 <T> Serialize for Arc<T> where T: ?Sized + Serialize
567}
568
569deref_impl! {
570 #[cfg(any(feature = "std", feature = "alloc"))]
571 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
572 <'a, T> Serialize for Cow<'a, T> where T: ?Sized + Serialize + ToOwned
573}
574
575////////////////////////////////////////////////////////////////////////////////
576
577/// This impl requires the [`"rc"`] Cargo feature of Serde.
578///
579/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
580#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
581#[cfg_attr(
582 docsrs,
583 doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
584)]
585impl<T> Serialize for RcWeak<T>
586where
587 T: ?Sized + Serialize,
588{
589 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
590 where
591 S: Serializer,
592 {
593 self.upgrade().serialize(serializer)
594 }
595}
596
597/// This impl requires the [`"rc"`] Cargo feature of Serde.
598///
599/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
600#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
601#[cfg_attr(
602 docsrs,
603 doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
604)]
605impl<T> Serialize for ArcWeak<T>
606where
607 T: ?Sized + Serialize,
608{
609 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
610 where
611 S: Serializer,
612 {
613 self.upgrade().serialize(serializer)
614 }
615}
616
617////////////////////////////////////////////////////////////////////////////////
618
619macro_rules! nonzero_integers {
620 ($($T:ident,)+) => {
621 $(
622 impl Serialize for num::$T {
623 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
624 where
625 S: Serializer,
626 {
627 self.get().serialize(serializer)
628 }
629 }
630 )+
631 }
632}
633
634nonzero_integers! {
635 NonZeroU8,
636 NonZeroU16,
637 NonZeroU32,
638 NonZeroU64,
639 NonZeroU128,
640 NonZeroUsize,
641}
642
643#[cfg(not(no_num_nonzero_signed))]
644nonzero_integers! {
645 NonZeroI8,
646 NonZeroI16,
647 NonZeroI32,
648 NonZeroI64,
649 NonZeroI128,
650 NonZeroIsize,
651}
652
653impl<T> Serialize for Cell<T>
654where
655 T: Serialize + Copy,
656{
657 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
658 where
659 S: Serializer,
660 {
661 self.get().serialize(serializer)
662 }
663}
664
665impl<T> Serialize for RefCell<T>
666where
667 T: ?Sized + Serialize,
668{
669 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
670 where
671 S: Serializer,
672 {
673 match self.try_borrow() {
674 Ok(value: Ref<'_, T>) => value.serialize(serializer),
675 Err(_) => Err(S::Error::custom(msg:"already mutably borrowed")),
676 }
677 }
678}
679
680#[cfg(feature = "std")]
681#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
682impl<T> Serialize for Mutex<T>
683where
684 T: ?Sized + Serialize,
685{
686 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
687 where
688 S: Serializer,
689 {
690 match self.lock() {
691 Ok(locked: MutexGuard<'_, T>) => locked.serialize(serializer),
692 Err(_) => Err(S::Error::custom(msg:"lock poison error while serializing")),
693 }
694 }
695}
696
697#[cfg(feature = "std")]
698#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
699impl<T> Serialize for RwLock<T>
700where
701 T: ?Sized + Serialize,
702{
703 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
704 where
705 S: Serializer,
706 {
707 match self.read() {
708 Ok(locked: RwLockReadGuard<'_, T>) => locked.serialize(serializer),
709 Err(_) => Err(S::Error::custom(msg:"lock poison error while serializing")),
710 }
711 }
712}
713
714////////////////////////////////////////////////////////////////////////////////
715
716impl<T, E> Serialize for Result<T, E>
717where
718 T: Serialize,
719 E: Serialize,
720{
721 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
722 where
723 S: Serializer,
724 {
725 match *self {
726 Result::Ok(ref value: &T) => serializer.serialize_newtype_variant(name:"Result", variant_index:0, variant:"Ok", value),
727 Result::Err(ref value: &E) => {
728 serializer.serialize_newtype_variant(name:"Result", variant_index:1, variant:"Err", value)
729 }
730 }
731 }
732}
733
734////////////////////////////////////////////////////////////////////////////////
735
736impl Serialize for Duration {
737 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
738 where
739 S: Serializer,
740 {
741 use super::SerializeStruct;
742 let mut state: ::SerializeStruct = tri!(serializer.serialize_struct("Duration", 2));
743 tri!(state.serialize_field("secs", &self.as_secs()));
744 tri!(state.serialize_field("nanos", &self.subsec_nanos()));
745 state.end()
746 }
747}
748
749////////////////////////////////////////////////////////////////////////////////
750
751#[cfg(feature = "std")]
752#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
753impl Serialize for SystemTime {
754 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
755 where
756 S: Serializer,
757 {
758 use super::SerializeStruct;
759 let duration_since_epoch: Duration = match self.duration_since(UNIX_EPOCH) {
760 Ok(duration_since_epoch: Duration) => duration_since_epoch,
761 Err(_) => return Err(S::Error::custom(msg:"SystemTime must be later than UNIX_EPOCH")),
762 };
763 let mut state: ::SerializeStruct = tri!(serializer.serialize_struct("SystemTime", 2));
764 tri!(state.serialize_field("secs_since_epoch", &duration_since_epoch.as_secs()));
765 tri!(state.serialize_field("nanos_since_epoch", &duration_since_epoch.subsec_nanos()));
766 state.end()
767 }
768}
769
770////////////////////////////////////////////////////////////////////////////////
771
772/// Serialize a value that implements `Display` as a string, when that string is
773/// statically known to never have more than a constant `MAX_LEN` bytes.
774///
775/// Panics if the `Display` impl tries to write more than `MAX_LEN` bytes.
776#[cfg(any(feature = "std", not(no_core_net)))]
777macro_rules! serialize_display_bounded_length {
778 ($value:expr, $max:expr, $serializer:expr) => {{
779 let mut buffer = [0u8; $max];
780 let mut writer = crate::format::Buf::new(&mut buffer);
781 write!(&mut writer, "{}", $value).unwrap();
782 $serializer.serialize_str(writer.as_str())
783 }};
784}
785
786#[cfg(any(feature = "std", not(no_core_net)))]
787impl Serialize for net::IpAddr {
788 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
789 where
790 S: Serializer,
791 {
792 if serializer.is_human_readable() {
793 match *self {
794 net::IpAddr::V4(ref a: &Ipv4Addr) => a.serialize(serializer),
795 net::IpAddr::V6(ref a: &Ipv6Addr) => a.serialize(serializer),
796 }
797 } else {
798 match *self {
799 net::IpAddr::V4(ref a: &Ipv4Addr) => {
800 serializer.serialize_newtype_variant(name:"IpAddr", variant_index:0, variant:"V4", value:a)
801 }
802 net::IpAddr::V6(ref a: &Ipv6Addr) => {
803 serializer.serialize_newtype_variant(name:"IpAddr", variant_index:1, variant:"V6", value:a)
804 }
805 }
806 }
807 }
808}
809
810#[cfg(any(feature = "std", not(no_core_net)))]
811const DEC_DIGITS_LUT: &[u8] = b"\
812 0001020304050607080910111213141516171819\
813 2021222324252627282930313233343536373839\
814 4041424344454647484950515253545556575859\
815 6061626364656667686970717273747576777879\
816 8081828384858687888990919293949596979899";
817
818#[cfg(any(feature = "std", not(no_core_net)))]
819#[inline]
820fn format_u8(mut n: u8, out: &mut [u8]) -> usize {
821 if n >= 100 {
822 let d1: usize = ((n % 100) << 1) as usize;
823 n /= 100;
824 out[0] = b'0' + n;
825 out[1] = DEC_DIGITS_LUT[d1];
826 out[2] = DEC_DIGITS_LUT[d1 + 1];
827 3
828 } else if n >= 10 {
829 let d1: usize = (n << 1) as usize;
830 out[0] = DEC_DIGITS_LUT[d1];
831 out[1] = DEC_DIGITS_LUT[d1 + 1];
832 2
833 } else {
834 out[0] = b'0' + n;
835 1
836 }
837}
838
839#[cfg(any(feature = "std", not(no_core_net)))]
840#[test]
841fn test_format_u8() {
842 let mut i = 0u8;
843
844 loop {
845 let mut buf = [0u8; 3];
846 let written = format_u8(i, &mut buf);
847 assert_eq!(i.to_string().as_bytes(), &buf[..written]);
848
849 match i.checked_add(1) {
850 Some(next) => i = next,
851 None => break,
852 }
853 }
854}
855
856#[cfg(any(feature = "std", not(no_core_net)))]
857impl Serialize for net::Ipv4Addr {
858 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
859 where
860 S: Serializer,
861 {
862 if serializer.is_human_readable() {
863 const MAX_LEN: usize = 15;
864 debug_assert_eq!(MAX_LEN, "101.102.103.104".len());
865 let mut buf: [u8; 15] = [b'.'; MAX_LEN];
866 let mut written: usize = format_u8(self.octets()[0], &mut buf);
867 for oct: &u8 in &self.octets()[1..] {
868 // Skip over delimiters that we initialized buf with
869 written += format_u8(*oct, &mut buf[written + 1..]) + 1;
870 }
871 // Safety: We've only written ASCII bytes to the buffer, so it is valid UTF-8
872 let buf: &str = unsafe { str::from_utf8_unchecked(&buf[..written]) };
873 serializer.serialize_str(buf)
874 } else {
875 self.octets().serialize(serializer)
876 }
877 }
878}
879
880#[cfg(any(feature = "std", not(no_core_net)))]
881impl Serialize for net::Ipv6Addr {
882 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
883 where
884 S: Serializer,
885 {
886 if serializer.is_human_readable() {
887 const MAX_LEN: usize = 39;
888 debug_assert_eq!(MAX_LEN, "1001:1002:1003:1004:1005:1006:1007:1008".len());
889 serialize_display_bounded_length!(self, MAX_LEN, serializer)
890 } else {
891 self.octets().serialize(serializer)
892 }
893 }
894}
895
896#[cfg(any(feature = "std", not(no_core_net)))]
897impl Serialize for net::SocketAddr {
898 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
899 where
900 S: Serializer,
901 {
902 if serializer.is_human_readable() {
903 match *self {
904 net::SocketAddr::V4(ref addr: &SocketAddrV4) => addr.serialize(serializer),
905 net::SocketAddr::V6(ref addr: &SocketAddrV6) => addr.serialize(serializer),
906 }
907 } else {
908 match *self {
909 net::SocketAddr::V4(ref addr: &SocketAddrV4) => {
910 serializer.serialize_newtype_variant(name:"SocketAddr", variant_index:0, variant:"V4", value:addr)
911 }
912 net::SocketAddr::V6(ref addr: &SocketAddrV6) => {
913 serializer.serialize_newtype_variant(name:"SocketAddr", variant_index:1, variant:"V6", value:addr)
914 }
915 }
916 }
917 }
918}
919
920#[cfg(any(feature = "std", not(no_core_net)))]
921impl Serialize for net::SocketAddrV4 {
922 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
923 where
924 S: Serializer,
925 {
926 if serializer.is_human_readable() {
927 const MAX_LEN: usize = 21;
928 debug_assert_eq!(MAX_LEN, "101.102.103.104:65000".len());
929 serialize_display_bounded_length!(self, MAX_LEN, serializer)
930 } else {
931 (self.ip(), self.port()).serialize(serializer)
932 }
933 }
934}
935
936#[cfg(any(feature = "std", not(no_core_net)))]
937impl Serialize for net::SocketAddrV6 {
938 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
939 where
940 S: Serializer,
941 {
942 if serializer.is_human_readable() {
943 const MAX_LEN: usize = 58;
944 debug_assert_eq!(
945 MAX_LEN,
946 "[1001:1002:1003:1004:1005:1006:1007:1008%4294967295]:65000".len()
947 );
948 serialize_display_bounded_length!(self, MAX_LEN, serializer)
949 } else {
950 (self.ip(), self.port()).serialize(serializer)
951 }
952 }
953}
954
955////////////////////////////////////////////////////////////////////////////////
956
957#[cfg(feature = "std")]
958#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
959impl Serialize for Path {
960 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
961 where
962 S: Serializer,
963 {
964 match self.to_str() {
965 Some(s: &str) => s.serialize(serializer),
966 None => Err(Error::custom(msg:"path contains invalid UTF-8 characters")),
967 }
968 }
969}
970
971#[cfg(feature = "std")]
972#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
973impl Serialize for PathBuf {
974 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
975 where
976 S: Serializer,
977 {
978 self.as_path().serialize(serializer)
979 }
980}
981
982#[cfg(all(feature = "std", any(unix, windows)))]
983#[cfg_attr(docsrs, doc(cfg(all(feature = "std", any(unix, windows)))))]
984impl Serialize for OsStr {
985 #[cfg(unix)]
986 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
987 where
988 S: Serializer,
989 {
990 use std::os::unix::ffi::OsStrExt;
991 serializer.serialize_newtype_variant(name:"OsString", variant_index:0, variant:"Unix", self.as_bytes())
992 }
993
994 #[cfg(windows)]
995 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
996 where
997 S: Serializer,
998 {
999 use std::os::windows::ffi::OsStrExt;
1000 let val = self.encode_wide().collect::<Vec<_>>();
1001 serializer.serialize_newtype_variant("OsString", 1, "Windows", &val)
1002 }
1003}
1004
1005#[cfg(all(feature = "std", any(unix, windows)))]
1006#[cfg_attr(docsrs, doc(cfg(all(feature = "std", any(unix, windows)))))]
1007impl Serialize for OsString {
1008 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1009 where
1010 S: Serializer,
1011 {
1012 self.as_os_str().serialize(serializer)
1013 }
1014}
1015
1016////////////////////////////////////////////////////////////////////////////////
1017
1018impl<T> Serialize for Wrapping<T>
1019where
1020 T: Serialize,
1021{
1022 #[inline]
1023 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1024 where
1025 S: Serializer,
1026 {
1027 self.0.serialize(serializer)
1028 }
1029}
1030
1031#[cfg(not(no_core_num_saturating))]
1032impl<T> Serialize for Saturating<T>
1033where
1034 T: Serialize,
1035{
1036 #[inline]
1037 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1038 where
1039 S: Serializer,
1040 {
1041 self.0.serialize(serializer)
1042 }
1043}
1044
1045impl<T> Serialize for Reverse<T>
1046where
1047 T: Serialize,
1048{
1049 #[inline]
1050 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1051 where
1052 S: Serializer,
1053 {
1054 self.0.serialize(serializer)
1055 }
1056}
1057
1058////////////////////////////////////////////////////////////////////////////////
1059
1060#[cfg(all(feature = "std", not(no_std_atomic)))]
1061macro_rules! atomic_impl {
1062 ($($ty:ident $size:expr)*) => {
1063 $(
1064 #[cfg(any(no_target_has_atomic, target_has_atomic = $size))]
1065 #[cfg_attr(docsrs, doc(cfg(all(feature = "std", target_has_atomic = $size))))]
1066 impl Serialize for $ty {
1067 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1068 where
1069 S: Serializer,
1070 {
1071 // Matches the atomic ordering used in libcore for the Debug impl
1072 self.load(Ordering::Relaxed).serialize(serializer)
1073 }
1074 }
1075 )*
1076 }
1077}
1078
1079#[cfg(all(feature = "std", not(no_std_atomic)))]
1080atomic_impl! {
1081 AtomicBool "8"
1082 AtomicI8 "8"
1083 AtomicI16 "16"
1084 AtomicI32 "32"
1085 AtomicIsize "ptr"
1086 AtomicU8 "8"
1087 AtomicU16 "16"
1088 AtomicU32 "32"
1089 AtomicUsize "ptr"
1090}
1091
1092#[cfg(all(feature = "std", not(no_std_atomic64)))]
1093atomic_impl! {
1094 AtomicI64 "64"
1095 AtomicU64 "64"
1096}
1097