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

   1 #[cfg(feature = "std")]
   2 use std::borrow::Cow;
   3 #[cfg(all(feature = "collections", not(feature = "std")))]
   4 use collections::borrow::Cow;
   5
   6 #[cfg(feature = "std")]
   7 use std::collections::{BinaryHeap, BTreeMap, BTreeSet, LinkedList, HashMap, HashSet, VecDeque};
   8 #[cfg(all(feature = "collections", not(feature = "std")))]
   9 use collections::{BinaryHeap, BTreeMap, BTreeSet, LinkedList, VecDeque, String, Vec};
  10
  11 #[cfg(feature = "collections")]
  12 use collections::borrow::ToOwned;
  13
  14 #[cfg(feature = "std")]
  15 use core::hash::{Hash, BuildHasher};
  16 #[cfg(feature = "std")]
  17 use std::net;
  18 #[cfg(any(feature = "std", feature = "unstable"))]
  19 use core::ops;
  20 #[cfg(feature = "std")]
  21 use std::path;
  22 #[cfg(feature = "std")]
  23 use std::ffi::{CString, CStr, OsString, OsStr};
  24 #[cfg(feature = "std")]
  25 use std::rc::Rc;
  26 #[cfg(all(feature = "alloc", not(feature = "std")))]
  27 use alloc::rc::Rc;
  28 #[cfg(feature = "std")]
  29 use std::time::Duration;
  30
  31 #[cfg(feature = "std")]
  32 use std::sync::Arc;
  33 #[cfg(all(feature = "alloc", not(feature = "std")))]
  34 use alloc::arc::Arc;
  35
  36 #[cfg(all(feature = "alloc", not(feature = "std")))]
  37 use alloc::boxed::Box;
  38
  39 use core::cell::{Cell, RefCell};
  40
  41 #[cfg(feature = "std")]
  42 use std::sync::{Mutex, RwLock};
  43
  44 use core::marker::PhantomData;
  45
  46 #[cfg(feature = "unstable")]
  47 use core::nonzero::{NonZero, Zeroable};
  48
  49 use super::{Serialize, SerializeSeq, SerializeTuple, Serializer};
  50 #[cfg(feature = "std")]
  51 use super::Error;
  52
  53 ///////////////////////////////////////////////////////////////////////////////
  54
  55 macro_rules! impl_visit {
  56     ($ty:ty, $method:ident $($cast:tt)*) => {
  57         impl Serialize for $ty {
  58             #[inline]
  59             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  60                 where S: Serializer,
  61             {
  62                 serializer.$method(*self $($cast)*)
  63             }
  64         }
  65     }
  66 }
  67
  68 impl_visit!(bool, serialize_bool);
  69 impl_visit!(isize, serialize_i64 as i64);
  70 impl_visit!(i8, serialize_i8);
  71 impl_visit!(i16, serialize_i16);
  72 impl_visit!(i32, serialize_i32);
  73 impl_visit!(i64, serialize_i64);
  74 impl_visit!(usize, serialize_u64 as u64);
  75 impl_visit!(u8, serialize_u8);
  76 impl_visit!(u16, serialize_u16);
  77 impl_visit!(u32, serialize_u32);
  78 impl_visit!(u64, serialize_u64);
  79 impl_visit!(f32, serialize_f32);
  80 impl_visit!(f64, serialize_f64);
  81 impl_visit!(char, serialize_char);
  82
  83 ///////////////////////////////////////////////////////////////////////////////
  84
  85 impl Serialize for str {
  86     #[inline]
  87     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  88         where S: Serializer
  89     {
  90         serializer.serialize_str(self)
  91     }
  92 }
  93
  94 #[cfg(any(feature = "std", feature = "collections"))]
  95 impl Serialize for String {
  96     #[inline]
  97     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  98         where S: Serializer
  99     {
 100         (&self[..]).serialize(serializer)
 101     }
 102 }
 103
 104 ///////////////////////////////////////////////////////////////////////////////
 105
 106 #[cfg(feature = "std")]
 107 impl Serialize for CStr {
 108     #[inline]
 109     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 110         where S: Serializer
 111     {
 112         serializer.serialize_bytes(self.to_bytes())
 113     }
 114 }
 115
 116 #[cfg(feature = "std")]
 117 impl Serialize for CString {
 118     #[inline]
 119     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 120         where S: Serializer
 121     {
 122         serializer.serialize_bytes(self.to_bytes())
 123     }
 124 }
 125
 126 ///////////////////////////////////////////////////////////////////////////////
 127
 128 impl<T> Serialize for Option<T>
 129     where T: Serialize
 130 {
 131     #[inline]
 132     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 133         where S: Serializer
 134     {
 135         match *self {
 136             Some(ref value) => serializer.serialize_some(value),
 137             None => serializer.serialize_none(),
 138         }
 139     }
 140 }
 141
 142 ///////////////////////////////////////////////////////////////////////////////
 143
 144 impl<T> Serialize for PhantomData<T> {
 145     #[inline]
 146     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 147         where S: Serializer
 148     {
 149         serializer.serialize_unit_struct("PhantomData")
 150     }
 151 }
 152
 153 ///////////////////////////////////////////////////////////////////////////////
 154
 155 macro_rules! array_impls {
 156     ($len:expr) => {
 157         impl<T> Serialize for [T; $len] where T: Serialize {
 158             #[inline]
 159             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 160                 where S: Serializer,
 161             {
 162                 let mut seq = try!(serializer.serialize_seq_fixed_size($len));
 163                 for e in self {
 164                     try!(seq.serialize_element(e));
 165                 }
 166                 seq.end()
 167             }
 168         }
 169     }
 170 }
 171
 172 array_impls!(0);
 173 array_impls!(1);
 174 array_impls!(2);
 175 array_impls!(3);
 176 array_impls!(4);
 177 array_impls!(5);
 178 array_impls!(6);
 179 array_impls!(7);
 180 array_impls!(8);
 181 array_impls!(9);
 182 array_impls!(10);
 183 array_impls!(11);
 184 array_impls!(12);
 185 array_impls!(13);
 186 array_impls!(14);
 187 array_impls!(15);
 188 array_impls!(16);
 189 array_impls!(17);
 190 array_impls!(18);
 191 array_impls!(19);
 192 array_impls!(20);
 193 array_impls!(21);
 194 array_impls!(22);
 195 array_impls!(23);
 196 array_impls!(24);
 197 array_impls!(25);
 198 array_impls!(26);
 199 array_impls!(27);
 200 array_impls!(28);
 201 array_impls!(29);
 202 array_impls!(30);
 203 array_impls!(31);
 204 array_impls!(32);
 205
 206 ///////////////////////////////////////////////////////////////////////////////
 207
 208 macro_rules! serialize_seq {
 209     () => {
 210         #[inline]
 211         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 212             where S: Serializer,
 213         {
 214             serializer.collect_seq(self)
 215         }
 216     }
 217 }
 218
 219 impl<T> Serialize for [T]
 220     where T: Serialize
 221 {
 222     serialize_seq!();
 223 }
 224
 225 #[cfg(any(feature = "std", feature = "collections"))]
 226 impl<T> Serialize for BinaryHeap<T>
 227     where T: Serialize + Ord
 228 {
 229     serialize_seq!();
 230 }
 231
 232 #[cfg(any(feature = "std", feature = "collections"))]
 233 impl<T> Serialize for BTreeSet<T>
 234     where T: Serialize + Ord
 235 {
 236     serialize_seq!();
 237 }
 238
 239 #[cfg(feature = "std")]
 240 impl<T, H> Serialize for HashSet<T, H>
 241     where T: Serialize + Eq + Hash,
 242           H: BuildHasher
 243 {
 244     serialize_seq!();
 245 }
 246
 247 #[cfg(any(feature = "std", feature = "collections"))]
 248 impl<T> Serialize for LinkedList<T>
 249     where T: Serialize
 250 {
 251     serialize_seq!();
 252 }
 253
 254 #[cfg(any(feature = "std", feature = "collections"))]
 255 impl<T> Serialize for Vec<T>
 256     where T: Serialize
 257 {
 258     serialize_seq!();
 259 }
 260
 261 #[cfg(any(feature = "std", feature = "collections"))]
 262 impl<T> Serialize for VecDeque<T>
 263     where T: Serialize
 264 {
 265     serialize_seq!();
 266 }
 267
 268 ///////////////////////////////////////////////////////////////////////////////
 269
 270 #[cfg(feature = "std")]
 271 impl<Idx: Serialize> Serialize for ops::Range<Idx> {
 272     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 273         where S: Serializer
 274     {
 275         use super::SerializeStruct;
 276         let mut state = try!(serializer.serialize_struct("Range", 2));
 277         try!(state.serialize_field("start", &self.start));
 278         try!(state.serialize_field("end", &self.end));
 279         state.end()
 280     }
 281 }
 282
 283 ///////////////////////////////////////////////////////////////////////////////
 284
 285 impl Serialize for () {
 286     #[inline]
 287     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 288         where S: Serializer
 289     {
 290         serializer.serialize_unit()
 291     }
 292 }
 293
 294 ///////////////////////////////////////////////////////////////////////////////
 295
 296 macro_rules! tuple_impls {
 297     ($(
 298         $TupleVisitor:ident ($len:expr, $($T:ident),+) {
 299             $($state:pat => $idx:tt,)+
 300         }
 301     )+) => {
 302         $(
 303             impl<$($T),+> Serialize for ($($T,)+)
 304                 where $($T: Serialize),+
 305             {
 306                 #[inline]
 307                 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 308                     where S: Serializer,
 309                 {
 310                     let mut tuple = try!(serializer.serialize_tuple($len));
 311                     $(
 312                         try!(tuple.serialize_element(&self.$idx));
 313                     )+
 314                     tuple.end()
 315                 }
 316             }
 317         )+
 318     }
 319 }
 320
 321 tuple_impls! {
 322     TupleVisitor1 (1, T0) {
 323         0 => 0,
 324     }
 325     TupleVisitor2 (2, T0, T1) {
 326         0 => 0,
 327         1 => 1,
 328     }
 329     TupleVisitor3 (3, T0, T1, T2) {
 330         0 => 0,
 331         1 => 1,
 332         2 => 2,
 333     }
 334     TupleVisitor4 (4, T0, T1, T2, T3) {
 335         0 => 0,
 336         1 => 1,
 337         2 => 2,
 338         3 => 3,
 339     }
 340     TupleVisitor5 (5, T0, T1, T2, T3, T4) {
 341         0 => 0,
 342         1 => 1,
 343         2 => 2,
 344         3 => 3,
 345         4 => 4,
 346     }
 347     TupleVisitor6 (6, T0, T1, T2, T3, T4, T5) {
 348         0 => 0,
 349         1 => 1,
 350         2 => 2,
 351         3 => 3,
 352         4 => 4,
 353         5 => 5,
 354     }
 355     TupleVisitor7 (7, T0, T1, T2, T3, T4, T5, T6) {
 356         0 => 0,
 357         1 => 1,
 358         2 => 2,
 359         3 => 3,
 360         4 => 4,
 361         5 => 5,
 362         6 => 6,
 363     }
 364     TupleVisitor8 (8, T0, T1, T2, T3, T4, T5, T6, T7) {
 365         0 => 0,
 366         1 => 1,
 367         2 => 2,
 368         3 => 3,
 369         4 => 4,
 370         5 => 5,
 371         6 => 6,
 372         7 => 7,
 373     }
 374     TupleVisitor9 (9, T0, T1, T2, T3, T4, T5, T6, T7, T8) {
 375         0 => 0,
 376         1 => 1,
 377         2 => 2,
 378         3 => 3,
 379         4 => 4,
 380         5 => 5,
 381         6 => 6,
 382         7 => 7,
 383         8 => 8,
 384     }
 385     TupleVisitor10 (10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {
 386         0 => 0,
 387         1 => 1,
 388         2 => 2,
 389         3 => 3,
 390         4 => 4,
 391         5 => 5,
 392         6 => 6,
 393         7 => 7,
 394         8 => 8,
 395         9 => 9,
 396     }
 397     TupleVisitor11 (11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {
 398         0 => 0,
 399         1 => 1,
 400         2 => 2,
 401         3 => 3,
 402         4 => 4,
 403         5 => 5,
 404         6 => 6,
 405         7 => 7,
 406         8 => 8,
 407         9 => 9,
 408         10 => 10,
 409     }
 410     TupleVisitor12 (12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {
 411         0 => 0,
 412         1 => 1,
 413         2 => 2,
 414         3 => 3,
 415         4 => 4,
 416         5 => 5,
 417         6 => 6,
 418         7 => 7,
 419         8 => 8,
 420         9 => 9,
 421         10 => 10,
 422         11 => 11,
 423     }
 424     TupleVisitor13 (13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) {
 425         0 => 0,
 426         1 => 1,
 427         2 => 2,
 428         3 => 3,
 429         4 => 4,
 430         5 => 5,
 431         6 => 6,
 432         7 => 7,
 433         8 => 8,
 434         9 => 9,
 435         10 => 10,
 436         11 => 11,
 437         12 => 12,
 438     }
 439     TupleVisitor14 (14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) {
 440         0 => 0,
 441         1 => 1,
 442         2 => 2,
 443         3 => 3,
 444         4 => 4,
 445         5 => 5,
 446         6 => 6,
 447         7 => 7,
 448         8 => 8,
 449         9 => 9,
 450         10 => 10,
 451         11 => 11,
 452         12 => 12,
 453         13 => 13,
 454     }
 455     TupleVisitor15 (15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) {
 456         0 => 0,
 457         1 => 1,
 458         2 => 2,
 459         3 => 3,
 460         4 => 4,
 461         5 => 5,
 462         6 => 6,
 463         7 => 7,
 464         8 => 8,
 465         9 => 9,
 466         10 => 10,
 467         11 => 11,
 468         12 => 12,
 469         13 => 13,
 470         14 => 14,
 471     }
 472     TupleVisitor16 (16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) {
 473         0 => 0,
 474         1 => 1,
 475         2 => 2,
 476         3 => 3,
 477         4 => 4,
 478         5 => 5,
 479         6 => 6,
 480         7 => 7,
 481         8 => 8,
 482         9 => 9,
 483         10 => 10,
 484         11 => 11,
 485         12 => 12,
 486         13 => 13,
 487         14 => 14,
 488         15 => 15,
 489     }
 490 }
 491
 492 ///////////////////////////////////////////////////////////////////////////////
 493
 494 macro_rules! serialize_map {
 495     () => {
 496         #[inline]
 497         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 498             where S: Serializer,
 499         {
 500             serializer.collect_map(self)
 501         }
 502     }
 503 }
 504
 505 #[cfg(any(feature = "std", feature = "collections"))]
 506 impl<K, V> Serialize for BTreeMap<K, V>
 507     where K: Serialize + Ord,
 508           V: Serialize
 509 {
 510     serialize_map!();
 511 }
 512
 513 #[cfg(feature = "std")]
 514 impl<K, V, H> Serialize for HashMap<K, V, H>
 515     where K: Serialize + Eq + Hash,
 516           V: Serialize,
 517           H: BuildHasher
 518 {
 519     serialize_map!();
 520 }
 521
 522 ///////////////////////////////////////////////////////////////////////////////
 523
 524 impl<'a, T: ?Sized> Serialize for &'a T
 525     where T: Serialize
 526 {
 527     #[inline]
 528     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 529         where S: Serializer
 530     {
 531         (**self).serialize(serializer)
 532     }
 533 }
 534
 535 impl<'a, T: ?Sized> Serialize for &'a mut T
 536     where T: Serialize
 537 {
 538     #[inline]
 539     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 540         where S: Serializer
 541     {
 542         (**self).serialize(serializer)
 543     }
 544 }
 545
 546 #[cfg(any(feature = "std", feature = "alloc"))]
 547 impl<T: ?Sized> Serialize for Box<T>
 548     where T: Serialize
 549 {
 550     #[inline]
 551     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 552         where S: Serializer
 553     {
 554         (**self).serialize(serializer)
 555     }
 556 }
 557
 558 #[cfg(any(feature = "std", feature = "alloc"))]
 559 impl<T> Serialize for Rc<T>
 560     where T: Serialize
 561 {
 562     #[inline]
 563     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 564         where S: Serializer
 565     {
 566         (**self).serialize(serializer)
 567     }
 568 }
 569
 570 #[cfg(any(feature = "std", feature = "alloc"))]
 571 impl<T> Serialize for Arc<T>
 572     where T: Serialize
 573 {
 574     #[inline]
 575     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 576         where S: Serializer
 577     {
 578         (**self).serialize(serializer)
 579     }
 580 }
 581
 582 #[cfg(any(feature = "std", feature = "collections"))]
 583 impl<'a, T: ?Sized> Serialize for Cow<'a, T>
 584     where T: Serialize + ToOwned
 585 {
 586     #[inline]
 587     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 588         where S: Serializer
 589     {
 590         (**self).serialize(serializer)
 591     }
 592 }
 593
 594 impl<T> Serialize for Cell<T>
 595     where T: Serialize + Copy
 596 {
 597     #[inline]
 598     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 599         where S: Serializer
 600     {
 601         self.get().serialize(serializer)
 602     }
 603 }
 604
 605 impl<T> Serialize for RefCell<T>
 606     where T: Serialize
 607 {
 608     #[inline]
 609     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 610         where S: Serializer
 611     {
 612         self.borrow().serialize(serializer)
 613     }
 614 }
 615
 616 #[cfg(feature = "std")]
 617 impl<T> Serialize for Mutex<T>
 618     where T: Serialize
 619 {
 620     #[inline]
 621     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 622         where S: Serializer
 623     {
 624         match self.lock() {
 625             Ok(locked) => locked.serialize(serializer),
 626             Err(_) => Err(S::Error::custom("lock poison error while serializing")),
 627         }
 628     }
 629 }
 630
 631 #[cfg(feature = "std")]
 632 impl<T> Serialize for RwLock<T>
 633     where T: Serialize
 634 {
 635     #[inline]
 636     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 637         where S: Serializer
 638     {
 639         match self.read() {
 640             Ok(locked) => locked.serialize(serializer),
 641             Err(_) => Err(S::Error::custom("lock poison error while serializing")),
 642         }
 643     }
 644 }
 645
 646 ///////////////////////////////////////////////////////////////////////////////
 647
 648 impl<T, E> Serialize for Result<T, E>
 649     where T: Serialize,
 650           E: Serialize
 651 {
 652     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 653         where S: Serializer
 654     {
 655         match *self {
 656             Result::Ok(ref value) => serializer.serialize_newtype_variant("Result", 0, "Ok", value),
 657             Result::Err(ref value) => {
 658                 serializer.serialize_newtype_variant("Result", 1, "Err", value)
 659             }
 660         }
 661     }
 662 }
 663
 664 ///////////////////////////////////////////////////////////////////////////////
 665
 666 #[cfg(feature = "std")]
 667 impl Serialize for Duration {
 668     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 669         where S: Serializer
 670     {
 671         use super::SerializeStruct;
 672         let mut state = try!(serializer.serialize_struct("Duration", 2));
 673         try!(state.serialize_field("secs", &self.as_secs()));
 674         try!(state.serialize_field("nanos", &self.subsec_nanos()));
 675         state.end()
 676     }
 677 }
 678
 679 ///////////////////////////////////////////////////////////////////////////////
 680
 681 #[cfg(feature = "std")]
 682 impl Serialize for net::IpAddr {
 683     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 684         where S: Serializer
 685     {
 686         match *self {
 687             net::IpAddr::V4(ref a) => a.serialize(serializer),
 688             net::IpAddr::V6(ref a) => a.serialize(serializer),
 689         }
 690     }
 691 }
 692
 693 #[cfg(feature = "std")]
 694 impl Serialize for net::Ipv4Addr {
 695     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 696         where S: Serializer
 697     {
 698         /// "101.102.103.104".len()
 699         const MAX_LEN: usize = 15;
 700         serialize_display_bounded_length!(self, MAX_LEN, serializer)
 701     }
 702 }
 703
 704 #[cfg(feature = "std")]
 705 impl Serialize for net::Ipv6Addr {
 706     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 707         where S: Serializer
 708     {
 709         /// "1000:1002:1003:1004:1005:1006:1007:1008".len()
 710         const MAX_LEN: usize = 39;
 711         serialize_display_bounded_length!(self, MAX_LEN, serializer)
 712     }
 713 }
 714
 715 ///////////////////////////////////////////////////////////////////////////////
 716
 717 #[cfg(feature = "std")]
 718 impl Serialize for net::SocketAddr {
 719     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 720         where S: Serializer
 721     {
 722         match *self {
 723             net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
 724             net::SocketAddr::V6(ref addr) => addr.serialize(serializer),
 725         }
 726     }
 727 }
 728
 729 #[cfg(feature = "std")]
 730 impl Serialize for net::SocketAddrV4 {
 731     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 732         where S: Serializer
 733     {
 734         /// "101.102.103.104:65000".len()
 735         const MAX_LEN: usize = 21;
 736         serialize_display_bounded_length!(self, MAX_LEN, serializer)
 737     }
 738 }
 739
 740 #[cfg(feature = "std")]
 741 impl Serialize for net::SocketAddrV6 {
 742     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 743         where S: Serializer
 744     {
 745         /// "[1000:1002:1003:1004:1005:1006:1007:1008]:65000".len()
 746         const MAX_LEN: usize = 47;
 747         serialize_display_bounded_length!(self, MAX_LEN, serializer)
 748     }
 749 }
 750
 751 ///////////////////////////////////////////////////////////////////////////////
 752
 753 #[cfg(feature = "std")]
 754 impl Serialize for path::Path {
 755     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 756         where S: Serializer
 757     {
 758         match self.to_str() {
 759             Some(s) => s.serialize(serializer),
 760             None => Err(Error::custom("path contains invalid UTF-8 characters")),
 761         }
 762     }
 763 }
 764
 765 #[cfg(feature = "std")]
 766 impl Serialize for path::PathBuf {
 767     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 768         where S: Serializer
 769     {
 770         self.as_path().serialize(serializer)
 771     }
 772 }
 773
 774 #[cfg(all(feature = "std", any(unix, windows)))]
 775 impl Serialize for OsStr {
 776     #[cfg(unix)]
 777     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 778         where S: Serializer
 779     {
 780         use std::os::unix::ffi::OsStrExt;
 781         serializer.serialize_newtype_variant("OsString",
 782                                              0,
 783                                              "Unix",
 784                                              self.as_bytes())
 785     }
 786     #[cfg(windows)]
 787     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 788         where S: Serializer
 789     {
 790         use std::os::windows::ffi::OsStrExt;
 791         let val = self.encode_wide().collect::<Vec<_>>();
 792         serializer.serialize_newtype_variant("OsString",
 793                                              1,
 794                                              "Windows",
 795                                              &val)
 796     }
 797 }
 798
 799 #[cfg(all(feature = "std", any(unix, windows)))]
 800 #[cfg(feature = "std")]
 801 impl Serialize for OsString {
 802     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 803         where S: Serializer
 804     {
 805         self.as_os_str().serialize(serializer)
 806     }
 807 }
 808
 809 #[cfg(feature = "unstable")]
 810 impl<T> Serialize for NonZero<T>
 811     where T: Serialize + Zeroable
 812 {
 813     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 814         where S: Serializer
 815     {
 816         (**self).serialize(serializer)
 817     }
 818 }