src/librustc_serialize/serialize.rs

   1 //! Support code for encoding and decoding types.
   2
   3 /*
   4 Core encoding and decoding interfaces.
   5 */
   6
   7 use std::borrow::Cow;
   8 use std::cell::{Cell, RefCell};
   9 use std::marker::PhantomData;
  10 use std::path;
  11 use std::rc::Rc;
  12 use std::sync::Arc;
  13
  14 pub trait Encoder {
  15     type Error;
  16
  17     // Primitive types:
  18     fn emit_unit(&mut self) -> Result<(), Self::Error>;
  19     fn emit_usize(&mut self, v: usize) -> Result<(), Self::Error>;
  20     fn emit_u128(&mut self, v: u128) -> Result<(), Self::Error>;
  21     fn emit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
  22     fn emit_u32(&mut self, v: u32) -> Result<(), Self::Error>;
  23     fn emit_u16(&mut self, v: u16) -> Result<(), Self::Error>;
  24     fn emit_u8(&mut self, v: u8) -> Result<(), Self::Error>;
  25     fn emit_isize(&mut self, v: isize) -> Result<(), Self::Error>;
  26     fn emit_i128(&mut self, v: i128) -> Result<(), Self::Error>;
  27     fn emit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
  28     fn emit_i32(&mut self, v: i32) -> Result<(), Self::Error>;
  29     fn emit_i16(&mut self, v: i16) -> Result<(), Self::Error>;
  30     fn emit_i8(&mut self, v: i8) -> Result<(), Self::Error>;
  31     fn emit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
  32     fn emit_f64(&mut self, v: f64) -> Result<(), Self::Error>;
  33     fn emit_f32(&mut self, v: f32) -> Result<(), Self::Error>;
  34     fn emit_char(&mut self, v: char) -> Result<(), Self::Error>;
  35     fn emit_str(&mut self, v: &str) -> Result<(), Self::Error>;
  36
  37     // Compound types:
  38     #[inline]
  39     fn emit_enum<F>(&mut self, _name: &str, f: F) -> Result<(), Self::Error>
  40     where
  41         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  42     {
  43         f(self)
  44     }
  45
  46     fn emit_enum_variant<F>(
  47         &mut self,
  48         _v_name: &str,
  49         v_id: usize,
  50         _len: usize,
  51         f: F,
  52     ) -> Result<(), Self::Error>
  53     where
  54         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  55     {
  56         self.emit_usize(v_id)?;
  57         f(self)
  58     }
  59
  60     #[inline]
  61     fn emit_enum_variant_arg<F>(&mut self, _a_idx: usize, f: F) -> Result<(), Self::Error>
  62     where
  63         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  64     {
  65         f(self)
  66     }
  67
  68     fn emit_enum_struct_variant<F>(
  69         &mut self,
  70         v_name: &str,
  71         v_id: usize,
  72         len: usize,
  73         f: F,
  74     ) -> Result<(), Self::Error>
  75     where
  76         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  77     {
  78         self.emit_enum_variant(v_name, v_id, len, f)
  79     }
  80
  81     fn emit_enum_struct_variant_field<F>(
  82         &mut self,
  83         _f_name: &str,
  84         f_idx: usize,
  85         f: F,
  86     ) -> Result<(), Self::Error>
  87     where
  88         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  89     {
  90         self.emit_enum_variant_arg(f_idx, f)
  91     }
  92
  93     #[inline]
  94     fn emit_struct<F>(&mut self, _name: &str, _len: usize, f: F) -> Result<(), Self::Error>
  95     where
  96         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  97     {
  98         f(self)
  99     }
 100
 101     #[inline]
 102     fn emit_struct_field<F>(
 103         &mut self,
 104         _f_name: &str,
 105         _f_idx: usize,
 106         f: F,
 107     ) -> Result<(), Self::Error>
 108     where
 109         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 110     {
 111         f(self)
 112     }
 113
 114     #[inline]
 115     fn emit_tuple<F>(&mut self, _len: usize, f: F) -> Result<(), Self::Error>
 116     where
 117         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 118     {
 119         f(self)
 120     }
 121
 122     #[inline]
 123     fn emit_tuple_arg<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
 124     where
 125         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 126     {
 127         f(self)
 128     }
 129
 130     fn emit_tuple_struct<F>(&mut self, _name: &str, len: usize, f: F) -> Result<(), Self::Error>
 131     where
 132         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 133     {
 134         self.emit_tuple(len, f)
 135     }
 136
 137     fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> Result<(), Self::Error>
 138     where
 139         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 140     {
 141         self.emit_tuple_arg(f_idx, f)
 142     }
 143
 144     // Specialized types:
 145     fn emit_option<F>(&mut self, f: F) -> Result<(), Self::Error>
 146     where
 147         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 148     {
 149         self.emit_enum("Option", f)
 150     }
 151
 152     #[inline]
 153     fn emit_option_none(&mut self) -> Result<(), Self::Error> {
 154         self.emit_enum_variant("None", 0, 0, |_| Ok(()))
 155     }
 156
 157     fn emit_option_some<F>(&mut self, f: F) -> Result<(), Self::Error>
 158     where
 159         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 160     {
 161         self.emit_enum_variant("Some", 1, 1, f)
 162     }
 163
 164     fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
 165     where
 166         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 167     {
 168         self.emit_usize(len)?;
 169         f(self)
 170     }
 171
 172     #[inline]
 173     fn emit_seq_elt<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
 174     where
 175         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 176     {
 177         f(self)
 178     }
 179
 180     fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
 181     where
 182         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 183     {
 184         self.emit_usize(len)?;
 185         f(self)
 186     }
 187
 188     #[inline]
 189     fn emit_map_elt_key<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
 190     where
 191         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 192     {
 193         f(self)
 194     }
 195
 196     #[inline]
 197     fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
 198     where
 199         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 200     {
 201         f(self)
 202     }
 203 }
 204
 205 pub trait Decoder {
 206     type Error;
 207
 208     // Primitive types:
 209     fn read_nil(&mut self) -> Result<(), Self::Error>;
 210     fn read_usize(&mut self) -> Result<usize, Self::Error>;
 211     fn read_u128(&mut self) -> Result<u128, Self::Error>;
 212     fn read_u64(&mut self) -> Result<u64, Self::Error>;
 213     fn read_u32(&mut self) -> Result<u32, Self::Error>;
 214     fn read_u16(&mut self) -> Result<u16, Self::Error>;
 215     fn read_u8(&mut self) -> Result<u8, Self::Error>;
 216     fn read_isize(&mut self) -> Result<isize, Self::Error>;
 217     fn read_i128(&mut self) -> Result<i128, Self::Error>;
 218     fn read_i64(&mut self) -> Result<i64, Self::Error>;
 219     fn read_i32(&mut self) -> Result<i32, Self::Error>;
 220     fn read_i16(&mut self) -> Result<i16, Self::Error>;
 221     fn read_i8(&mut self) -> Result<i8, Self::Error>;
 222     fn read_bool(&mut self) -> Result<bool, Self::Error>;
 223     fn read_f64(&mut self) -> Result<f64, Self::Error>;
 224     fn read_f32(&mut self) -> Result<f32, Self::Error>;
 225     fn read_char(&mut self) -> Result<char, Self::Error>;
 226     fn read_str(&mut self) -> Result<Cow<'_, str>, Self::Error>;
 227
 228     // Compound types:
 229     #[inline]
 230     fn read_enum<T, F>(&mut self, _name: &str, f: F) -> Result<T, Self::Error>
 231     where
 232         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 233     {
 234         f(self)
 235     }
 236
 237     #[inline]
 238     fn read_enum_variant<T, F>(&mut self, _names: &[&str], mut f: F) -> Result<T, Self::Error>
 239     where
 240         F: FnMut(&mut Self, usize) -> Result<T, Self::Error>,
 241     {
 242         let disr = self.read_usize()?;
 243         f(self, disr)
 244     }
 245
 246     #[inline]
 247     fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Self::Error>
 248     where
 249         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 250     {
 251         f(self)
 252     }
 253
 254     fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, Self::Error>
 255     where
 256         F: FnMut(&mut Self, usize) -> Result<T, Self::Error>,
 257     {
 258         self.read_enum_variant(names, f)
 259     }
 260
 261     fn read_enum_struct_variant_field<T, F>(
 262         &mut self,
 263         _f_name: &str,
 264         f_idx: usize,
 265         f: F,
 266     ) -> Result<T, Self::Error>
 267     where
 268         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 269     {
 270         self.read_enum_variant_arg(f_idx, f)
 271     }
 272
 273     #[inline]
 274     fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, f: F) -> Result<T, Self::Error>
 275     where
 276         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 277     {
 278         f(self)
 279     }
 280
 281     #[inline]
 282     fn read_struct_field<T, F>(
 283         &mut self,
 284         _f_name: &str,
 285         _f_idx: usize,
 286         f: F,
 287     ) -> Result<T, Self::Error>
 288     where
 289         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 290     {
 291         f(self)
 292     }
 293
 294     #[inline]
 295     fn read_tuple<T, F>(&mut self, _len: usize, f: F) -> Result<T, Self::Error>
 296     where
 297         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 298     {
 299         f(self)
 300     }
 301
 302     #[inline]
 303     fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Self::Error>
 304     where
 305         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 306     {
 307         f(self)
 308     }
 309
 310     fn read_tuple_struct<T, F>(&mut self, _s_name: &str, len: usize, f: F) -> Result<T, Self::Error>
 311     where
 312         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 313     {
 314         self.read_tuple(len, f)
 315     }
 316
 317     fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F) -> Result<T, Self::Error>
 318     where
 319         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 320     {
 321         self.read_tuple_arg(a_idx, f)
 322     }
 323
 324     // Specialized types:
 325     fn read_option<T, F>(&mut self, mut f: F) -> Result<T, Self::Error>
 326     where
 327         F: FnMut(&mut Self, bool) -> Result<T, Self::Error>,
 328     {
 329         self.read_enum("Option", move |this| {
 330             this.read_enum_variant(&["None", "Some"], move |this, idx| match idx {
 331                 0 => f(this, false),
 332                 1 => f(this, true),
 333                 _ => Err(this.error("read_option: expected 0 for None or 1 for Some")),
 334             })
 335         })
 336     }
 337
 338     fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
 339     where
 340         F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>,
 341     {
 342         let len = self.read_usize()?;
 343         f(self, len)
 344     }
 345
 346     #[inline]
 347     fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error>
 348     where
 349         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 350     {
 351         f(self)
 352     }
 353
 354     fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
 355     where
 356         F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>,
 357     {
 358         let len = self.read_usize()?;
 359         f(self, len)
 360     }
 361
 362     #[inline]
 363     fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error>
 364     where
 365         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 366     {
 367         f(self)
 368     }
 369
 370     #[inline]
 371     fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error>
 372     where
 373         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 374     {
 375         f(self)
 376     }
 377
 378     // Failure
 379     fn error(&mut self, err: &str) -> Self::Error;
 380 }
 381
 382 pub trait Encodable<S: Encoder> {
 383     fn encode(&self, s: &mut S) -> Result<(), S::Error>;
 384 }
 385
 386 pub trait Decodable<D: Decoder>: Sized {
 387     fn decode(d: &mut D) -> Result<Self, D::Error>;
 388 }
 389
 390 impl<S: Encoder> Encodable<S> for usize {
 391     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 392         s.emit_usize(*self)
 393     }
 394 }
 395
 396 impl<D: Decoder> Decodable<D> for usize {
 397     fn decode(d: &mut D) -> Result<usize, D::Error> {
 398         d.read_usize()
 399     }
 400 }
 401
 402 impl<S: Encoder> Encodable<S> for u8 {
 403     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 404         s.emit_u8(*self)
 405     }
 406 }
 407
 408 impl<D: Decoder> Decodable<D> for u8 {
 409     fn decode(d: &mut D) -> Result<u8, D::Error> {
 410         d.read_u8()
 411     }
 412 }
 413
 414 impl<S: Encoder> Encodable<S> for u16 {
 415     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 416         s.emit_u16(*self)
 417     }
 418 }
 419
 420 impl<D: Decoder> Decodable<D> for u16 {
 421     fn decode(d: &mut D) -> Result<u16, D::Error> {
 422         d.read_u16()
 423     }
 424 }
 425
 426 impl<S: Encoder> Encodable<S> for u32 {
 427     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 428         s.emit_u32(*self)
 429     }
 430 }
 431
 432 impl<D: Decoder> Decodable<D> for u32 {
 433     fn decode(d: &mut D) -> Result<u32, D::Error> {
 434         d.read_u32()
 435     }
 436 }
 437
 438 impl<S: Encoder> Encodable<S> for ::std::num::NonZeroU32 {
 439     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 440         s.emit_u32(self.get())
 441     }
 442 }
 443
 444 impl<D: Decoder> Decodable<D> for ::std::num::NonZeroU32 {
 445     fn decode(d: &mut D) -> Result<Self, D::Error> {
 446         d.read_u32().map(|d| ::std::num::NonZeroU32::new(d).unwrap())
 447     }
 448 }
 449
 450 impl<S: Encoder> Encodable<S> for u64 {
 451     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 452         s.emit_u64(*self)
 453     }
 454 }
 455
 456 impl<D: Decoder> Decodable<D> for u64 {
 457     fn decode(d: &mut D) -> Result<u64, D::Error> {
 458         d.read_u64()
 459     }
 460 }
 461
 462 impl<S: Encoder> Encodable<S> for u128 {
 463     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 464         s.emit_u128(*self)
 465     }
 466 }
 467
 468 impl<D: Decoder> Decodable<D> for u128 {
 469     fn decode(d: &mut D) -> Result<u128, D::Error> {
 470         d.read_u128()
 471     }
 472 }
 473
 474 impl<S: Encoder> Encodable<S> for isize {
 475     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 476         s.emit_isize(*self)
 477     }
 478 }
 479
 480 impl<D: Decoder> Decodable<D> for isize {
 481     fn decode(d: &mut D) -> Result<isize, D::Error> {
 482         d.read_isize()
 483     }
 484 }
 485
 486 impl<S: Encoder> Encodable<S> for i8 {
 487     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 488         s.emit_i8(*self)
 489     }
 490 }
 491
 492 impl<D: Decoder> Decodable<D> for i8 {
 493     fn decode(d: &mut D) -> Result<i8, D::Error> {
 494         d.read_i8()
 495     }
 496 }
 497
 498 impl<S: Encoder> Encodable<S> for i16 {
 499     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 500         s.emit_i16(*self)
 501     }
 502 }
 503
 504 impl<D: Decoder> Decodable<D> for i16 {
 505     fn decode(d: &mut D) -> Result<i16, D::Error> {
 506         d.read_i16()
 507     }
 508 }
 509
 510 impl<S: Encoder> Encodable<S> for i32 {
 511     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 512         s.emit_i32(*self)
 513     }
 514 }
 515
 516 impl<D: Decoder> Decodable<D> for i32 {
 517     fn decode(d: &mut D) -> Result<i32, D::Error> {
 518         d.read_i32()
 519     }
 520 }
 521
 522 impl<S: Encoder> Encodable<S> for i64 {
 523     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 524         s.emit_i64(*self)
 525     }
 526 }
 527
 528 impl<D: Decoder> Decodable<D> for i64 {
 529     fn decode(d: &mut D) -> Result<i64, D::Error> {
 530         d.read_i64()
 531     }
 532 }
 533
 534 impl<S: Encoder> Encodable<S> for i128 {
 535     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 536         s.emit_i128(*self)
 537     }
 538 }
 539
 540 impl<D: Decoder> Decodable<D> for i128 {
 541     fn decode(d: &mut D) -> Result<i128, D::Error> {
 542         d.read_i128()
 543     }
 544 }
 545
 546 impl<S: Encoder> Encodable<S> for str {
 547     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 548         s.emit_str(self)
 549     }
 550 }
 551
 552 impl<S: Encoder> Encodable<S> for &str {
 553     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 554         s.emit_str(self)
 555     }
 556 }
 557
 558 impl<S: Encoder> Encodable<S> for String {
 559     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 560         s.emit_str(&self[..])
 561     }
 562 }
 563
 564 impl<D: Decoder> Decodable<D> for String {
 565     fn decode(d: &mut D) -> Result<String, D::Error> {
 566         Ok(d.read_str()?.into_owned())
 567     }
 568 }
 569
 570 impl<S: Encoder> Encodable<S> for f32 {
 571     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 572         s.emit_f32(*self)
 573     }
 574 }
 575
 576 impl<D: Decoder> Decodable<D> for f32 {
 577     fn decode(d: &mut D) -> Result<f32, D::Error> {
 578         d.read_f32()
 579     }
 580 }
 581
 582 impl<S: Encoder> Encodable<S> for f64 {
 583     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 584         s.emit_f64(*self)
 585     }
 586 }
 587
 588 impl<D: Decoder> Decodable<D> for f64 {
 589     fn decode(d: &mut D) -> Result<f64, D::Error> {
 590         d.read_f64()
 591     }
 592 }
 593
 594 impl<S: Encoder> Encodable<S> for bool {
 595     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 596         s.emit_bool(*self)
 597     }
 598 }
 599
 600 impl<D: Decoder> Decodable<D> for bool {
 601     fn decode(d: &mut D) -> Result<bool, D::Error> {
 602         d.read_bool()
 603     }
 604 }
 605
 606 impl<S: Encoder> Encodable<S> for char {
 607     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 608         s.emit_char(*self)
 609     }
 610 }
 611
 612 impl<D: Decoder> Decodable<D> for char {
 613     fn decode(d: &mut D) -> Result<char, D::Error> {
 614         d.read_char()
 615     }
 616 }
 617
 618 impl<S: Encoder> Encodable<S> for () {
 619     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 620         s.emit_unit()
 621     }
 622 }
 623
 624 impl<D: Decoder> Decodable<D> for () {
 625     fn decode(d: &mut D) -> Result<(), D::Error> {
 626         d.read_nil()
 627     }
 628 }
 629
 630 impl<S: Encoder, T> Encodable<S> for PhantomData<T> {
 631     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 632         s.emit_unit()
 633     }
 634 }
 635
 636 impl<D: Decoder, T> Decodable<D> for PhantomData<T> {
 637     fn decode(d: &mut D) -> Result<PhantomData<T>, D::Error> {
 638         d.read_nil()?;
 639         Ok(PhantomData)
 640     }
 641 }
 642
 643 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<[T]> {
 644     fn decode(d: &mut D) -> Result<Box<[T]>, D::Error> {
 645         let v: Vec<T> = Decodable::decode(d)?;
 646         Ok(v.into_boxed_slice())
 647     }
 648 }
 649
 650 impl<S: Encoder, T: Encodable<S>> Encodable<S> for Rc<T> {
 651     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 652         (**self).encode(s)
 653     }
 654 }
 655
 656 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<T> {
 657     fn decode(d: &mut D) -> Result<Rc<T>, D::Error> {
 658         Ok(Rc::new(Decodable::decode(d)?))
 659     }
 660 }
 661
 662 impl<S: Encoder, T: Encodable<S>> Encodable<S> for [T] {
 663     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 664         s.emit_seq(self.len(), |s| {
 665             for (i, e) in self.iter().enumerate() {
 666                 s.emit_seq_elt(i, |s| e.encode(s))?
 667             }
 668             Ok(())
 669         })
 670     }
 671 }
 672
 673 impl<S: Encoder, T: Encodable<S>> Encodable<S> for Vec<T> {
 674     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 675         s.emit_seq(self.len(), |s| {
 676             for (i, e) in self.iter().enumerate() {
 677                 s.emit_seq_elt(i, |s| e.encode(s))?
 678             }
 679             Ok(())
 680         })
 681     }
 682 }
 683
 684 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Vec<T> {
 685     fn decode(d: &mut D) -> Result<Vec<T>, D::Error> {
 686         d.read_seq(|d, len| {
 687             let mut v = Vec::with_capacity(len);
 688             for i in 0..len {
 689                 v.push(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 690             }
 691             Ok(v)
 692         })
 693     }
 694 }
 695
 696 impl<S: Encoder> Encodable<S> for [u8; 20] {
 697     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 698         s.emit_seq(self.len(), |s| {
 699             for (i, e) in self.iter().enumerate() {
 700                 s.emit_seq_elt(i, |s| e.encode(s))?
 701             }
 702             Ok(())
 703         })
 704     }
 705 }
 706
 707 impl<D: Decoder> Decodable<D> for [u8; 20] {
 708     fn decode(d: &mut D) -> Result<[u8; 20], D::Error> {
 709         d.read_seq(|d, len| {
 710             assert!(len == 20);
 711             let mut v = [0u8; 20];
 712             for i in 0..len {
 713                 v[i] = d.read_seq_elt(i, |d| Decodable::decode(d))?;
 714             }
 715             Ok(v)
 716         })
 717     }
 718 }
 719
 720 impl<'a, S: Encoder, T: Encodable<S>> Encodable<S> for Cow<'a, [T]>
 721 where
 722     [T]: ToOwned<Owned = Vec<T>>,
 723 {
 724     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 725         s.emit_seq(self.len(), |s| {
 726             for (i, e) in self.iter().enumerate() {
 727                 s.emit_seq_elt(i, |s| e.encode(s))?
 728             }
 729             Ok(())
 730         })
 731     }
 732 }
 733
 734 impl<D: Decoder, T: Decodable<D> + ToOwned> Decodable<D> for Cow<'static, [T]>
 735 where
 736     [T]: ToOwned<Owned = Vec<T>>,
 737 {
 738     fn decode(d: &mut D) -> Result<Cow<'static, [T]>, D::Error> {
 739         d.read_seq(|d, len| {
 740             let mut v = Vec::with_capacity(len);
 741             for i in 0..len {
 742                 v.push(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 743             }
 744             Ok(Cow::Owned(v))
 745         })
 746     }
 747 }
 748
 749 impl<S: Encoder, T: Encodable<S>> Encodable<S> for Option<T> {
 750     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 751         s.emit_option(|s| match *self {
 752             None => s.emit_option_none(),
 753             Some(ref v) => s.emit_option_some(|s| v.encode(s)),
 754         })
 755     }
 756 }
 757
 758 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Option<T> {
 759     fn decode(d: &mut D) -> Result<Option<T>, D::Error> {
 760         d.read_option(|d, b| if b { Ok(Some(Decodable::decode(d)?)) } else { Ok(None) })
 761     }
 762 }
 763
 764 impl<S: Encoder, T1: Encodable<S>, T2: Encodable<S>> Encodable<S> for Result<T1, T2> {
 765     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 766         s.emit_enum("Result", |s| match *self {
 767             Ok(ref v) => {
 768                 s.emit_enum_variant("Ok", 0, 1, |s| s.emit_enum_variant_arg(0, |s| v.encode(s)))
 769             }
 770             Err(ref v) => {
 771                 s.emit_enum_variant("Err", 1, 1, |s| s.emit_enum_variant_arg(0, |s| v.encode(s)))
 772             }
 773         })
 774     }
 775 }
 776
 777 impl<D: Decoder, T1: Decodable<D>, T2: Decodable<D>> Decodable<D> for Result<T1, T2> {
 778     fn decode(d: &mut D) -> Result<Result<T1, T2>, D::Error> {
 779         d.read_enum("Result", |d| {
 780             d.read_enum_variant(&["Ok", "Err"], |d, disr| match disr {
 781                 0 => Ok(Ok(d.read_enum_variant_arg(0, |d| T1::decode(d))?)),
 782                 1 => Ok(Err(d.read_enum_variant_arg(0, |d| T2::decode(d))?)),
 783                 _ => {
 784                     panic!(
 785                         "Encountered invalid discriminant while \
 786                                 decoding `Result`."
 787                     );
 788                 }
 789             })
 790         })
 791     }
 792 }
 793
 794 macro_rules! peel {
 795     ($name:ident, $($other:ident,)*) => (tuple! { $($other,)* })
 796 }
 797
 798 /// Evaluates to the number of tokens passed to it.
 799 ///
 800 /// Logarithmic counting: every one or two recursive expansions, the number of
 801 /// tokens to count is divided by two, instead of being reduced by one.
 802 /// Therefore, the recursion depth is the binary logarithm of the number of
 803 /// tokens to count, and the expanded tree is likewise very small.
 804 macro_rules! count {
 805     ()                     => (0usize);
 806     ($one:tt)              => (1usize);
 807     ($($pairs:tt $_p:tt)*) => (count!($($pairs)*) << 1usize);
 808     ($odd:tt $($rest:tt)*) => (count!($($rest)*) | 1usize);
 809 }
 810
 811 macro_rules! tuple {
 812     () => ();
 813     ( $($name:ident,)+ ) => (
 814         impl<D: Decoder, $($name: Decodable<D>),+> Decodable<D> for ($($name,)+) {
 815             #[allow(non_snake_case)]
 816             fn decode(d: &mut D) -> Result<($($name,)+), D::Error> {
 817                 let len: usize = count!($($name)+);
 818                 d.read_tuple(len, |d| {
 819                     let mut i = 0;
 820                     let ret = ($(d.read_tuple_arg({ i+=1; i-1 }, |d| -> Result<$name, D::Error> {
 821                         Decodable::decode(d)
 822                     })?,)+);
 823                     Ok(ret)
 824                 })
 825             }
 826         }
 827         impl<S: Encoder, $($name: Encodable<S>),+> Encodable<S> for ($($name,)+) {
 828             #[allow(non_snake_case)]
 829             fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 830                 let ($(ref $name,)+) = *self;
 831                 let mut n = 0;
 832                 $(let $name = $name; n += 1;)+
 833                 s.emit_tuple(n, |s| {
 834                     let mut i = 0;
 835                     $(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s))?;)+
 836                     Ok(())
 837                 })
 838             }
 839         }
 840         peel! { $($name,)+ }
 841     )
 842 }
 843
 844 tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 845
 846 impl<S: Encoder> Encodable<S> for path::Path {
 847     fn encode(&self, e: &mut S) -> Result<(), S::Error> {
 848         self.to_str().unwrap().encode(e)
 849     }
 850 }
 851
 852 impl<S: Encoder> Encodable<S> for path::PathBuf {
 853     fn encode(&self, e: &mut S) -> Result<(), S::Error> {
 854         path::Path::encode(self, e)
 855     }
 856 }
 857
 858 impl<D: Decoder> Decodable<D> for path::PathBuf {
 859     fn decode(d: &mut D) -> Result<path::PathBuf, D::Error> {
 860         let bytes: String = Decodable::decode(d)?;
 861         Ok(path::PathBuf::from(bytes))
 862     }
 863 }
 864
 865 impl<S: Encoder, T: Encodable<S> + Copy> Encodable<S> for Cell<T> {
 866     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 867         self.get().encode(s)
 868     }
 869 }
 870
 871 impl<D: Decoder, T: Decodable<D> + Copy> Decodable<D> for Cell<T> {
 872     fn decode(d: &mut D) -> Result<Cell<T>, D::Error> {
 873         Ok(Cell::new(Decodable::decode(d)?))
 874     }
 875 }
 876
 877 // FIXME: #15036
 878 // Should use `try_borrow`, returning a
 879 // `encoder.error("attempting to Encode borrowed RefCell")`
 880 // from `encode` when `try_borrow` returns `None`.
 881
 882 impl<S: Encoder, T: Encodable<S>> Encodable<S> for RefCell<T> {
 883     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 884         self.borrow().encode(s)
 885     }
 886 }
 887
 888 impl<D: Decoder, T: Decodable<D>> Decodable<D> for RefCell<T> {
 889     fn decode(d: &mut D) -> Result<RefCell<T>, D::Error> {
 890         Ok(RefCell::new(Decodable::decode(d)?))
 891     }
 892 }
 893
 894 impl<S: Encoder, T: Encodable<S>> Encodable<S> for Arc<T> {
 895     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 896         (**self).encode(s)
 897     }
 898 }
 899
 900 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<T> {
 901     fn decode(d: &mut D) -> Result<Arc<T>, D::Error> {
 902         Ok(Arc::new(Decodable::decode(d)?))
 903     }
 904 }
 905
 906 impl<S: Encoder, T: ?Sized + Encodable<S>> Encodable<S> for Box<T> {
 907     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 908         (**self).encode(s)
 909     }
 910 }
 911 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<T> {
 912     fn decode(d: &mut D) -> Result<Box<T>, D::Error> {
 913         Ok(box Decodable::decode(d)?)
 914     }
 915 }