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! { 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 170 //////////////////////////////////////////////////////////////////////////////// 171 172 impl<T> Serialize for [T] 173 where 174 T: Serialize, 175 { 176 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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"))] 186 macro_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"))] 205 seq_impl!(BinaryHeap<T: Ord>); 206 207 #[cfg(any(feature = "std", feature = "alloc"))] 208 seq_impl!(BTreeSet<T: Ord>); 209 210 #[cfg(feature = "std")] 211 seq_impl!(HashSet<T: Eq + Hash, H: BuildHasher>); 212 213 #[cfg(any(feature = "std", feature = "alloc"))] 214 seq_impl!(LinkedList<T>); 215 216 #[cfg(any(feature = "std", feature = "alloc"))] 217 seq_impl!(Vec<T>); 218 219 #[cfg(any(feature = "std", feature = "alloc"))] 220 seq_impl!(VecDeque<T>); 221 222 //////////////////////////////////////////////////////////////////////////////// 223 224 impl<Idx> Serialize for Range<Idx> 225 where 226 Idx: Serialize, 227 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 //////////////////////////////////////////////////////////////////////////////// 241 242 #[cfg(range_inclusive)] 243 impl<Idx> Serialize for RangeInclusive<Idx> 244 where 245 Idx: Serialize, 246 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 //////////////////////////////////////////////////////////////////////////////// 260 261 #[cfg(any(ops_bound, collections_bound))] 262 impl<T> Serialize for Bound<T> 263 where 264 T: Serialize, 265 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 282 //////////////////////////////////////////////////////////////////////////////// 283 284 impl Serialize for () { 285 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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")] 295 impl Serialize for ! { serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,296 fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error> 297 where 298 S: Serializer, 299 { 300 *self 301 } 302 } 303 304 //////////////////////////////////////////////////////////////////////////////// 305 306 macro_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 329 tuple_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 //////////////////////////////////////////////////////////////////////////////// 349 350 #[cfg(any(feature = "std", feature = "alloc"))] 351 macro_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"))] 371 map_impl!(BTreeMap<K: Ord, V>); 372 373 #[cfg(feature = "std")] 374 map_impl!(HashMap<K: Eq + Hash, V, H: BuildHasher>); 375 376 //////////////////////////////////////////////////////////////////////////////// 377 378 macro_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 396 deref_impl!(<'a, T: ?Sized> Serialize for &'a T where T: Serialize); 397 deref_impl!(<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize); 398 399 #[cfg(any(feature = "std", feature = "alloc"))] 400 deref_impl!(<T: ?Sized> Serialize for Box<T> where T: Serialize); 401 402 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] 403 deref_impl! { 404 /// This impl requires the [`"rc"`] Cargo feature of Serde. 405 /// 406 /// Serializing a data structure containing `Rc` will serialize a copy of 407 /// the contents of the `Rc` each time the `Rc` is referenced within the 408 /// data structure. Serialization will not attempt to deduplicate these 409 /// repeated data. 410 /// 411 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc 412 <T: ?Sized> Serialize for Rc<T> where T: Serialize 413 } 414 415 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] 416 deref_impl! { 417 /// This impl requires the [`"rc"`] Cargo feature of Serde. 418 /// 419 /// Serializing a data structure containing `Arc` will serialize a copy of 420 /// the contents of the `Arc` each time the `Arc` is referenced within the 421 /// data structure. Serialization will not attempt to deduplicate these 422 /// repeated data. 423 /// 424 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc 425 <T: ?Sized> Serialize for Arc<T> where T: Serialize 426 } 427 428 #[cfg(any(feature = "std", feature = "alloc"))] 429 deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned); 430 431 //////////////////////////////////////////////////////////////////////////////// 432 433 /// This impl requires the [`"rc"`] Cargo feature of Serde. 434 /// 435 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc 436 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] 437 impl<T: ?Sized> Serialize for RcWeak<T> 438 where 439 T: Serialize, 440 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 /// This impl requires the [`"rc"`] Cargo feature of Serde. 450 /// 451 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc 452 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] 453 impl<T: ?Sized> Serialize for ArcWeak<T> 454 where 455 T: Serialize, 456 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 465 //////////////////////////////////////////////////////////////////////////////// 466 467 macro_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 483 nonzero_integers! { 484 NonZeroU8, 485 NonZeroU16, 486 NonZeroU32, 487 NonZeroU64, 488 NonZeroUsize, 489 } 490 491 #[cfg(num_nonzero_signed)] 492 nonzero_integers! { 493 NonZeroI8, 494 NonZeroI16, 495 NonZeroI32, 496 NonZeroI64, 497 NonZeroIsize, 498 } 499 500 // Currently 128-bit integers do not work on Emscripten targets so we need an 501 // additional `#[cfg]` 502 serde_if_integer128! { 503 nonzero_integers! { 504 NonZeroU128, 505 } 506 507 #[cfg(num_nonzero_signed)] 508 nonzero_integers! { 509 NonZeroI128, 510 } 511 } 512 513 impl<T> Serialize for Cell<T> 514 where 515 T: Serialize + Copy, 516 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 525 impl<T> Serialize for RefCell<T> 526 where 527 T: Serialize, 528 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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")] 541 impl<T> Serialize for Mutex<T> 542 where 543 T: Serialize, 544 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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")] 557 impl<T> Serialize for RwLock<T> 558 where 559 T: Serialize, 560 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 572 //////////////////////////////////////////////////////////////////////////////// 573 574 impl<T, E> Serialize for Result<T, E> 575 where 576 T: Serialize, 577 E: Serialize, 578 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 //////////////////////////////////////////////////////////////////////////////// 593 594 #[cfg(any(core_duration, feature = "std"))] 595 impl Serialize for Duration { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 //////////////////////////////////////////////////////////////////////////////// 609 610 #[cfg(feature = "std")] 611 impl Serialize for SystemTime { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 //////////////////////////////////////////////////////////////////////////////// 628 629 /// Serialize a value that implements `Display` as a string, when that string is 630 /// statically known to never have more than a constant `MAX_LEN` bytes. 631 /// 632 /// Panics if the `Display` impl tries to write more than `MAX_LEN` bytes. 633 #[cfg(feature = "std")] 634 macro_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 // write! only provides fmt::Formatter to Display implementations, which 646 // has methods write_str and write_char but no method to write arbitrary 647 // bytes. Therefore `written` must be valid UTF-8. 648 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")] 654 impl Serialize for net::IpAddr { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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")] 678 impl Serialize for net::Ipv4Addr { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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")] 694 impl Serialize for net::Ipv6Addr { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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")] 710 impl Serialize for net::SocketAddr { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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")] 734 impl Serialize for net::SocketAddrV4 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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")] 750 impl Serialize for net::SocketAddrV6 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 = 58; 757 debug_assert_eq!( 758 MAX_LEN, 759 "[1001:1002:1003:1004:1005:1006:1007:1008%4294967295]: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 //////////////////////////////////////////////////////////////////////////////// 769 770 #[cfg(feature = "std")] 771 impl Serialize for Path { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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")] 784 impl Serialize for PathBuf { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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)))] 794 impl Serialize for OsStr { 795 #[cfg(unix)] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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)] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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)))] 816 impl Serialize for OsString { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 //////////////////////////////////////////////////////////////////////////////// 826 827 impl<T> Serialize for Wrapping<T> 828 where 829 T: Serialize, 830 { 831 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,832 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 833 where 834 S: Serializer, 835 { 836 self.0.serialize(serializer) 837 } 838 } 839 840 #[cfg(core_reverse)] 841 impl<T> Serialize for Reverse<T> 842 where 843 T: Serialize, 844 { 845 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,846 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 847 where 848 S: Serializer, 849 { 850 self.0.serialize(serializer) 851 } 852 } 853 854 //////////////////////////////////////////////////////////////////////////////// 855 856 #[cfg(all(feature = "std", std_atomic))] 857 macro_rules! atomic_impl { 858 ($($ty:ident)*) => { 859 $( 860 impl Serialize for $ty { 861 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 862 where 863 S: Serializer, 864 { 865 self.load(Ordering::SeqCst).serialize(serializer) 866 } 867 } 868 )* 869 } 870 } 871 872 #[cfg(all(feature = "std", std_atomic))] 873 atomic_impl! { 874 AtomicBool 875 AtomicI8 AtomicI16 AtomicI32 AtomicIsize 876 AtomicU8 AtomicU16 AtomicU32 AtomicUsize 877 } 878 879 #[cfg(all(feature = "std", std_atomic64))] 880 atomic_impl! { 881 AtomicI64 AtomicU64 882 } 883