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] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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> { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 ! { serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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)] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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)] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 } 825