vendor/serde/src/ser/impls.rs

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