src/vendor/serde/src/ser/impls.rs

   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]
  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]
  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]
  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]
  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]
 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> Serialize for PhantomData<T> {
 115     #[inline]
 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]
 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]
 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 {
 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]
 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> Serialize for Rc<T> where T: Serialize);
 344
 345 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
 346 deref_impl!(<T> 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 {
 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 {
 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 {
 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 {
 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 {
 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 {
 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 {
 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 {
 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).expect("SystemTime must be later than UNIX_EPOCH");
 468         let mut state = try!(serializer.serialize_struct("SystemTime", 2));
 469         try!(state.serialize_field("secs_since_epoch", &duration_since_epoch.as_secs()));
 470         try!(state.serialize_field("nanos_since_epoch", &duration_since_epoch.subsec_nanos()));
 471         state.end()
 472     }
 473 }
 474
 475 ////////////////////////////////////////////////////////////////////////////////
 476
 477 /// Serialize a value that implements `Display` as a string, when that string is
 478 /// statically known to never have more than a constant `MAX_LEN` bytes.
 479 ///
 480 /// Panics if the `Display` impl tries to write more than `MAX_LEN` bytes.
 481 #[cfg(feature = "std")]
 482 macro_rules! serialize_display_bounded_length {
 483     ($value:expr, $max:expr, $serializer:expr) => {{
 484         let mut buffer: [u8; $max] = unsafe { mem::uninitialized() };
 485         let remaining_len = {
 486             let mut remaining = &mut buffer[..];
 487             write!(remaining, "{}", $value).unwrap();
 488             remaining.len()
 489         };
 490         let written_len = buffer.len() - remaining_len;
 491         let written = &buffer[..written_len];
 492
 493         // write! only provides fmt::Formatter to Display implementations, which
 494         // has methods write_str and write_char but no method to write arbitrary
 495         // bytes. Therefore `written` must be valid UTF-8.
 496         let written_str = unsafe {
 497             str::from_utf8_unchecked(written)
 498         };
 499         $serializer.serialize_str(written_str)
 500     }}
 501 }
 502
 503 #[cfg(feature = "std")]
 504 impl Serialize for net::IpAddr {
 505     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 506     where
 507         S: Serializer,
 508     {
 509         match *self {
 510             net::IpAddr::V4(ref a) => a.serialize(serializer),
 511             net::IpAddr::V6(ref a) => a.serialize(serializer),
 512         }
 513     }
 514 }
 515
 516 #[cfg(feature = "std")]
 517 impl Serialize for net::Ipv4Addr {
 518     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 519     where
 520         S: Serializer,
 521     {
 522         /// "101.102.103.104".len()
 523         const MAX_LEN: usize = 15;
 524         serialize_display_bounded_length!(self, MAX_LEN, serializer)
 525     }
 526 }
 527
 528 #[cfg(feature = "std")]
 529 impl Serialize for net::Ipv6Addr {
 530     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 531     where
 532         S: Serializer,
 533     {
 534         /// "1000:1002:1003:1004:1005:1006:1007:1008".len()
 535         const MAX_LEN: usize = 39;
 536         serialize_display_bounded_length!(self, MAX_LEN, serializer)
 537     }
 538 }
 539
 540 #[cfg(feature = "std")]
 541 impl Serialize for net::SocketAddr {
 542     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 543     where
 544         S: Serializer,
 545     {
 546         match *self {
 547             net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
 548             net::SocketAddr::V6(ref addr) => addr.serialize(serializer),
 549         }
 550     }
 551 }
 552
 553 #[cfg(feature = "std")]
 554 impl Serialize for net::SocketAddrV4 {
 555     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 556     where
 557         S: Serializer,
 558     {
 559         /// "101.102.103.104:65000".len()
 560         const MAX_LEN: usize = 21;
 561         serialize_display_bounded_length!(self, MAX_LEN, serializer)
 562     }
 563 }
 564
 565 #[cfg(feature = "std")]
 566 impl Serialize for net::SocketAddrV6 {
 567     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 568     where
 569         S: Serializer,
 570     {
 571         /// "[1000:1002:1003:1004:1005:1006:1007:1008]:65000".len()
 572         const MAX_LEN: usize = 47;
 573         serialize_display_bounded_length!(self, MAX_LEN, serializer)
 574     }
 575 }
 576
 577 ////////////////////////////////////////////////////////////////////////////////
 578
 579 #[cfg(feature = "std")]
 580 impl Serialize for Path {
 581     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 582     where
 583         S: Serializer,
 584     {
 585         match self.to_str() {
 586             Some(s) => s.serialize(serializer),
 587             None => Err(Error::custom("path contains invalid UTF-8 characters")),
 588         }
 589     }
 590 }
 591
 592 #[cfg(feature = "std")]
 593 impl Serialize for PathBuf {
 594     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 595     where
 596         S: Serializer,
 597     {
 598         self.as_path().serialize(serializer)
 599     }
 600 }
 601
 602 #[cfg(all(feature = "std", any(unix, windows)))]
 603 impl Serialize for OsStr {
 604     #[cfg(unix)]
 605     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 606     where
 607         S: Serializer,
 608     {
 609         use std::os::unix::ffi::OsStrExt;
 610         serializer.serialize_newtype_variant("OsString", 0, "Unix", self.as_bytes())
 611     }
 612
 613     #[cfg(windows)]
 614     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 615     where
 616         S: Serializer,
 617     {
 618         use std::os::windows::ffi::OsStrExt;
 619         let val = self.encode_wide().collect::<Vec<_>>();
 620         serializer.serialize_newtype_variant("OsString", 1, "Windows", &val)
 621     }
 622 }
 623
 624 #[cfg(all(feature = "std", any(unix, windows)))]
 625 impl Serialize for OsString {
 626     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 627     where
 628         S: Serializer,
 629     {
 630         self.as_os_str().serialize(serializer)
 631     }
 632 }