1 // Copyright 2017 Serde Developers 2 // 3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or 4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license 5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your 6 // option. This file may not be copied, modified, or distributed 7 // except according to those terms. 8 9 use lib::*; 10 11 use ser::{Serialize, SerializeTuple, Serializer}; 12 13 #[cfg(feature = "std")] 14 use ser::Error; 15 16 //////////////////////////////////////////////////////////////////////////////// 17 18 macro_rules! primitive_impl { 19 ($ty:ident, $method:ident $($cast:tt)*) => { 20 impl Serialize for $ty { 21 #[inline] 22 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 23 where 24 S: Serializer, 25 { 26 serializer.$method(*self $($cast)*) 27 } 28 } 29 } 30 } 31 32 primitive_impl!(bool, serialize_bool); 33 primitive_impl!(isize, serialize_i64 as i64); 34 primitive_impl!(i8, serialize_i8); 35 primitive_impl!(i16, serialize_i16); 36 primitive_impl!(i32, serialize_i32); 37 primitive_impl!(i64, serialize_i64); 38 primitive_impl!(usize, serialize_u64 as u64); 39 primitive_impl!(u8, serialize_u8); 40 primitive_impl!(u16, serialize_u16); 41 primitive_impl!(u32, serialize_u32); 42 primitive_impl!(u64, serialize_u64); 43 primitive_impl!(f32, serialize_f32); 44 primitive_impl!(f64, serialize_f64); 45 primitive_impl!(char, serialize_char); 46 47 //////////////////////////////////////////////////////////////////////////////// 48 49 impl Serialize for str { 50 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,51 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 52 where 53 S: Serializer, 54 { 55 serializer.serialize_str(self) 56 } 57 } 58 59 #[cfg(any(feature = "std", feature = "alloc"))] 60 impl Serialize for String { 61 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,62 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 63 where 64 S: Serializer, 65 { 66 serializer.serialize_str(self) 67 } 68 } 69 70 //////////////////////////////////////////////////////////////////////////////// 71 72 #[cfg(feature = "std")] 73 impl Serialize for CStr { 74 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,75 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 76 where 77 S: Serializer, 78 { 79 serializer.serialize_bytes(self.to_bytes()) 80 } 81 } 82 83 #[cfg(feature = "std")] 84 impl Serialize for CString { 85 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,86 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 87 where 88 S: Serializer, 89 { 90 serializer.serialize_bytes(self.to_bytes()) 91 } 92 } 93 94 //////////////////////////////////////////////////////////////////////////////// 95 96 impl<T> Serialize for Option<T> 97 where 98 T: Serialize, 99 { 100 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,101 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 102 where 103 S: Serializer, 104 { 105 match *self { 106 Some(ref value) => serializer.serialize_some(value), 107 None => serializer.serialize_none(), 108 } 109 } 110 } 111 112 //////////////////////////////////////////////////////////////////////////////// 113 114 impl<T: ?Sized> Serialize for PhantomData<T> { 115 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,116 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 117 where 118 S: Serializer, 119 { 120 serializer.serialize_unit_struct("PhantomData") 121 } 122 } 123 124 //////////////////////////////////////////////////////////////////////////////// 125 126 // Does not require T: Serialize. 127 impl<T> Serialize for [T; 0] { 128 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,129 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 130 where 131 S: Serializer, 132 { 133 try!(serializer.serialize_tuple(0)).end() 134 } 135 } 136 137 macro_rules! array_impls { 138 ($($len:tt)+) => { 139 $( 140 impl<T> Serialize for [T; $len] 141 where 142 T: Serialize, 143 { 144 #[inline] 145 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 146 where 147 S: Serializer, 148 { 149 let mut seq = try!(serializer.serialize_tuple($len)); 150 for e in self { 151 try!(seq.serialize_element(e)); 152 } 153 seq.end() 154 } 155 } 156 )+ 157 } 158 } 159 160 array_impls!(01 02 03 04 05 06 07 08 09 10 161 11 12 13 14 15 16 17 18 19 20 162 21 22 23 24 25 26 27 28 29 30 163 31 32); 164 165 //////////////////////////////////////////////////////////////////////////////// 166 167 impl<T> Serialize for [T] 168 where 169 T: Serialize, 170 { 171 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,172 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 173 where 174 S: Serializer, 175 { 176 serializer.collect_seq(self) 177 } 178 } 179 180 #[cfg(any(feature = "std", feature = "alloc"))] 181 macro_rules! seq_impl { 182 ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)* >) => { 183 impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*> 184 where 185 T: Serialize $(+ $tbound1 $(+ $tbound2)*)*, 186 $($typaram: $bound,)* 187 { 188 #[inline] 189 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 190 where 191 S: Serializer, 192 { 193 serializer.collect_seq(self) 194 } 195 } 196 } 197 } 198 199 #[cfg(any(feature = "std", feature = "alloc"))] 200 seq_impl!(BinaryHeap<T: Ord>); 201 202 #[cfg(any(feature = "std", feature = "alloc"))] 203 seq_impl!(BTreeSet<T: Ord>); 204 205 #[cfg(feature = "std")] 206 seq_impl!(HashSet<T: Eq + Hash, H: BuildHasher>); 207 208 #[cfg(any(feature = "std", feature = "alloc"))] 209 seq_impl!(LinkedList<T>); 210 211 #[cfg(any(feature = "std", feature = "alloc"))] 212 seq_impl!(Vec<T>); 213 214 #[cfg(any(feature = "std", feature = "alloc"))] 215 seq_impl!(VecDeque<T>); 216 217 //////////////////////////////////////////////////////////////////////////////// 218 219 #[cfg(feature = "std")] 220 impl<Idx> Serialize for ops::Range<Idx> 221 where 222 Idx: Serialize, 223 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,224 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 225 where 226 S: Serializer, 227 { 228 use super::SerializeStruct; 229 let mut state = try!(serializer.serialize_struct("Range", 2)); 230 try!(state.serialize_field("start", &self.start)); 231 try!(state.serialize_field("end", &self.end)); 232 state.end() 233 } 234 } 235 236 //////////////////////////////////////////////////////////////////////////////// 237 238 impl Serialize for () { 239 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,240 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 241 where 242 S: Serializer, 243 { 244 serializer.serialize_unit() 245 } 246 } 247 248 //////////////////////////////////////////////////////////////////////////////// 249 250 macro_rules! tuple_impls { 251 ($($len:expr => ($($n:tt $name:ident)+))+) => { 252 $( 253 impl<$($name),+> Serialize for ($($name,)+) 254 where 255 $($name: Serialize,)+ 256 { 257 #[inline] 258 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 259 where 260 S: Serializer, 261 { 262 let mut tuple = try!(serializer.serialize_tuple($len)); 263 $( 264 try!(tuple.serialize_element(&self.$n)); 265 )+ 266 tuple.end() 267 } 268 } 269 )+ 270 } 271 } 272 273 tuple_impls! { 274 1 => (0 T0) 275 2 => (0 T0 1 T1) 276 3 => (0 T0 1 T1 2 T2) 277 4 => (0 T0 1 T1 2 T2 3 T3) 278 5 => (0 T0 1 T1 2 T2 3 T3 4 T4) 279 6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5) 280 7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6) 281 8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7) 282 9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8) 283 10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9) 284 11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10) 285 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) 286 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) 287 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) 288 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) 289 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) 290 } 291 292 //////////////////////////////////////////////////////////////////////////////// 293 294 #[cfg(any(feature = "std", feature = "alloc"))] 295 macro_rules! map_impl { 296 ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)* >) => { 297 impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*> 298 where 299 K: Serialize $(+ $kbound1 $(+ $kbound2)*)*, 300 V: Serialize, 301 $($typaram: $bound,)* 302 { 303 #[inline] 304 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 305 where 306 S: Serializer, 307 { 308 serializer.collect_map(self) 309 } 310 } 311 } 312 } 313 314 #[cfg(any(feature = "std", feature = "alloc"))] 315 map_impl!(BTreeMap<K: Ord, V>); 316 317 #[cfg(feature = "std")] 318 map_impl!(HashMap<K: Eq + Hash, V, H: BuildHasher>); 319 320 //////////////////////////////////////////////////////////////////////////////// 321 322 macro_rules! deref_impl { 323 ($($desc:tt)+) => { 324 impl $($desc)+ { 325 #[inline] 326 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 327 where 328 S: Serializer, 329 { 330 (**self).serialize(serializer) 331 } 332 } 333 }; 334 } 335 336 deref_impl!(<'a, T: ?Sized> Serialize for &'a T where T: Serialize); 337 deref_impl!(<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize); 338 339 #[cfg(any(feature = "std", feature = "alloc"))] 340 deref_impl!(<T: ?Sized> Serialize for Box<T> where T: Serialize); 341 342 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] 343 deref_impl!(<T: ?Sized> Serialize for Rc<T> where T: Serialize); 344 345 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] 346 deref_impl!(<T: ?Sized> Serialize for Arc<T> where T: Serialize); 347 348 #[cfg(any(feature = "std", feature = "alloc"))] 349 deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned); 350 351 //////////////////////////////////////////////////////////////////////////////// 352 353 #[cfg(feature = "unstable")] 354 impl<T> Serialize for NonZero<T> 355 where 356 T: Serialize + Zeroable + Clone, 357 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,358 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 359 where 360 S: Serializer, 361 { 362 self.clone().get().serialize(serializer) 363 } 364 } 365 366 impl<T> Serialize for Cell<T> 367 where 368 T: Serialize + Copy, 369 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,370 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 371 where 372 S: Serializer, 373 { 374 self.get().serialize(serializer) 375 } 376 } 377 378 impl<T> Serialize for RefCell<T> 379 where 380 T: Serialize, 381 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,382 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 383 where 384 S: Serializer, 385 { 386 self.borrow().serialize(serializer) 387 } 388 } 389 390 #[cfg(feature = "std")] 391 impl<T> Serialize for Mutex<T> 392 where 393 T: Serialize, 394 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,395 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 396 where 397 S: Serializer, 398 { 399 match self.lock() { 400 Ok(locked) => locked.serialize(serializer), 401 Err(_) => Err(S::Error::custom("lock poison error while serializing")), 402 } 403 } 404 } 405 406 #[cfg(feature = "std")] 407 impl<T> Serialize for RwLock<T> 408 where 409 T: Serialize, 410 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,411 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 412 where 413 S: Serializer, 414 { 415 match self.read() { 416 Ok(locked) => locked.serialize(serializer), 417 Err(_) => Err(S::Error::custom("lock poison error while serializing")), 418 } 419 } 420 } 421 422 //////////////////////////////////////////////////////////////////////////////// 423 424 impl<T, E> Serialize for Result<T, E> 425 where 426 T: Serialize, 427 E: Serialize, 428 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,429 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 430 where 431 S: Serializer, 432 { 433 match *self { 434 Result::Ok(ref value) => serializer.serialize_newtype_variant("Result", 0, "Ok", value), 435 Result::Err(ref value) => { 436 serializer.serialize_newtype_variant("Result", 1, "Err", value) 437 } 438 } 439 } 440 } 441 442 //////////////////////////////////////////////////////////////////////////////// 443 444 #[cfg(feature = "std")] 445 impl Serialize for Duration { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,446 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 447 where 448 S: Serializer, 449 { 450 use super::SerializeStruct; 451 let mut state = try!(serializer.serialize_struct("Duration", 2)); 452 try!(state.serialize_field("secs", &self.as_secs())); 453 try!(state.serialize_field("nanos", &self.subsec_nanos())); 454 state.end() 455 } 456 } 457 458 //////////////////////////////////////////////////////////////////////////////// 459 460 #[cfg(feature = "std")] 461 impl Serialize for SystemTime { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,462 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 463 where 464 S: Serializer, 465 { 466 use super::SerializeStruct; 467 let duration_since_epoch = self.duration_since(UNIX_EPOCH) 468 .expect("SystemTime must be later than UNIX_EPOCH"); 469 let mut state = try!(serializer.serialize_struct("SystemTime", 2)); 470 try!(state.serialize_field("secs_since_epoch", &duration_since_epoch.as_secs())); 471 try!(state.serialize_field("nanos_since_epoch", &duration_since_epoch.subsec_nanos())); 472 state.end() 473 } 474 } 475 476 //////////////////////////////////////////////////////////////////////////////// 477 478 /// Serialize a value that implements `Display` as a string, when that string is 479 /// statically known to never have more than a constant `MAX_LEN` bytes. 480 /// 481 /// Panics if the `Display` impl tries to write more than `MAX_LEN` bytes. 482 #[cfg(feature = "std")] 483 macro_rules! serialize_display_bounded_length { 484 ($value:expr, $max:expr, $serializer:expr) => {{ 485 let mut buffer: [u8; $max] = unsafe { mem::uninitialized() }; 486 let remaining_len = { 487 let mut remaining = &mut buffer[..]; 488 write!(remaining, "{}", $value).unwrap(); 489 remaining.len() 490 }; 491 let written_len = buffer.len() - remaining_len; 492 let written = &buffer[..written_len]; 493 494 // write! only provides fmt::Formatter to Display implementations, which 495 // has methods write_str and write_char but no method to write arbitrary 496 // bytes. Therefore `written` must be valid UTF-8. 497 let written_str = unsafe { 498 str::from_utf8_unchecked(written) 499 }; 500 $serializer.serialize_str(written_str) 501 }} 502 } 503 504 #[cfg(feature = "std")] 505 impl Serialize for net::IpAddr { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,506 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 507 where 508 S: Serializer, 509 { 510 if serializer.is_human_readable() { 511 match *self { 512 net::IpAddr::V4(ref a) => a.serialize(serializer), 513 net::IpAddr::V6(ref a) => a.serialize(serializer), 514 } 515 } else { 516 match *self { 517 net::IpAddr::V4(ref a) => { 518 serializer.serialize_newtype_variant("IpAddr", 0, "V4", a) 519 } 520 net::IpAddr::V6(ref a) => { 521 serializer.serialize_newtype_variant("IpAddr", 1, "V6", a) 522 } 523 } 524 } 525 } 526 } 527 528 #[cfg(feature = "std")] 529 impl Serialize for net::Ipv4Addr { 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 if serializer.is_human_readable() { 535 const MAX_LEN: usize = 15; 536 debug_assert_eq!(MAX_LEN, "101.102.103.104".len()); 537 serialize_display_bounded_length!(self, MAX_LEN, serializer) 538 } else { 539 self.octets().serialize(serializer) 540 } 541 } 542 } 543 544 #[cfg(feature = "std")] 545 impl Serialize for net::Ipv6Addr { 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 if serializer.is_human_readable() { 551 const MAX_LEN: usize = 39; 552 debug_assert_eq!(MAX_LEN, "1001:1002:1003:1004:1005:1006:1007:1008".len()); 553 serialize_display_bounded_length!(self, MAX_LEN, serializer) 554 } else { 555 self.octets().serialize(serializer) 556 } 557 } 558 } 559 560 #[cfg(feature = "std")] 561 impl Serialize for net::SocketAddr { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,562 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 563 where 564 S: Serializer, 565 { 566 if serializer.is_human_readable() { 567 match *self { 568 net::SocketAddr::V4(ref addr) => addr.serialize(serializer), 569 net::SocketAddr::V6(ref addr) => addr.serialize(serializer), 570 } 571 } else { 572 match *self { 573 net::SocketAddr::V4(ref addr) => { 574 serializer.serialize_newtype_variant("SocketAddr", 0, "V4", addr) 575 } 576 net::SocketAddr::V6(ref addr) => { 577 serializer.serialize_newtype_variant("SocketAddr", 1, "V6", addr) 578 } 579 } 580 } 581 } 582 } 583 584 #[cfg(feature = "std")] 585 impl Serialize for net::SocketAddrV4 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,586 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 587 where 588 S: Serializer, 589 { 590 if serializer.is_human_readable() { 591 const MAX_LEN: usize = 21; 592 debug_assert_eq!(MAX_LEN, "101.102.103.104:65000".len()); 593 serialize_display_bounded_length!(self, MAX_LEN, serializer) 594 } else { 595 (self.ip(), self.port()).serialize(serializer) 596 } 597 } 598 } 599 600 #[cfg(feature = "std")] 601 impl Serialize for net::SocketAddrV6 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,602 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 603 where 604 S: Serializer, 605 { 606 if serializer.is_human_readable() { 607 const MAX_LEN: usize = 47; 608 debug_assert_eq!( 609 MAX_LEN, 610 "[1001:1002:1003:1004:1005:1006:1007:1008]:65000".len() 611 ); 612 serialize_display_bounded_length!(self, MAX_LEN, serializer) 613 } else { 614 (self.ip(), self.port()).serialize(serializer) 615 } 616 } 617 } 618 619 //////////////////////////////////////////////////////////////////////////////// 620 621 #[cfg(feature = "std")] 622 impl Serialize for Path { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,623 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 624 where 625 S: Serializer, 626 { 627 match self.to_str() { 628 Some(s) => s.serialize(serializer), 629 None => Err(Error::custom("path contains invalid UTF-8 characters")), 630 } 631 } 632 } 633 634 #[cfg(feature = "std")] 635 impl Serialize for PathBuf { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,636 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 637 where 638 S: Serializer, 639 { 640 self.as_path().serialize(serializer) 641 } 642 } 643 644 #[cfg(all(feature = "std", any(unix, windows)))] 645 impl Serialize for OsStr { 646 #[cfg(unix)] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,647 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 648 where 649 S: Serializer, 650 { 651 use std::os::unix::ffi::OsStrExt; 652 serializer.serialize_newtype_variant("OsString", 0, "Unix", self.as_bytes()) 653 } 654 655 #[cfg(windows)] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,656 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 657 where 658 S: Serializer, 659 { 660 use std::os::windows::ffi::OsStrExt; 661 let val = self.encode_wide().collect::<Vec<_>>(); 662 serializer.serialize_newtype_variant("OsString", 1, "Windows", &val) 663 } 664 } 665 666 #[cfg(all(feature = "std", any(unix, windows)))] 667 impl Serialize for OsString { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,668 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 669 where 670 S: Serializer, 671 { 672 self.as_os_str().serialize(serializer) 673 } 674 } 675 676 //////////////////////////////////////////////////////////////////////////////// 677 678 #[cfg(feature = "std")] 679 impl<T> Serialize for Wrapping<T> 680 where 681 T: Serialize, 682 { 683 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,684 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 685 where 686 S: Serializer, 687 { 688 self.0.serialize(serializer) 689 } 690 } 691