vendor/serde/src/private/de.rs

   1 use lib::*;
   2
   3 use de::value::{BorrowedBytesDeserializer, BytesDeserializer};
   4 use de::{Deserialize, Deserializer, Error, IntoDeserializer, Visitor};
   5
   6 #[cfg(any(feature = "std", feature = "alloc"))]
   7 use de::{DeserializeSeed, MapAccess, Unexpected};
   8
   9 #[cfg(any(feature = "std", feature = "alloc"))]
  10 pub use self::content::{
  11     Content, ContentDeserializer, ContentRefDeserializer, EnumDeserializer,
  12     InternallyTaggedUnitVisitor, TagContentOtherField, TagContentOtherFieldVisitor,
  13     TagOrContentField, TagOrContentFieldVisitor, TaggedContentVisitor, UntaggedUnitVisitor,
  14 };
  15
  16 pub use seed::InPlaceSeed;
  17
  18 /// If the missing field is of type `Option<T>` then treat is as `None`,
  19 /// otherwise it is an error.
  20 pub fn missing_field<'de, V, E>(field: &'static str) -> Result<V, E>
  21 where
  22     V: Deserialize<'de>,
  23     E: Error,
  24 {
  25     struct MissingFieldDeserializer<E>(&'static str, PhantomData<E>);
  26
  27     impl<'de, E> Deserializer<'de> for MissingFieldDeserializer<E>
  28     where
  29         E: Error,
  30     {
  31         type Error = E;
  32
  33         fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, E>
  34         where
  35             V: Visitor<'de>,
  36         {
  37             Err(Error::missing_field(self.0))
  38         }
  39
  40         fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
  41         where
  42             V: Visitor<'de>,
  43         {
  44             visitor.visit_none()
  45         }
  46
  47         forward_to_deserialize_any! {
  48             bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
  49             bytes byte_buf unit unit_struct newtype_struct seq tuple
  50             tuple_struct map struct enum identifier ignored_any
  51         }
  52     }
  53
  54     let deserializer = MissingFieldDeserializer(field, PhantomData);
  55     Deserialize::deserialize(deserializer)
  56 }
  57
  58 #[cfg(any(feature = "std", feature = "alloc"))]
  59 pub fn borrow_cow_str<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error>
  60 where
  61     D: Deserializer<'de>,
  62     R: From<Cow<'a, str>>,
  63 {
  64     struct CowStrVisitor;
  65
  66     impl<'a> Visitor<'a> for CowStrVisitor {
  67         type Value = Cow<'a, str>;
  68
  69         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  70             formatter.write_str("a string")
  71         }
  72
  73         fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
  74         where
  75             E: Error,
  76         {
  77             Ok(Cow::Owned(v.to_owned()))
  78         }
  79
  80         fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
  81         where
  82             E: Error,
  83         {
  84             Ok(Cow::Borrowed(v))
  85         }
  86
  87         fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
  88         where
  89             E: Error,
  90         {
  91             Ok(Cow::Owned(v))
  92         }
  93
  94         fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
  95         where
  96             E: Error,
  97         {
  98             match str::from_utf8(v) {
  99                 Ok(s) => Ok(Cow::Owned(s.to_owned())),
 100                 Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
 101             }
 102         }
 103
 104         fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
 105         where
 106             E: Error,
 107         {
 108             match str::from_utf8(v) {
 109                 Ok(s) => Ok(Cow::Borrowed(s)),
 110                 Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
 111             }
 112         }
 113
 114         fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
 115         where
 116             E: Error,
 117         {
 118             match String::from_utf8(v) {
 119                 Ok(s) => Ok(Cow::Owned(s)),
 120                 Err(e) => Err(Error::invalid_value(
 121                     Unexpected::Bytes(&e.into_bytes()),
 122                     &self,
 123                 )),
 124             }
 125         }
 126     }
 127
 128     deserializer.deserialize_str(CowStrVisitor).map(From::from)
 129 }
 130
 131 #[cfg(any(feature = "std", feature = "alloc"))]
 132 pub fn borrow_cow_bytes<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error>
 133 where
 134     D: Deserializer<'de>,
 135     R: From<Cow<'a, [u8]>>,
 136 {
 137     struct CowBytesVisitor;
 138
 139     impl<'a> Visitor<'a> for CowBytesVisitor {
 140         type Value = Cow<'a, [u8]>;
 141
 142         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 143             formatter.write_str("a byte array")
 144         }
 145
 146         fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
 147         where
 148             E: Error,
 149         {
 150             Ok(Cow::Owned(v.as_bytes().to_vec()))
 151         }
 152
 153         fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
 154         where
 155             E: Error,
 156         {
 157             Ok(Cow::Borrowed(v.as_bytes()))
 158         }
 159
 160         fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
 161         where
 162             E: Error,
 163         {
 164             Ok(Cow::Owned(v.into_bytes()))
 165         }
 166
 167         fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
 168         where
 169             E: Error,
 170         {
 171             Ok(Cow::Owned(v.to_vec()))
 172         }
 173
 174         fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
 175         where
 176             E: Error,
 177         {
 178             Ok(Cow::Borrowed(v))
 179         }
 180
 181         fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
 182         where
 183             E: Error,
 184         {
 185             Ok(Cow::Owned(v))
 186         }
 187     }
 188
 189     deserializer
 190         .deserialize_bytes(CowBytesVisitor)
 191         .map(From::from)
 192 }
 193
 194 #[cfg(any(feature = "std", feature = "alloc"))]
 195 mod content {
 196     // This module is private and nothing here should be used outside of
 197     // generated code.
 198     //
 199     // We will iterate on the implementation for a few releases and only have to
 200     // worry about backward compatibility for the `untagged` and `tag` attributes
 201     // rather than for this entire mechanism.
 202     //
 203     // This issue is tracking making some of this stuff public:
 204     // https://github.com/serde-rs/serde/issues/741
 205
 206     use lib::*;
 207
 208     use __private::size_hint;
 209     use actually_private;
 210     use de::{
 211         self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Expected, IgnoredAny,
 212         MapAccess, SeqAccess, Unexpected, Visitor,
 213     };
 214
 215     /// Used from generated code to buffer the contents of the Deserializer when
 216     /// deserializing untagged enums and internally tagged enums.
 217     ///
 218     /// Not public API. Use serde-value instead.
 219     #[derive(Debug, Clone)]
 220     pub enum Content<'de> {
 221         Bool(bool),
 222
 223         U8(u8),
 224         U16(u16),
 225         U32(u32),
 226         U64(u64),
 227
 228         I8(i8),
 229         I16(i16),
 230         I32(i32),
 231         I64(i64),
 232
 233         F32(f32),
 234         F64(f64),
 235
 236         Char(char),
 237         String(String),
 238         Str(&'de str),
 239         ByteBuf(Vec<u8>),
 240         Bytes(&'de [u8]),
 241
 242         None,
 243         Some(Box<Content<'de>>),
 244
 245         Unit,
 246         Newtype(Box<Content<'de>>),
 247         Seq(Vec<Content<'de>>),
 248         Map(Vec<(Content<'de>, Content<'de>)>),
 249     }
 250
 251     impl<'de> Content<'de> {
 252         pub fn as_str(&self) -> Option<&str> {
 253             match *self {
 254                 Content::Str(x) => Some(x),
 255                 Content::String(ref x) => Some(x),
 256                 Content::Bytes(x) => str::from_utf8(x).ok(),
 257                 Content::ByteBuf(ref x) => str::from_utf8(x).ok(),
 258                 _ => None,
 259             }
 260         }
 261
 262         #[cold]
 263         fn unexpected(&self) -> Unexpected {
 264             match *self {
 265                 Content::Bool(b) => Unexpected::Bool(b),
 266                 Content::U8(n) => Unexpected::Unsigned(n as u64),
 267                 Content::U16(n) => Unexpected::Unsigned(n as u64),
 268                 Content::U32(n) => Unexpected::Unsigned(n as u64),
 269                 Content::U64(n) => Unexpected::Unsigned(n),
 270                 Content::I8(n) => Unexpected::Signed(n as i64),
 271                 Content::I16(n) => Unexpected::Signed(n as i64),
 272                 Content::I32(n) => Unexpected::Signed(n as i64),
 273                 Content::I64(n) => Unexpected::Signed(n),
 274                 Content::F32(f) => Unexpected::Float(f as f64),
 275                 Content::F64(f) => Unexpected::Float(f),
 276                 Content::Char(c) => Unexpected::Char(c),
 277                 Content::String(ref s) => Unexpected::Str(s),
 278                 Content::Str(s) => Unexpected::Str(s),
 279                 Content::ByteBuf(ref b) => Unexpected::Bytes(b),
 280                 Content::Bytes(b) => Unexpected::Bytes(b),
 281                 Content::None | Content::Some(_) => Unexpected::Option,
 282                 Content::Unit => Unexpected::Unit,
 283                 Content::Newtype(_) => Unexpected::NewtypeStruct,
 284                 Content::Seq(_) => Unexpected::Seq,
 285                 Content::Map(_) => Unexpected::Map,
 286             }
 287         }
 288     }
 289
 290     impl<'de> Deserialize<'de> for Content<'de> {
 291         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 292         where
 293             D: Deserializer<'de>,
 294         {
 295             // Untagged and internally tagged enums are only supported in
 296             // self-describing formats.
 297             let visitor = ContentVisitor { value: PhantomData };
 298             deserializer.__deserialize_content(actually_private::T, visitor)
 299         }
 300     }
 301
 302     struct ContentVisitor<'de> {
 303         value: PhantomData<Content<'de>>,
 304     }
 305
 306     impl<'de> ContentVisitor<'de> {
 307         fn new() -> Self {
 308             ContentVisitor { value: PhantomData }
 309         }
 310     }
 311
 312     impl<'de> Visitor<'de> for ContentVisitor<'de> {
 313         type Value = Content<'de>;
 314
 315         fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 316             fmt.write_str("any value")
 317         }
 318
 319         fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F>
 320         where
 321             F: de::Error,
 322         {
 323             Ok(Content::Bool(value))
 324         }
 325
 326         fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F>
 327         where
 328             F: de::Error,
 329         {
 330             Ok(Content::I8(value))
 331         }
 332
 333         fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
 334         where
 335             F: de::Error,
 336         {
 337             Ok(Content::I16(value))
 338         }
 339
 340         fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F>
 341         where
 342             F: de::Error,
 343         {
 344             Ok(Content::I32(value))
 345         }
 346
 347         fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F>
 348         where
 349             F: de::Error,
 350         {
 351             Ok(Content::I64(value))
 352         }
 353
 354         fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F>
 355         where
 356             F: de::Error,
 357         {
 358             Ok(Content::U8(value))
 359         }
 360
 361         fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
 362         where
 363             F: de::Error,
 364         {
 365             Ok(Content::U16(value))
 366         }
 367
 368         fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F>
 369         where
 370             F: de::Error,
 371         {
 372             Ok(Content::U32(value))
 373         }
 374
 375         fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F>
 376         where
 377             F: de::Error,
 378         {
 379             Ok(Content::U64(value))
 380         }
 381
 382         fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F>
 383         where
 384             F: de::Error,
 385         {
 386             Ok(Content::F32(value))
 387         }
 388
 389         fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F>
 390         where
 391             F: de::Error,
 392         {
 393             Ok(Content::F64(value))
 394         }
 395
 396         fn visit_char<F>(self, value: char) -> Result<Self::Value, F>
 397         where
 398             F: de::Error,
 399         {
 400             Ok(Content::Char(value))
 401         }
 402
 403         fn visit_str<F>(self, value: &str) -> Result<Self::Value, F>
 404         where
 405             F: de::Error,
 406         {
 407             Ok(Content::String(value.into()))
 408         }
 409
 410         fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F>
 411         where
 412             F: de::Error,
 413         {
 414             Ok(Content::Str(value))
 415         }
 416
 417         fn visit_string<F>(self, value: String) -> Result<Self::Value, F>
 418         where
 419             F: de::Error,
 420         {
 421             Ok(Content::String(value))
 422         }
 423
 424         fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F>
 425         where
 426             F: de::Error,
 427         {
 428             Ok(Content::ByteBuf(value.into()))
 429         }
 430
 431         fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F>
 432         where
 433             F: de::Error,
 434         {
 435             Ok(Content::Bytes(value))
 436         }
 437
 438         fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F>
 439         where
 440             F: de::Error,
 441         {
 442             Ok(Content::ByteBuf(value))
 443         }
 444
 445         fn visit_unit<F>(self) -> Result<Self::Value, F>
 446         where
 447             F: de::Error,
 448         {
 449             Ok(Content::Unit)
 450         }
 451
 452         fn visit_none<F>(self) -> Result<Self::Value, F>
 453         where
 454             F: de::Error,
 455         {
 456             Ok(Content::None)
 457         }
 458
 459         fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
 460         where
 461             D: Deserializer<'de>,
 462         {
 463             Deserialize::deserialize(deserializer).map(|v| Content::Some(Box::new(v)))
 464         }
 465
 466         fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
 467         where
 468             D: Deserializer<'de>,
 469         {
 470             Deserialize::deserialize(deserializer).map(|v| Content::Newtype(Box::new(v)))
 471         }
 472
 473         fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
 474         where
 475             V: SeqAccess<'de>,
 476         {
 477             let mut vec = Vec::with_capacity(size_hint::cautious(visitor.size_hint()));
 478             while let Some(e) = try!(visitor.next_element()) {
 479                 vec.push(e);
 480             }
 481             Ok(Content::Seq(vec))
 482         }
 483
 484         fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
 485         where
 486             V: MapAccess<'de>,
 487         {
 488             let mut vec = Vec::with_capacity(size_hint::cautious(visitor.size_hint()));
 489             while let Some(kv) = try!(visitor.next_entry()) {
 490                 vec.push(kv);
 491             }
 492             Ok(Content::Map(vec))
 493         }
 494
 495         fn visit_enum<V>(self, _visitor: V) -> Result<Self::Value, V::Error>
 496         where
 497             V: EnumAccess<'de>,
 498         {
 499             Err(de::Error::custom(
 500                 "untagged and internally tagged enums do not support enum input",
 501             ))
 502         }
 503     }
 504
 505     /// This is the type of the map keys in an internally tagged enum.
 506     ///
 507     /// Not public API.
 508     pub enum TagOrContent<'de> {
 509         Tag,
 510         Content(Content<'de>),
 511     }
 512
 513     struct TagOrContentVisitor<'de> {
 514         name: &'static str,
 515         value: PhantomData<TagOrContent<'de>>,
 516     }
 517
 518     impl<'de> TagOrContentVisitor<'de> {
 519         fn new(name: &'static str) -> Self {
 520             TagOrContentVisitor {
 521                 name: name,
 522                 value: PhantomData,
 523             }
 524         }
 525     }
 526
 527     impl<'de> DeserializeSeed<'de> for TagOrContentVisitor<'de> {
 528         type Value = TagOrContent<'de>;
 529
 530         fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
 531         where
 532             D: Deserializer<'de>,
 533         {
 534             // Internally tagged enums are only supported in self-describing
 535             // formats.
 536             deserializer.deserialize_any(self)
 537         }
 538     }
 539
 540     impl<'de> Visitor<'de> for TagOrContentVisitor<'de> {
 541         type Value = TagOrContent<'de>;
 542
 543         fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 544             write!(fmt, "a type tag `{}` or any other value", self.name)
 545         }
 546
 547         fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F>
 548         where
 549             F: de::Error,
 550         {
 551             ContentVisitor::new()
 552                 .visit_bool(value)
 553                 .map(TagOrContent::Content)
 554         }
 555
 556         fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F>
 557         where
 558             F: de::Error,
 559         {
 560             ContentVisitor::new()
 561                 .visit_i8(value)
 562                 .map(TagOrContent::Content)
 563         }
 564
 565         fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
 566         where
 567             F: de::Error,
 568         {
 569             ContentVisitor::new()
 570                 .visit_i16(value)
 571                 .map(TagOrContent::Content)
 572         }
 573
 574         fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F>
 575         where
 576             F: de::Error,
 577         {
 578             ContentVisitor::new()
 579                 .visit_i32(value)
 580                 .map(TagOrContent::Content)
 581         }
 582
 583         fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F>
 584         where
 585             F: de::Error,
 586         {
 587             ContentVisitor::new()
 588                 .visit_i64(value)
 589                 .map(TagOrContent::Content)
 590         }
 591
 592         fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F>
 593         where
 594             F: de::Error,
 595         {
 596             ContentVisitor::new()
 597                 .visit_u8(value)
 598                 .map(TagOrContent::Content)
 599         }
 600
 601         fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
 602         where
 603             F: de::Error,
 604         {
 605             ContentVisitor::new()
 606                 .visit_u16(value)
 607                 .map(TagOrContent::Content)
 608         }
 609
 610         fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F>
 611         where
 612             F: de::Error,
 613         {
 614             ContentVisitor::new()
 615                 .visit_u32(value)
 616                 .map(TagOrContent::Content)
 617         }
 618
 619         fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F>
 620         where
 621             F: de::Error,
 622         {
 623             ContentVisitor::new()
 624                 .visit_u64(value)
 625                 .map(TagOrContent::Content)
 626         }
 627
 628         fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F>
 629         where
 630             F: de::Error,
 631         {
 632             ContentVisitor::new()
 633                 .visit_f32(value)
 634                 .map(TagOrContent::Content)
 635         }
 636
 637         fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F>
 638         where
 639             F: de::Error,
 640         {
 641             ContentVisitor::new()
 642                 .visit_f64(value)
 643                 .map(TagOrContent::Content)
 644         }
 645
 646         fn visit_char<F>(self, value: char) -> Result<Self::Value, F>
 647         where
 648             F: de::Error,
 649         {
 650             ContentVisitor::new()
 651                 .visit_char(value)
 652                 .map(TagOrContent::Content)
 653         }
 654
 655         fn visit_str<F>(self, value: &str) -> Result<Self::Value, F>
 656         where
 657             F: de::Error,
 658         {
 659             if value == self.name {
 660                 Ok(TagOrContent::Tag)
 661             } else {
 662                 ContentVisitor::new()
 663                     .visit_str(value)
 664                     .map(TagOrContent::Content)
 665             }
 666         }
 667
 668         fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F>
 669         where
 670             F: de::Error,
 671         {
 672             if value == self.name {
 673                 Ok(TagOrContent::Tag)
 674             } else {
 675                 ContentVisitor::new()
 676                     .visit_borrowed_str(value)
 677                     .map(TagOrContent::Content)
 678             }
 679         }
 680
 681         fn visit_string<F>(self, value: String) -> Result<Self::Value, F>
 682         where
 683             F: de::Error,
 684         {
 685             if value == self.name {
 686                 Ok(TagOrContent::Tag)
 687             } else {
 688                 ContentVisitor::new()
 689                     .visit_string(value)
 690                     .map(TagOrContent::Content)
 691             }
 692         }
 693
 694         fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F>
 695         where
 696             F: de::Error,
 697         {
 698             if value == self.name.as_bytes() {
 699                 Ok(TagOrContent::Tag)
 700             } else {
 701                 ContentVisitor::new()
 702                     .visit_bytes(value)
 703                     .map(TagOrContent::Content)
 704             }
 705         }
 706
 707         fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F>
 708         where
 709             F: de::Error,
 710         {
 711             if value == self.name.as_bytes() {
 712                 Ok(TagOrContent::Tag)
 713             } else {
 714                 ContentVisitor::new()
 715                     .visit_borrowed_bytes(value)
 716                     .map(TagOrContent::Content)
 717             }
 718         }
 719
 720         fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F>
 721         where
 722             F: de::Error,
 723         {
 724             if value == self.name.as_bytes() {
 725                 Ok(TagOrContent::Tag)
 726             } else {
 727                 ContentVisitor::new()
 728                     .visit_byte_buf(value)
 729                     .map(TagOrContent::Content)
 730             }
 731         }
 732
 733         fn visit_unit<F>(self) -> Result<Self::Value, F>
 734         where
 735             F: de::Error,
 736         {
 737             ContentVisitor::new()
 738                 .visit_unit()
 739                 .map(TagOrContent::Content)
 740         }
 741
 742         fn visit_none<F>(self) -> Result<Self::Value, F>
 743         where
 744             F: de::Error,
 745         {
 746             ContentVisitor::new()
 747                 .visit_none()
 748                 .map(TagOrContent::Content)
 749         }
 750
 751         fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
 752         where
 753             D: Deserializer<'de>,
 754         {
 755             ContentVisitor::new()
 756                 .visit_some(deserializer)
 757                 .map(TagOrContent::Content)
 758         }
 759
 760         fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
 761         where
 762             D: Deserializer<'de>,
 763         {
 764             ContentVisitor::new()
 765                 .visit_newtype_struct(deserializer)
 766                 .map(TagOrContent::Content)
 767         }
 768
 769         fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
 770         where
 771             V: SeqAccess<'de>,
 772         {
 773             ContentVisitor::new()
 774                 .visit_seq(visitor)
 775                 .map(TagOrContent::Content)
 776         }
 777
 778         fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
 779         where
 780             V: MapAccess<'de>,
 781         {
 782             ContentVisitor::new()
 783                 .visit_map(visitor)
 784                 .map(TagOrContent::Content)
 785         }
 786
 787         fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
 788         where
 789             V: EnumAccess<'de>,
 790         {
 791             ContentVisitor::new()
 792                 .visit_enum(visitor)
 793                 .map(TagOrContent::Content)
 794         }
 795     }
 796
 797     /// Used by generated code to deserialize an internally tagged enum.
 798     ///
 799     /// Not public API.
 800     pub struct TaggedContent<'de, T> {
 801         pub tag: T,
 802         pub content: Content<'de>,
 803     }
 804
 805     /// Not public API.
 806     pub struct TaggedContentVisitor<'de, T> {
 807         tag_name: &'static str,
 808         expecting: &'static str,
 809         value: PhantomData<TaggedContent<'de, T>>,
 810     }
 811
 812     impl<'de, T> TaggedContentVisitor<'de, T> {
 813         /// Visitor for the content of an internally tagged enum with the given
 814         /// tag name.
 815         pub fn new(name: &'static str, expecting: &'static str) -> Self {
 816             TaggedContentVisitor {
 817                 tag_name: name,
 818                 expecting: expecting,
 819                 value: PhantomData,
 820             }
 821         }
 822     }
 823
 824     impl<'de, T> DeserializeSeed<'de> for TaggedContentVisitor<'de, T>
 825     where
 826         T: Deserialize<'de>,
 827     {
 828         type Value = TaggedContent<'de, T>;
 829
 830         fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
 831         where
 832             D: Deserializer<'de>,
 833         {
 834             // Internally tagged enums are only supported in self-describing
 835             // formats.
 836             deserializer.deserialize_any(self)
 837         }
 838     }
 839
 840     impl<'de, T> Visitor<'de> for TaggedContentVisitor<'de, T>
 841     where
 842         T: Deserialize<'de>,
 843     {
 844         type Value = TaggedContent<'de, T>;
 845
 846         fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 847             fmt.write_str(self.expecting)
 848         }
 849
 850         fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
 851         where
 852             S: SeqAccess<'de>,
 853         {
 854             let tag = match try!(seq.next_element()) {
 855                 Some(tag) => tag,
 856                 None => {
 857                     return Err(de::Error::missing_field(self.tag_name));
 858                 }
 859             };
 860             let rest = de::value::SeqAccessDeserializer::new(seq);
 861             Ok(TaggedContent {
 862                 tag: tag,
 863                 content: try!(Content::deserialize(rest)),
 864             })
 865         }
 866
 867         fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
 868         where
 869             M: MapAccess<'de>,
 870         {
 871             let mut tag = None;
 872             let mut vec = Vec::with_capacity(size_hint::cautious(map.size_hint()));
 873             while let Some(k) = try!(map.next_key_seed(TagOrContentVisitor::new(self.tag_name))) {
 874                 match k {
 875                     TagOrContent::Tag => {
 876                         if tag.is_some() {
 877                             return Err(de::Error::duplicate_field(self.tag_name));
 878                         }
 879                         tag = Some(try!(map.next_value()));
 880                     }
 881                     TagOrContent::Content(k) => {
 882                         let v = try!(map.next_value());
 883                         vec.push((k, v));
 884                     }
 885                 }
 886             }
 887             match tag {
 888                 None => Err(de::Error::missing_field(self.tag_name)),
 889                 Some(tag) => Ok(TaggedContent {
 890                     tag: tag,
 891                     content: Content::Map(vec),
 892                 }),
 893             }
 894         }
 895     }
 896
 897     /// Used by generated code to deserialize an adjacently tagged enum.
 898     ///
 899     /// Not public API.
 900     pub enum TagOrContentField {
 901         Tag,
 902         Content,
 903     }
 904
 905     /// Not public API.
 906     pub struct TagOrContentFieldVisitor {
 907         pub tag: &'static str,
 908         pub content: &'static str,
 909     }
 910
 911     impl<'de> DeserializeSeed<'de> for TagOrContentFieldVisitor {
 912         type Value = TagOrContentField;
 913
 914         fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
 915         where
 916             D: Deserializer<'de>,
 917         {
 918             deserializer.deserialize_str(self)
 919         }
 920     }
 921
 922     impl<'de> Visitor<'de> for TagOrContentFieldVisitor {
 923         type Value = TagOrContentField;
 924
 925         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 926             write!(formatter, "{:?} or {:?}", self.tag, self.content)
 927         }
 928
 929         fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
 930         where
 931             E: de::Error,
 932         {
 933             if field == self.tag {
 934                 Ok(TagOrContentField::Tag)
 935             } else if field == self.content {
 936                 Ok(TagOrContentField::Content)
 937             } else {
 938                 Err(de::Error::invalid_value(Unexpected::Str(field), &self))
 939             }
 940         }
 941     }
 942
 943     /// Used by generated code to deserialize an adjacently tagged enum when
 944     /// ignoring unrelated fields is allowed.
 945     ///
 946     /// Not public API.
 947     pub enum TagContentOtherField {
 948         Tag,
 949         Content,
 950         Other,
 951     }
 952
 953     /// Not public API.
 954     pub struct TagContentOtherFieldVisitor {
 955         pub tag: &'static str,
 956         pub content: &'static str,
 957     }
 958
 959     impl<'de> DeserializeSeed<'de> for TagContentOtherFieldVisitor {
 960         type Value = TagContentOtherField;
 961
 962         fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
 963         where
 964             D: Deserializer<'de>,
 965         {
 966             deserializer.deserialize_str(self)
 967         }
 968     }
 969
 970     impl<'de> Visitor<'de> for TagContentOtherFieldVisitor {
 971         type Value = TagContentOtherField;
 972
 973         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 974             write!(
 975                 formatter,
 976                 "{:?}, {:?}, or other ignored fields",
 977                 self.tag, self.content
 978             )
 979         }
 980
 981         fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
 982         where
 983             E: de::Error,
 984         {
 985             if field == self.tag {
 986                 Ok(TagContentOtherField::Tag)
 987             } else if field == self.content {
 988                 Ok(TagContentOtherField::Content)
 989             } else {
 990                 Ok(TagContentOtherField::Other)
 991             }
 992         }
 993     }
 994
 995     /// Not public API
 996     pub struct ContentDeserializer<'de, E> {
 997         content: Content<'de>,
 998         err: PhantomData<E>,
 999     }
1000
1001     impl<'de, E> ContentDeserializer<'de, E>
1002     where
1003         E: de::Error,
1004     {
1005         #[cold]
1006         fn invalid_type(self, exp: &Expected) -> E {
1007             de::Error::invalid_type(self.content.unexpected(), exp)
1008         }
1009
1010         fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E>
1011         where
1012             V: Visitor<'de>,
1013         {
1014             match self.content {
1015                 Content::U8(v) => visitor.visit_u8(v),
1016                 Content::U16(v) => visitor.visit_u16(v),
1017                 Content::U32(v) => visitor.visit_u32(v),
1018                 Content::U64(v) => visitor.visit_u64(v),
1019                 Content::I8(v) => visitor.visit_i8(v),
1020                 Content::I16(v) => visitor.visit_i16(v),
1021                 Content::I32(v) => visitor.visit_i32(v),
1022                 Content::I64(v) => visitor.visit_i64(v),
1023                 _ => Err(self.invalid_type(&visitor)),
1024             }
1025         }
1026
1027         fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
1028         where
1029             V: Visitor<'de>,
1030         {
1031             match self.content {
1032                 Content::F32(v) => visitor.visit_f32(v),
1033                 Content::F64(v) => visitor.visit_f64(v),
1034                 Content::U8(v) => visitor.visit_u8(v),
1035                 Content::U16(v) => visitor.visit_u16(v),
1036                 Content::U32(v) => visitor.visit_u32(v),
1037                 Content::U64(v) => visitor.visit_u64(v),
1038                 Content::I8(v) => visitor.visit_i8(v),
1039                 Content::I16(v) => visitor.visit_i16(v),
1040                 Content::I32(v) => visitor.visit_i32(v),
1041                 Content::I64(v) => visitor.visit_i64(v),
1042                 _ => Err(self.invalid_type(&visitor)),
1043             }
1044         }
1045     }
1046
1047     fn visit_content_seq<'de, V, E>(content: Vec<Content<'de>>, visitor: V) -> Result<V::Value, E>
1048     where
1049         V: Visitor<'de>,
1050         E: de::Error,
1051     {
1052         let seq = content.into_iter().map(ContentDeserializer::new);
1053         let mut seq_visitor = de::value::SeqDeserializer::new(seq);
1054         let value = try!(visitor.visit_seq(&mut seq_visitor));
1055         try!(seq_visitor.end());
1056         Ok(value)
1057     }
1058
1059     fn visit_content_map<'de, V, E>(
1060         content: Vec<(Content<'de>, Content<'de>)>,
1061         visitor: V,
1062     ) -> Result<V::Value, E>
1063     where
1064         V: Visitor<'de>,
1065         E: de::Error,
1066     {
1067         let map = content
1068             .into_iter()
1069             .map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v)));
1070         let mut map_visitor = de::value::MapDeserializer::new(map);
1071         let value = try!(visitor.visit_map(&mut map_visitor));
1072         try!(map_visitor.end());
1073         Ok(value)
1074     }
1075
1076     /// Used when deserializing an internally tagged enum because the content
1077     /// will be used exactly once.
1078     impl<'de, E> Deserializer<'de> for ContentDeserializer<'de, E>
1079     where
1080         E: de::Error,
1081     {
1082         type Error = E;
1083
1084         fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1085         where
1086             V: Visitor<'de>,
1087         {
1088             match self.content {
1089                 Content::Bool(v) => visitor.visit_bool(v),
1090                 Content::U8(v) => visitor.visit_u8(v),
1091                 Content::U16(v) => visitor.visit_u16(v),
1092                 Content::U32(v) => visitor.visit_u32(v),
1093                 Content::U64(v) => visitor.visit_u64(v),
1094                 Content::I8(v) => visitor.visit_i8(v),
1095                 Content::I16(v) => visitor.visit_i16(v),
1096                 Content::I32(v) => visitor.visit_i32(v),
1097                 Content::I64(v) => visitor.visit_i64(v),
1098                 Content::F32(v) => visitor.visit_f32(v),
1099                 Content::F64(v) => visitor.visit_f64(v),
1100                 Content::Char(v) => visitor.visit_char(v),
1101                 Content::String(v) => visitor.visit_string(v),
1102                 Content::Str(v) => visitor.visit_borrowed_str(v),
1103                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
1104                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1105                 Content::Unit => visitor.visit_unit(),
1106                 Content::None => visitor.visit_none(),
1107                 Content::Some(v) => visitor.visit_some(ContentDeserializer::new(*v)),
1108                 Content::Newtype(v) => visitor.visit_newtype_struct(ContentDeserializer::new(*v)),
1109                 Content::Seq(v) => visit_content_seq(v, visitor),
1110                 Content::Map(v) => visit_content_map(v, visitor),
1111             }
1112         }
1113
1114         fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1115         where
1116             V: Visitor<'de>,
1117         {
1118             match self.content {
1119                 Content::Bool(v) => visitor.visit_bool(v),
1120                 _ => Err(self.invalid_type(&visitor)),
1121             }
1122         }
1123
1124         fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1125         where
1126             V: Visitor<'de>,
1127         {
1128             self.deserialize_integer(visitor)
1129         }
1130
1131         fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1132         where
1133             V: Visitor<'de>,
1134         {
1135             self.deserialize_integer(visitor)
1136         }
1137
1138         fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1139         where
1140             V: Visitor<'de>,
1141         {
1142             self.deserialize_integer(visitor)
1143         }
1144
1145         fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1146         where
1147             V: Visitor<'de>,
1148         {
1149             self.deserialize_integer(visitor)
1150         }
1151
1152         fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1153         where
1154             V: Visitor<'de>,
1155         {
1156             self.deserialize_integer(visitor)
1157         }
1158
1159         fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1160         where
1161             V: Visitor<'de>,
1162         {
1163             self.deserialize_integer(visitor)
1164         }
1165
1166         fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1167         where
1168             V: Visitor<'de>,
1169         {
1170             self.deserialize_integer(visitor)
1171         }
1172
1173         fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1174         where
1175             V: Visitor<'de>,
1176         {
1177             self.deserialize_integer(visitor)
1178         }
1179
1180         fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1181         where
1182             V: Visitor<'de>,
1183         {
1184             self.deserialize_float(visitor)
1185         }
1186
1187         fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1188         where
1189             V: Visitor<'de>,
1190         {
1191             self.deserialize_float(visitor)
1192         }
1193
1194         fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1195         where
1196             V: Visitor<'de>,
1197         {
1198             match self.content {
1199                 Content::Char(v) => visitor.visit_char(v),
1200                 Content::String(v) => visitor.visit_string(v),
1201                 Content::Str(v) => visitor.visit_borrowed_str(v),
1202                 _ => Err(self.invalid_type(&visitor)),
1203             }
1204         }
1205
1206         fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1207         where
1208             V: Visitor<'de>,
1209         {
1210             self.deserialize_string(visitor)
1211         }
1212
1213         fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1214         where
1215             V: Visitor<'de>,
1216         {
1217             match self.content {
1218                 Content::String(v) => visitor.visit_string(v),
1219                 Content::Str(v) => visitor.visit_borrowed_str(v),
1220                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
1221                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1222                 _ => Err(self.invalid_type(&visitor)),
1223             }
1224         }
1225
1226         fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1227         where
1228             V: Visitor<'de>,
1229         {
1230             self.deserialize_byte_buf(visitor)
1231         }
1232
1233         fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1234         where
1235             V: Visitor<'de>,
1236         {
1237             match self.content {
1238                 Content::String(v) => visitor.visit_string(v),
1239                 Content::Str(v) => visitor.visit_borrowed_str(v),
1240                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
1241                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1242                 Content::Seq(v) => visit_content_seq(v, visitor),
1243                 _ => Err(self.invalid_type(&visitor)),
1244             }
1245         }
1246
1247         fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1248         where
1249             V: Visitor<'de>,
1250         {
1251             match self.content {
1252                 Content::None => visitor.visit_none(),
1253                 Content::Some(v) => visitor.visit_some(ContentDeserializer::new(*v)),
1254                 Content::Unit => visitor.visit_unit(),
1255                 _ => visitor.visit_some(self),
1256             }
1257         }
1258
1259         fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1260         where
1261             V: Visitor<'de>,
1262         {
1263             match self.content {
1264                 Content::Unit => visitor.visit_unit(),
1265
1266                 // Allow deserializing newtype variant containing unit.
1267                 //
1268                 //     #[derive(Deserialize)]
1269                 //     #[serde(tag = "result")]
1270                 //     enum Response<T> {
1271                 //         Success(T),
1272                 //     }
1273                 //
1274                 // We want {"result":"Success"} to deserialize into Response<()>.
1275                 Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
1276                 _ => Err(self.invalid_type(&visitor)),
1277             }
1278         }
1279
1280         fn deserialize_unit_struct<V>(
1281             self,
1282             _name: &'static str,
1283             visitor: V,
1284         ) -> Result<V::Value, Self::Error>
1285         where
1286             V: Visitor<'de>,
1287         {
1288             match self.content {
1289                 // As a special case, allow deserializing untagged newtype
1290                 // variant containing unit struct.
1291                 //
1292                 //     #[derive(Deserialize)]
1293                 //     struct Info;
1294                 //
1295                 //     #[derive(Deserialize)]
1296                 //     #[serde(tag = "topic")]
1297                 //     enum Message {
1298                 //         Info(Info),
1299                 //     }
1300                 //
1301                 // We want {"topic":"Info"} to deserialize even though
1302                 // ordinarily unit structs do not deserialize from empty map/seq.
1303                 Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
1304                 Content::Seq(ref v) if v.is_empty() => visitor.visit_unit(),
1305                 _ => self.deserialize_any(visitor),
1306             }
1307         }
1308
1309         fn deserialize_newtype_struct<V>(
1310             self,
1311             _name: &str,
1312             visitor: V,
1313         ) -> Result<V::Value, Self::Error>
1314         where
1315             V: Visitor<'de>,
1316         {
1317             match self.content {
1318                 Content::Newtype(v) => visitor.visit_newtype_struct(ContentDeserializer::new(*v)),
1319                 _ => visitor.visit_newtype_struct(self),
1320             }
1321         }
1322
1323         fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1324         where
1325             V: Visitor<'de>,
1326         {
1327             match self.content {
1328                 Content::Seq(v) => visit_content_seq(v, visitor),
1329                 _ => Err(self.invalid_type(&visitor)),
1330             }
1331         }
1332
1333         fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1334         where
1335             V: Visitor<'de>,
1336         {
1337             self.deserialize_seq(visitor)
1338         }
1339
1340         fn deserialize_tuple_struct<V>(
1341             self,
1342             _name: &'static str,
1343             _len: usize,
1344             visitor: V,
1345         ) -> Result<V::Value, Self::Error>
1346         where
1347             V: Visitor<'de>,
1348         {
1349             self.deserialize_seq(visitor)
1350         }
1351
1352         fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1353         where
1354             V: Visitor<'de>,
1355         {
1356             match self.content {
1357                 Content::Map(v) => visit_content_map(v, visitor),
1358                 _ => Err(self.invalid_type(&visitor)),
1359             }
1360         }
1361
1362         fn deserialize_struct<V>(
1363             self,
1364             _name: &'static str,
1365             _fields: &'static [&'static str],
1366             visitor: V,
1367         ) -> Result<V::Value, Self::Error>
1368         where
1369             V: Visitor<'de>,
1370         {
1371             match self.content {
1372                 Content::Seq(v) => visit_content_seq(v, visitor),
1373                 Content::Map(v) => visit_content_map(v, visitor),
1374                 _ => Err(self.invalid_type(&visitor)),
1375             }
1376         }
1377
1378         fn deserialize_enum<V>(
1379             self,
1380             _name: &str,
1381             _variants: &'static [&'static str],
1382             visitor: V,
1383         ) -> Result<V::Value, Self::Error>
1384         where
1385             V: Visitor<'de>,
1386         {
1387             let (variant, value) = match self.content {
1388                 Content::Map(value) => {
1389                     let mut iter = value.into_iter();
1390                     let (variant, value) = match iter.next() {
1391                         Some(v) => v,
1392                         None => {
1393                             return Err(de::Error::invalid_value(
1394                                 de::Unexpected::Map,
1395                                 &"map with a single key",
1396                             ));
1397                         }
1398                     };
1399                     // enums are encoded in json as maps with a single key:value pair
1400                     if iter.next().is_some() {
1401                         return Err(de::Error::invalid_value(
1402                             de::Unexpected::Map,
1403                             &"map with a single key",
1404                         ));
1405                     }
1406                     (variant, Some(value))
1407                 }
1408                 s @ Content::String(_) | s @ Content::Str(_) => (s, None),
1409                 other => {
1410                     return Err(de::Error::invalid_type(
1411                         other.unexpected(),
1412                         &"string or map",
1413                     ));
1414                 }
1415             };
1416
1417             visitor.visit_enum(EnumDeserializer::new(variant, value))
1418         }
1419
1420         fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1421         where
1422             V: Visitor<'de>,
1423         {
1424             match self.content {
1425                 Content::String(v) => visitor.visit_string(v),
1426                 Content::Str(v) => visitor.visit_borrowed_str(v),
1427                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
1428                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1429                 Content::U8(v) => visitor.visit_u8(v),
1430                 Content::U64(v) => visitor.visit_u64(v),
1431                 _ => Err(self.invalid_type(&visitor)),
1432             }
1433         }
1434
1435         fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1436         where
1437             V: Visitor<'de>,
1438         {
1439             drop(self);
1440             visitor.visit_unit()
1441         }
1442
1443         fn __deserialize_content<V>(
1444             self,
1445             _: actually_private::T,
1446             visitor: V,
1447         ) -> Result<Content<'de>, Self::Error>
1448         where
1449             V: Visitor<'de, Value = Content<'de>>,
1450         {
1451             let _ = visitor;
1452             Ok(self.content)
1453         }
1454     }
1455
1456     impl<'de, E> ContentDeserializer<'de, E> {
1457         /// private API, don't use
1458         pub fn new(content: Content<'de>) -> Self {
1459             ContentDeserializer {
1460                 content: content,
1461                 err: PhantomData,
1462             }
1463         }
1464     }
1465
1466     pub struct EnumDeserializer<'de, E>
1467     where
1468         E: de::Error,
1469     {
1470         variant: Content<'de>,
1471         value: Option<Content<'de>>,
1472         err: PhantomData<E>,
1473     }
1474
1475     impl<'de, E> EnumDeserializer<'de, E>
1476     where
1477         E: de::Error,
1478     {
1479         pub fn new(variant: Content<'de>, value: Option<Content<'de>>) -> EnumDeserializer<'de, E> {
1480             EnumDeserializer {
1481                 variant: variant,
1482                 value: value,
1483                 err: PhantomData,
1484             }
1485         }
1486     }
1487
1488     impl<'de, E> de::EnumAccess<'de> for EnumDeserializer<'de, E>
1489     where
1490         E: de::Error,
1491     {
1492         type Error = E;
1493         type Variant = VariantDeserializer<'de, Self::Error>;
1494
1495         fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E>
1496         where
1497             V: de::DeserializeSeed<'de>,
1498         {
1499             let visitor = VariantDeserializer {
1500                 value: self.value,
1501                 err: PhantomData,
1502             };
1503             seed.deserialize(ContentDeserializer::new(self.variant))
1504                 .map(|v| (v, visitor))
1505         }
1506     }
1507
1508     pub struct VariantDeserializer<'de, E>
1509     where
1510         E: de::Error,
1511     {
1512         value: Option<Content<'de>>,
1513         err: PhantomData<E>,
1514     }
1515
1516     impl<'de, E> de::VariantAccess<'de> for VariantDeserializer<'de, E>
1517     where
1518         E: de::Error,
1519     {
1520         type Error = E;
1521
1522         fn unit_variant(self) -> Result<(), E> {
1523             match self.value {
1524                 Some(value) => de::Deserialize::deserialize(ContentDeserializer::new(value)),
1525                 None => Ok(()),
1526             }
1527         }
1528
1529         fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E>
1530         where
1531             T: de::DeserializeSeed<'de>,
1532         {
1533             match self.value {
1534                 Some(value) => seed.deserialize(ContentDeserializer::new(value)),
1535                 None => Err(de::Error::invalid_type(
1536                     de::Unexpected::UnitVariant,
1537                     &"newtype variant",
1538                 )),
1539             }
1540         }
1541
1542         fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1543         where
1544             V: de::Visitor<'de>,
1545         {
1546             match self.value {
1547                 Some(Content::Seq(v)) => {
1548                     de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
1549                 }
1550                 Some(other) => Err(de::Error::invalid_type(
1551                     other.unexpected(),
1552                     &"tuple variant",
1553                 )),
1554                 None => Err(de::Error::invalid_type(
1555                     de::Unexpected::UnitVariant,
1556                     &"tuple variant",
1557                 )),
1558             }
1559         }
1560
1561         fn struct_variant<V>(
1562             self,
1563             _fields: &'static [&'static str],
1564             visitor: V,
1565         ) -> Result<V::Value, Self::Error>
1566         where
1567             V: de::Visitor<'de>,
1568         {
1569             match self.value {
1570                 Some(Content::Map(v)) => {
1571                     de::Deserializer::deserialize_any(MapDeserializer::new(v), visitor)
1572                 }
1573                 Some(Content::Seq(v)) => {
1574                     de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
1575                 }
1576                 Some(other) => Err(de::Error::invalid_type(
1577                     other.unexpected(),
1578                     &"struct variant",
1579                 )),
1580                 None => Err(de::Error::invalid_type(
1581                     de::Unexpected::UnitVariant,
1582                     &"struct variant",
1583                 )),
1584             }
1585         }
1586     }
1587
1588     struct SeqDeserializer<'de, E>
1589     where
1590         E: de::Error,
1591     {
1592         iter: <Vec<Content<'de>> as IntoIterator>::IntoIter,
1593         err: PhantomData<E>,
1594     }
1595
1596     impl<'de, E> SeqDeserializer<'de, E>
1597     where
1598         E: de::Error,
1599     {
1600         fn new(vec: Vec<Content<'de>>) -> Self {
1601             SeqDeserializer {
1602                 iter: vec.into_iter(),
1603                 err: PhantomData,
1604             }
1605         }
1606     }
1607
1608     impl<'de, E> de::Deserializer<'de> for SeqDeserializer<'de, E>
1609     where
1610         E: de::Error,
1611     {
1612         type Error = E;
1613
1614         #[inline]
1615         fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
1616         where
1617             V: de::Visitor<'de>,
1618         {
1619             let len = self.iter.len();
1620             if len == 0 {
1621                 visitor.visit_unit()
1622             } else {
1623                 let ret = try!(visitor.visit_seq(&mut self));
1624                 let remaining = self.iter.len();
1625                 if remaining == 0 {
1626                     Ok(ret)
1627                 } else {
1628                     Err(de::Error::invalid_length(len, &"fewer elements in array"))
1629                 }
1630             }
1631         }
1632
1633         forward_to_deserialize_any! {
1634             bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1635             bytes byte_buf option unit unit_struct newtype_struct seq tuple
1636             tuple_struct map struct enum identifier ignored_any
1637         }
1638     }
1639
1640     impl<'de, E> de::SeqAccess<'de> for SeqDeserializer<'de, E>
1641     where
1642         E: de::Error,
1643     {
1644         type Error = E;
1645
1646         fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1647         where
1648             T: de::DeserializeSeed<'de>,
1649         {
1650             match self.iter.next() {
1651                 Some(value) => seed.deserialize(ContentDeserializer::new(value)).map(Some),
1652                 None => Ok(None),
1653             }
1654         }
1655
1656         fn size_hint(&self) -> Option<usize> {
1657             size_hint::from_bounds(&self.iter)
1658         }
1659     }
1660
1661     struct MapDeserializer<'de, E>
1662     where
1663         E: de::Error,
1664     {
1665         iter: <Vec<(Content<'de>, Content<'de>)> as IntoIterator>::IntoIter,
1666         value: Option<Content<'de>>,
1667         err: PhantomData<E>,
1668     }
1669
1670     impl<'de, E> MapDeserializer<'de, E>
1671     where
1672         E: de::Error,
1673     {
1674         fn new(map: Vec<(Content<'de>, Content<'de>)>) -> Self {
1675             MapDeserializer {
1676                 iter: map.into_iter(),
1677                 value: None,
1678                 err: PhantomData,
1679             }
1680         }
1681     }
1682
1683     impl<'de, E> de::MapAccess<'de> for MapDeserializer<'de, E>
1684     where
1685         E: de::Error,
1686     {
1687         type Error = E;
1688
1689         fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1690         where
1691             T: de::DeserializeSeed<'de>,
1692         {
1693             match self.iter.next() {
1694                 Some((key, value)) => {
1695                     self.value = Some(value);
1696                     seed.deserialize(ContentDeserializer::new(key)).map(Some)
1697                 }
1698                 None => Ok(None),
1699             }
1700         }
1701
1702         fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
1703         where
1704             T: de::DeserializeSeed<'de>,
1705         {
1706             match self.value.take() {
1707                 Some(value) => seed.deserialize(ContentDeserializer::new(value)),
1708                 None => Err(de::Error::custom("value is missing")),
1709             }
1710         }
1711
1712         fn size_hint(&self) -> Option<usize> {
1713             size_hint::from_bounds(&self.iter)
1714         }
1715     }
1716
1717     impl<'de, E> de::Deserializer<'de> for MapDeserializer<'de, E>
1718     where
1719         E: de::Error,
1720     {
1721         type Error = E;
1722
1723         #[inline]
1724         fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1725         where
1726             V: de::Visitor<'de>,
1727         {
1728             visitor.visit_map(self)
1729         }
1730
1731         forward_to_deserialize_any! {
1732             bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1733             bytes byte_buf option unit unit_struct newtype_struct seq tuple
1734             tuple_struct map struct enum identifier ignored_any
1735         }
1736     }
1737
1738     /// Not public API.
1739     pub struct ContentRefDeserializer<'a, 'de: 'a, E> {
1740         content: &'a Content<'de>,
1741         err: PhantomData<E>,
1742     }
1743
1744     impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E>
1745     where
1746         E: de::Error,
1747     {
1748         #[cold]
1749         fn invalid_type(self, exp: &Expected) -> E {
1750             de::Error::invalid_type(self.content.unexpected(), exp)
1751         }
1752
1753         fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E>
1754         where
1755             V: Visitor<'de>,
1756         {
1757             match *self.content {
1758                 Content::U8(v) => visitor.visit_u8(v),
1759                 Content::U16(v) => visitor.visit_u16(v),
1760                 Content::U32(v) => visitor.visit_u32(v),
1761                 Content::U64(v) => visitor.visit_u64(v),
1762                 Content::I8(v) => visitor.visit_i8(v),
1763                 Content::I16(v) => visitor.visit_i16(v),
1764                 Content::I32(v) => visitor.visit_i32(v),
1765                 Content::I64(v) => visitor.visit_i64(v),
1766                 _ => Err(self.invalid_type(&visitor)),
1767             }
1768         }
1769
1770         fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
1771         where
1772             V: Visitor<'de>,
1773         {
1774             match *self.content {
1775                 Content::F32(v) => visitor.visit_f32(v),
1776                 Content::F64(v) => visitor.visit_f64(v),
1777                 Content::U8(v) => visitor.visit_u8(v),
1778                 Content::U16(v) => visitor.visit_u16(v),
1779                 Content::U32(v) => visitor.visit_u32(v),
1780                 Content::U64(v) => visitor.visit_u64(v),
1781                 Content::I8(v) => visitor.visit_i8(v),
1782                 Content::I16(v) => visitor.visit_i16(v),
1783                 Content::I32(v) => visitor.visit_i32(v),
1784                 Content::I64(v) => visitor.visit_i64(v),
1785                 _ => Err(self.invalid_type(&visitor)),
1786             }
1787         }
1788     }
1789
1790     fn visit_content_seq_ref<'a, 'de, V, E>(
1791         content: &'a [Content<'de>],
1792         visitor: V,
1793     ) -> Result<V::Value, E>
1794     where
1795         V: Visitor<'de>,
1796         E: de::Error,
1797     {
1798         let seq = content.iter().map(ContentRefDeserializer::new);
1799         let mut seq_visitor = de::value::SeqDeserializer::new(seq);
1800         let value = try!(visitor.visit_seq(&mut seq_visitor));
1801         try!(seq_visitor.end());
1802         Ok(value)
1803     }
1804
1805     fn visit_content_map_ref<'a, 'de, V, E>(
1806         content: &'a [(Content<'de>, Content<'de>)],
1807         visitor: V,
1808     ) -> Result<V::Value, E>
1809     where
1810         V: Visitor<'de>,
1811         E: de::Error,
1812     {
1813         let map = content.iter().map(|(k, v)| {
1814             (
1815                 ContentRefDeserializer::new(k),
1816                 ContentRefDeserializer::new(v),
1817             )
1818         });
1819         let mut map_visitor = de::value::MapDeserializer::new(map);
1820         let value = try!(visitor.visit_map(&mut map_visitor));
1821         try!(map_visitor.end());
1822         Ok(value)
1823     }
1824
1825     /// Used when deserializing an untagged enum because the content may need
1826     /// to be used more than once.
1827     impl<'de, 'a, E> Deserializer<'de> for ContentRefDeserializer<'a, 'de, E>
1828     where
1829         E: de::Error,
1830     {
1831         type Error = E;
1832
1833         fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, E>
1834         where
1835             V: Visitor<'de>,
1836         {
1837             match *self.content {
1838                 Content::Bool(v) => visitor.visit_bool(v),
1839                 Content::U8(v) => visitor.visit_u8(v),
1840                 Content::U16(v) => visitor.visit_u16(v),
1841                 Content::U32(v) => visitor.visit_u32(v),
1842                 Content::U64(v) => visitor.visit_u64(v),
1843                 Content::I8(v) => visitor.visit_i8(v),
1844                 Content::I16(v) => visitor.visit_i16(v),
1845                 Content::I32(v) => visitor.visit_i32(v),
1846                 Content::I64(v) => visitor.visit_i64(v),
1847                 Content::F32(v) => visitor.visit_f32(v),
1848                 Content::F64(v) => visitor.visit_f64(v),
1849                 Content::Char(v) => visitor.visit_char(v),
1850                 Content::String(ref v) => visitor.visit_str(v),
1851                 Content::Str(v) => visitor.visit_borrowed_str(v),
1852                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
1853                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1854                 Content::Unit => visitor.visit_unit(),
1855                 Content::None => visitor.visit_none(),
1856                 Content::Some(ref v) => visitor.visit_some(ContentRefDeserializer::new(v)),
1857                 Content::Newtype(ref v) => {
1858                     visitor.visit_newtype_struct(ContentRefDeserializer::new(v))
1859                 }
1860                 Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
1861                 Content::Map(ref v) => visit_content_map_ref(v, visitor),
1862             }
1863         }
1864
1865         fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1866         where
1867             V: Visitor<'de>,
1868         {
1869             match *self.content {
1870                 Content::Bool(v) => visitor.visit_bool(v),
1871                 _ => Err(self.invalid_type(&visitor)),
1872             }
1873         }
1874
1875         fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1876         where
1877             V: Visitor<'de>,
1878         {
1879             self.deserialize_integer(visitor)
1880         }
1881
1882         fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1883         where
1884             V: Visitor<'de>,
1885         {
1886             self.deserialize_integer(visitor)
1887         }
1888
1889         fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1890         where
1891             V: Visitor<'de>,
1892         {
1893             self.deserialize_integer(visitor)
1894         }
1895
1896         fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1897         where
1898             V: Visitor<'de>,
1899         {
1900             self.deserialize_integer(visitor)
1901         }
1902
1903         fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1904         where
1905             V: Visitor<'de>,
1906         {
1907             self.deserialize_integer(visitor)
1908         }
1909
1910         fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1911         where
1912             V: Visitor<'de>,
1913         {
1914             self.deserialize_integer(visitor)
1915         }
1916
1917         fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1918         where
1919             V: Visitor<'de>,
1920         {
1921             self.deserialize_integer(visitor)
1922         }
1923
1924         fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1925         where
1926             V: Visitor<'de>,
1927         {
1928             self.deserialize_integer(visitor)
1929         }
1930
1931         fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1932         where
1933             V: Visitor<'de>,
1934         {
1935             self.deserialize_float(visitor)
1936         }
1937
1938         fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1939         where
1940             V: Visitor<'de>,
1941         {
1942             self.deserialize_float(visitor)
1943         }
1944
1945         fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1946         where
1947             V: Visitor<'de>,
1948         {
1949             match *self.content {
1950                 Content::Char(v) => visitor.visit_char(v),
1951                 Content::String(ref v) => visitor.visit_str(v),
1952                 Content::Str(v) => visitor.visit_borrowed_str(v),
1953                 _ => Err(self.invalid_type(&visitor)),
1954             }
1955         }
1956
1957         fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1958         where
1959             V: Visitor<'de>,
1960         {
1961             match *self.content {
1962                 Content::String(ref v) => visitor.visit_str(v),
1963                 Content::Str(v) => visitor.visit_borrowed_str(v),
1964                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
1965                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1966                 _ => Err(self.invalid_type(&visitor)),
1967             }
1968         }
1969
1970         fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1971         where
1972             V: Visitor<'de>,
1973         {
1974             self.deserialize_str(visitor)
1975         }
1976
1977         fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1978         where
1979             V: Visitor<'de>,
1980         {
1981             match *self.content {
1982                 Content::String(ref v) => visitor.visit_str(v),
1983                 Content::Str(v) => visitor.visit_borrowed_str(v),
1984                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
1985                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
1986                 Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
1987                 _ => Err(self.invalid_type(&visitor)),
1988             }
1989         }
1990
1991         fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1992         where
1993             V: Visitor<'de>,
1994         {
1995             self.deserialize_bytes(visitor)
1996         }
1997
1998         fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
1999         where
2000             V: Visitor<'de>,
2001         {
2002             match *self.content {
2003                 Content::None => visitor.visit_none(),
2004                 Content::Some(ref v) => visitor.visit_some(ContentRefDeserializer::new(v)),
2005                 Content::Unit => visitor.visit_unit(),
2006                 _ => visitor.visit_some(self),
2007             }
2008         }
2009
2010         fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2011         where
2012             V: Visitor<'de>,
2013         {
2014             match *self.content {
2015                 Content::Unit => visitor.visit_unit(),
2016                 _ => Err(self.invalid_type(&visitor)),
2017             }
2018         }
2019
2020         fn deserialize_unit_struct<V>(
2021             self,
2022             _name: &'static str,
2023             visitor: V,
2024         ) -> Result<V::Value, Self::Error>
2025         where
2026             V: Visitor<'de>,
2027         {
2028             self.deserialize_unit(visitor)
2029         }
2030
2031         fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, E>
2032         where
2033             V: Visitor<'de>,
2034         {
2035             match *self.content {
2036                 Content::Newtype(ref v) => {
2037                     visitor.visit_newtype_struct(ContentRefDeserializer::new(v))
2038                 }
2039                 _ => visitor.visit_newtype_struct(self),
2040             }
2041         }
2042
2043         fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2044         where
2045             V: Visitor<'de>,
2046         {
2047             match *self.content {
2048                 Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
2049                 _ => Err(self.invalid_type(&visitor)),
2050             }
2051         }
2052
2053         fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
2054         where
2055             V: Visitor<'de>,
2056         {
2057             self.deserialize_seq(visitor)
2058         }
2059
2060         fn deserialize_tuple_struct<V>(
2061             self,
2062             _name: &'static str,
2063             _len: usize,
2064             visitor: V,
2065         ) -> Result<V::Value, Self::Error>
2066         where
2067             V: Visitor<'de>,
2068         {
2069             self.deserialize_seq(visitor)
2070         }
2071
2072         fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2073         where
2074             V: Visitor<'de>,
2075         {
2076             match *self.content {
2077                 Content::Map(ref v) => visit_content_map_ref(v, visitor),
2078                 _ => Err(self.invalid_type(&visitor)),
2079             }
2080         }
2081
2082         fn deserialize_struct<V>(
2083             self,
2084             _name: &'static str,
2085             _fields: &'static [&'static str],
2086             visitor: V,
2087         ) -> Result<V::Value, Self::Error>
2088         where
2089             V: Visitor<'de>,
2090         {
2091             match *self.content {
2092                 Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
2093                 Content::Map(ref v) => visit_content_map_ref(v, visitor),
2094                 _ => Err(self.invalid_type(&visitor)),
2095             }
2096         }
2097
2098         fn deserialize_enum<V>(
2099             self,
2100             _name: &str,
2101             _variants: &'static [&'static str],
2102             visitor: V,
2103         ) -> Result<V::Value, Self::Error>
2104         where
2105             V: Visitor<'de>,
2106         {
2107             let (variant, value) = match *self.content {
2108                 Content::Map(ref value) => {
2109                     let mut iter = value.iter();
2110                     let (variant, value) = match iter.next() {
2111                         Some(v) => v,
2112                         None => {
2113                             return Err(de::Error::invalid_value(
2114                                 de::Unexpected::Map,
2115                                 &"map with a single key",
2116                             ));
2117                         }
2118                     };
2119                     // enums are encoded in json as maps with a single key:value pair
2120                     if iter.next().is_some() {
2121                         return Err(de::Error::invalid_value(
2122                             de::Unexpected::Map,
2123                             &"map with a single key",
2124                         ));
2125                     }
2126                     (variant, Some(value))
2127                 }
2128                 ref s @ Content::String(_) | ref s @ Content::Str(_) => (s, None),
2129                 ref other => {
2130                     return Err(de::Error::invalid_type(
2131                         other.unexpected(),
2132                         &"string or map",
2133                     ));
2134                 }
2135             };
2136
2137             visitor.visit_enum(EnumRefDeserializer {
2138                 variant: variant,
2139                 value: value,
2140                 err: PhantomData,
2141             })
2142         }
2143
2144         fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2145         where
2146             V: Visitor<'de>,
2147         {
2148             match *self.content {
2149                 Content::String(ref v) => visitor.visit_str(v),
2150                 Content::Str(v) => visitor.visit_borrowed_str(v),
2151                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
2152                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
2153                 Content::U8(v) => visitor.visit_u8(v),
2154                 Content::U64(v) => visitor.visit_u64(v),
2155                 _ => Err(self.invalid_type(&visitor)),
2156             }
2157         }
2158
2159         fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2160         where
2161             V: Visitor<'de>,
2162         {
2163             visitor.visit_unit()
2164         }
2165
2166         fn __deserialize_content<V>(
2167             self,
2168             _: actually_private::T,
2169             visitor: V,
2170         ) -> Result<Content<'de>, Self::Error>
2171         where
2172             V: Visitor<'de, Value = Content<'de>>,
2173         {
2174             let _ = visitor;
2175             Ok(self.content.clone())
2176         }
2177     }
2178
2179     impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E> {
2180         /// private API, don't use
2181         pub fn new(content: &'a Content<'de>) -> Self {
2182             ContentRefDeserializer {
2183                 content: content,
2184                 err: PhantomData,
2185             }
2186         }
2187     }
2188
2189     struct EnumRefDeserializer<'a, 'de: 'a, E>
2190     where
2191         E: de::Error,
2192     {
2193         variant: &'a Content<'de>,
2194         value: Option<&'a Content<'de>>,
2195         err: PhantomData<E>,
2196     }
2197
2198     impl<'de, 'a, E> de::EnumAccess<'de> for EnumRefDeserializer<'a, 'de, E>
2199     where
2200         E: de::Error,
2201     {
2202         type Error = E;
2203         type Variant = VariantRefDeserializer<'a, 'de, Self::Error>;
2204
2205         fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
2206         where
2207             V: de::DeserializeSeed<'de>,
2208         {
2209             let visitor = VariantRefDeserializer {
2210                 value: self.value,
2211                 err: PhantomData,
2212             };
2213             seed.deserialize(ContentRefDeserializer::new(self.variant))
2214                 .map(|v| (v, visitor))
2215         }
2216     }
2217
2218     struct VariantRefDeserializer<'a, 'de: 'a, E>
2219     where
2220         E: de::Error,
2221     {
2222         value: Option<&'a Content<'de>>,
2223         err: PhantomData<E>,
2224     }
2225
2226     impl<'de, 'a, E> de::VariantAccess<'de> for VariantRefDeserializer<'a, 'de, E>
2227     where
2228         E: de::Error,
2229     {
2230         type Error = E;
2231
2232         fn unit_variant(self) -> Result<(), E> {
2233             match self.value {
2234                 Some(value) => de::Deserialize::deserialize(ContentRefDeserializer::new(value)),
2235                 None => Ok(()),
2236             }
2237         }
2238
2239         fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E>
2240         where
2241             T: de::DeserializeSeed<'de>,
2242         {
2243             match self.value {
2244                 Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
2245                 None => Err(de::Error::invalid_type(
2246                     de::Unexpected::UnitVariant,
2247                     &"newtype variant",
2248                 )),
2249             }
2250         }
2251
2252         fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
2253         where
2254             V: de::Visitor<'de>,
2255         {
2256             match self.value {
2257                 Some(Content::Seq(v)) => {
2258                     de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
2259                 }
2260                 Some(other) => Err(de::Error::invalid_type(
2261                     other.unexpected(),
2262                     &"tuple variant",
2263                 )),
2264                 None => Err(de::Error::invalid_type(
2265                     de::Unexpected::UnitVariant,
2266                     &"tuple variant",
2267                 )),
2268             }
2269         }
2270
2271         fn struct_variant<V>(
2272             self,
2273             _fields: &'static [&'static str],
2274             visitor: V,
2275         ) -> Result<V::Value, Self::Error>
2276         where
2277             V: de::Visitor<'de>,
2278         {
2279             match self.value {
2280                 Some(Content::Map(v)) => {
2281                     de::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
2282                 }
2283                 Some(Content::Seq(v)) => {
2284                     de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
2285                 }
2286                 Some(other) => Err(de::Error::invalid_type(
2287                     other.unexpected(),
2288                     &"struct variant",
2289                 )),
2290                 None => Err(de::Error::invalid_type(
2291                     de::Unexpected::UnitVariant,
2292                     &"struct variant",
2293                 )),
2294             }
2295         }
2296     }
2297
2298     struct SeqRefDeserializer<'a, 'de: 'a, E>
2299     where
2300         E: de::Error,
2301     {
2302         iter: <&'a [Content<'de>] as IntoIterator>::IntoIter,
2303         err: PhantomData<E>,
2304     }
2305
2306     impl<'a, 'de, E> SeqRefDeserializer<'a, 'de, E>
2307     where
2308         E: de::Error,
2309     {
2310         fn new(slice: &'a [Content<'de>]) -> Self {
2311             SeqRefDeserializer {
2312                 iter: slice.iter(),
2313                 err: PhantomData,
2314             }
2315         }
2316     }
2317
2318     impl<'de, 'a, E> de::Deserializer<'de> for SeqRefDeserializer<'a, 'de, E>
2319     where
2320         E: de::Error,
2321     {
2322         type Error = E;
2323
2324         #[inline]
2325         fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
2326         where
2327             V: de::Visitor<'de>,
2328         {
2329             let len = self.iter.len();
2330             if len == 0 {
2331                 visitor.visit_unit()
2332             } else {
2333                 let ret = try!(visitor.visit_seq(&mut self));
2334                 let remaining = self.iter.len();
2335                 if remaining == 0 {
2336                     Ok(ret)
2337                 } else {
2338                     Err(de::Error::invalid_length(len, &"fewer elements in array"))
2339                 }
2340             }
2341         }
2342
2343         forward_to_deserialize_any! {
2344             bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
2345             bytes byte_buf option unit unit_struct newtype_struct seq tuple
2346             tuple_struct map struct enum identifier ignored_any
2347         }
2348     }
2349
2350     impl<'de, 'a, E> de::SeqAccess<'de> for SeqRefDeserializer<'a, 'de, E>
2351     where
2352         E: de::Error,
2353     {
2354         type Error = E;
2355
2356         fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
2357         where
2358             T: de::DeserializeSeed<'de>,
2359         {
2360             match self.iter.next() {
2361                 Some(value) => seed
2362                     .deserialize(ContentRefDeserializer::new(value))
2363                     .map(Some),
2364                 None => Ok(None),
2365             }
2366         }
2367
2368         fn size_hint(&self) -> Option<usize> {
2369             size_hint::from_bounds(&self.iter)
2370         }
2371     }
2372
2373     struct MapRefDeserializer<'a, 'de: 'a, E>
2374     where
2375         E: de::Error,
2376     {
2377         iter: <&'a [(Content<'de>, Content<'de>)] as IntoIterator>::IntoIter,
2378         value: Option<&'a Content<'de>>,
2379         err: PhantomData<E>,
2380     }
2381
2382     impl<'a, 'de, E> MapRefDeserializer<'a, 'de, E>
2383     where
2384         E: de::Error,
2385     {
2386         fn new(map: &'a [(Content<'de>, Content<'de>)]) -> Self {
2387             MapRefDeserializer {
2388                 iter: map.iter(),
2389                 value: None,
2390                 err: PhantomData,
2391             }
2392         }
2393     }
2394
2395     impl<'de, 'a, E> de::MapAccess<'de> for MapRefDeserializer<'a, 'de, E>
2396     where
2397         E: de::Error,
2398     {
2399         type Error = E;
2400
2401         fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
2402         where
2403             T: de::DeserializeSeed<'de>,
2404         {
2405             match self.iter.next() {
2406                 Some((key, value)) => {
2407                     self.value = Some(value);
2408                     seed.deserialize(ContentRefDeserializer::new(key)).map(Some)
2409                 }
2410                 None => Ok(None),
2411             }
2412         }
2413
2414         fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
2415         where
2416             T: de::DeserializeSeed<'de>,
2417         {
2418             match self.value.take() {
2419                 Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
2420                 None => Err(de::Error::custom("value is missing")),
2421             }
2422         }
2423
2424         fn size_hint(&self) -> Option<usize> {
2425             size_hint::from_bounds(&self.iter)
2426         }
2427     }
2428
2429     impl<'de, 'a, E> de::Deserializer<'de> for MapRefDeserializer<'a, 'de, E>
2430     where
2431         E: de::Error,
2432     {
2433         type Error = E;
2434
2435         #[inline]
2436         fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2437         where
2438             V: de::Visitor<'de>,
2439         {
2440             visitor.visit_map(self)
2441         }
2442
2443         forward_to_deserialize_any! {
2444             bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
2445             bytes byte_buf option unit unit_struct newtype_struct seq tuple
2446             tuple_struct map struct enum identifier ignored_any
2447         }
2448     }
2449
2450     impl<'de, E> de::IntoDeserializer<'de, E> for ContentDeserializer<'de, E>
2451     where
2452         E: de::Error,
2453     {
2454         type Deserializer = Self;
2455
2456         fn into_deserializer(self) -> Self {
2457             self
2458         }
2459     }
2460
2461     impl<'de, 'a, E> de::IntoDeserializer<'de, E> for ContentRefDeserializer<'a, 'de, E>
2462     where
2463         E: de::Error,
2464     {
2465         type Deserializer = Self;
2466
2467         fn into_deserializer(self) -> Self {
2468             self
2469         }
2470     }
2471
2472     /// Visitor for deserializing an internally tagged unit variant.
2473     ///
2474     /// Not public API.
2475     pub struct InternallyTaggedUnitVisitor<'a> {
2476         type_name: &'a str,
2477         variant_name: &'a str,
2478     }
2479
2480     impl<'a> InternallyTaggedUnitVisitor<'a> {
2481         /// Not public API.
2482         pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
2483             InternallyTaggedUnitVisitor {
2484                 type_name: type_name,
2485                 variant_name: variant_name,
2486             }
2487         }
2488     }
2489
2490     impl<'de, 'a> Visitor<'de> for InternallyTaggedUnitVisitor<'a> {
2491         type Value = ();
2492
2493         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2494             write!(
2495                 formatter,
2496                 "unit variant {}::{}",
2497                 self.type_name, self.variant_name
2498             )
2499         }
2500
2501         fn visit_seq<S>(self, _: S) -> Result<(), S::Error>
2502         where
2503             S: SeqAccess<'de>,
2504         {
2505             Ok(())
2506         }
2507
2508         fn visit_map<M>(self, mut access: M) -> Result<(), M::Error>
2509         where
2510             M: MapAccess<'de>,
2511         {
2512             while try!(access.next_entry::<IgnoredAny, IgnoredAny>()).is_some() {}
2513             Ok(())
2514         }
2515     }
2516
2517     /// Visitor for deserializing an untagged unit variant.
2518     ///
2519     /// Not public API.
2520     pub struct UntaggedUnitVisitor<'a> {
2521         type_name: &'a str,
2522         variant_name: &'a str,
2523     }
2524
2525     impl<'a> UntaggedUnitVisitor<'a> {
2526         /// Not public API.
2527         pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
2528             UntaggedUnitVisitor {
2529                 type_name: type_name,
2530                 variant_name: variant_name,
2531             }
2532         }
2533     }
2534
2535     impl<'de, 'a> Visitor<'de> for UntaggedUnitVisitor<'a> {
2536         type Value = ();
2537
2538         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2539             write!(
2540                 formatter,
2541                 "unit variant {}::{}",
2542                 self.type_name, self.variant_name
2543             )
2544         }
2545
2546         fn visit_unit<E>(self) -> Result<(), E>
2547         where
2548             E: de::Error,
2549         {
2550             Ok(())
2551         }
2552
2553         fn visit_none<E>(self) -> Result<(), E>
2554         where
2555             E: de::Error,
2556         {
2557             Ok(())
2558         }
2559     }
2560 }
2561
2562 ////////////////////////////////////////////////////////////////////////////////
2563
2564 // Like `IntoDeserializer` but also implemented for `&[u8]`. This is used for
2565 // the newtype fallthrough case of `field_identifier`.
2566 //
2567 //    #[derive(Deserialize)]
2568 //    #[serde(field_identifier)]
2569 //    enum F {
2570 //        A,
2571 //        B,
2572 //        Other(String), // deserialized using IdentifierDeserializer
2573 //    }
2574 pub trait IdentifierDeserializer<'de, E: Error> {
2575     type Deserializer: Deserializer<'de, Error = E>;
2576
2577     fn from(self) -> Self::Deserializer;
2578 }
2579
2580 pub struct Borrowed<'de, T: 'de + ?Sized>(pub &'de T);
2581
2582 impl<'de, E> IdentifierDeserializer<'de, E> for u64
2583 where
2584     E: Error,
2585 {
2586     type Deserializer = <u64 as IntoDeserializer<'de, E>>::Deserializer;
2587
2588     fn from(self) -> Self::Deserializer {
2589         self.into_deserializer()
2590     }
2591 }
2592
2593 pub struct StrDeserializer<'a, E> {
2594     value: &'a str,
2595     marker: PhantomData<E>,
2596 }
2597
2598 impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E>
2599 where
2600     E: Error,
2601 {
2602     type Error = E;
2603
2604     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2605     where
2606         V: Visitor<'de>,
2607     {
2608         visitor.visit_str(self.value)
2609     }
2610
2611     forward_to_deserialize_any! {
2612         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
2613         bytes byte_buf option unit unit_struct newtype_struct seq tuple
2614         tuple_struct map struct enum identifier ignored_any
2615     }
2616 }
2617
2618 pub struct BorrowedStrDeserializer<'de, E> {
2619     value: &'de str,
2620     marker: PhantomData<E>,
2621 }
2622
2623 impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E>
2624 where
2625     E: Error,
2626 {
2627     type Error = E;
2628
2629     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2630     where
2631         V: Visitor<'de>,
2632     {
2633         visitor.visit_borrowed_str(self.value)
2634     }
2635
2636     forward_to_deserialize_any! {
2637         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
2638         bytes byte_buf option unit unit_struct newtype_struct seq tuple
2639         tuple_struct map struct enum identifier ignored_any
2640     }
2641 }
2642
2643 impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
2644 where
2645     E: Error,
2646 {
2647     type Deserializer = StrDeserializer<'a, E>;
2648
2649     fn from(self) -> Self::Deserializer {
2650         StrDeserializer {
2651             value: self,
2652             marker: PhantomData,
2653         }
2654     }
2655 }
2656
2657 impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, str>
2658 where
2659     E: Error,
2660 {
2661     type Deserializer = BorrowedStrDeserializer<'de, E>;
2662
2663     fn from(self) -> Self::Deserializer {
2664         BorrowedStrDeserializer {
2665             value: self.0,
2666             marker: PhantomData,
2667         }
2668     }
2669 }
2670
2671 impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
2672 where
2673     E: Error,
2674 {
2675     type Deserializer = BytesDeserializer<'a, E>;
2676
2677     fn from(self) -> Self::Deserializer {
2678         BytesDeserializer::new(self)
2679     }
2680 }
2681
2682 impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, [u8]>
2683 where
2684     E: Error,
2685 {
2686     type Deserializer = BorrowedBytesDeserializer<'de, E>;
2687
2688     fn from(self) -> Self::Deserializer {
2689         BorrowedBytesDeserializer::new(self.0)
2690     }
2691 }
2692
2693 #[cfg(any(feature = "std", feature = "alloc"))]
2694 pub struct FlatMapDeserializer<'a, 'de: 'a, E>(
2695     pub &'a mut Vec<Option<(Content<'de>, Content<'de>)>>,
2696     pub PhantomData<E>,
2697 );
2698
2699 #[cfg(any(feature = "std", feature = "alloc"))]
2700 impl<'a, 'de, E> FlatMapDeserializer<'a, 'de, E>
2701 where
2702     E: Error,
2703 {
2704     fn deserialize_other<V>() -> Result<V, E> {
2705         Err(Error::custom("can only flatten structs and maps"))
2706     }
2707 }
2708
2709 #[cfg(any(feature = "std", feature = "alloc"))]
2710 macro_rules! forward_to_deserialize_other {
2711     ($($func:ident ($($arg:ty),*))*) => {
2712         $(
2713             fn $func<V>(self, $(_: $arg,)* _visitor: V) -> Result<V::Value, Self::Error>
2714             where
2715                 V: Visitor<'de>,
2716             {
2717                 Self::deserialize_other()
2718             }
2719         )*
2720     }
2721 }
2722
2723 #[cfg(any(feature = "std", feature = "alloc"))]
2724 impl<'a, 'de, E> Deserializer<'de> for FlatMapDeserializer<'a, 'de, E>
2725 where
2726     E: Error,
2727 {
2728     type Error = E;
2729
2730     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2731     where
2732         V: Visitor<'de>,
2733     {
2734         visitor.visit_map(FlatInternallyTaggedAccess {
2735             iter: self.0.iter_mut(),
2736             pending: None,
2737             _marker: PhantomData,
2738         })
2739     }
2740
2741     fn deserialize_enum<V>(
2742         self,
2743         name: &'static str,
2744         variants: &'static [&'static str],
2745         visitor: V,
2746     ) -> Result<V::Value, Self::Error>
2747     where
2748         V: Visitor<'de>,
2749     {
2750         for item in self.0.iter_mut() {
2751             // items in the vector are nulled out when used.  So we can only use
2752             // an item if it's still filled in and if the field is one we care
2753             // about.
2754             let use_item = match *item {
2755                 None => false,
2756                 Some((ref c, _)) => c.as_str().map_or(false, |x| variants.contains(&x)),
2757             };
2758
2759             if use_item {
2760                 let (key, value) = item.take().unwrap();
2761                 return visitor.visit_enum(EnumDeserializer::new(key, Some(value)));
2762             }
2763         }
2764
2765         Err(Error::custom(format_args!(
2766             "no variant of enum {} found in flattened data",
2767             name
2768         )))
2769     }
2770
2771     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2772     where
2773         V: Visitor<'de>,
2774     {
2775         visitor.visit_map(FlatMapAccess::new(self.0.iter()))
2776     }
2777
2778     fn deserialize_struct<V>(
2779         self,
2780         _: &'static str,
2781         fields: &'static [&'static str],
2782         visitor: V,
2783     ) -> Result<V::Value, Self::Error>
2784     where
2785         V: Visitor<'de>,
2786     {
2787         visitor.visit_map(FlatStructAccess::new(self.0.iter_mut(), fields))
2788     }
2789
2790     fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
2791     where
2792         V: Visitor<'de>,
2793     {
2794         visitor.visit_newtype_struct(self)
2795     }
2796
2797     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2798     where
2799         V: Visitor<'de>,
2800     {
2801         match visitor.__private_visit_untagged_option(self) {
2802             Ok(value) => Ok(value),
2803             Err(()) => Self::deserialize_other(),
2804         }
2805     }
2806
2807     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
2808     where
2809         V: Visitor<'de>,
2810     {
2811         visitor.visit_unit()
2812     }
2813
2814     forward_to_deserialize_other! {
2815         deserialize_bool()
2816         deserialize_i8()
2817         deserialize_i16()
2818         deserialize_i32()
2819         deserialize_i64()
2820         deserialize_u8()
2821         deserialize_u16()
2822         deserialize_u32()
2823         deserialize_u64()
2824         deserialize_f32()
2825         deserialize_f64()
2826         deserialize_char()
2827         deserialize_str()
2828         deserialize_string()
2829         deserialize_bytes()
2830         deserialize_byte_buf()
2831         deserialize_unit_struct(&'static str)
2832         deserialize_seq()
2833         deserialize_tuple(usize)
2834         deserialize_tuple_struct(&'static str, usize)
2835         deserialize_identifier()
2836         deserialize_ignored_any()
2837     }
2838 }
2839
2840 #[cfg(any(feature = "std", feature = "alloc"))]
2841 pub struct FlatMapAccess<'a, 'de: 'a, E> {
2842     iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
2843     pending_content: Option<&'a Content<'de>>,
2844     _marker: PhantomData<E>,
2845 }
2846
2847 #[cfg(any(feature = "std", feature = "alloc"))]
2848 impl<'a, 'de, E> FlatMapAccess<'a, 'de, E> {
2849     fn new(
2850         iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
2851     ) -> FlatMapAccess<'a, 'de, E> {
2852         FlatMapAccess {
2853             iter: iter,
2854             pending_content: None,
2855             _marker: PhantomData,
2856         }
2857     }
2858 }
2859
2860 #[cfg(any(feature = "std", feature = "alloc"))]
2861 impl<'a, 'de, E> MapAccess<'de> for FlatMapAccess<'a, 'de, E>
2862 where
2863     E: Error,
2864 {
2865     type Error = E;
2866
2867     fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
2868     where
2869         T: DeserializeSeed<'de>,
2870     {
2871         for item in &mut self.iter {
2872             // Items in the vector are nulled out when used by a struct.
2873             if let Some((ref key, ref content)) = *item {
2874                 self.pending_content = Some(content);
2875                 return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
2876             }
2877         }
2878         Ok(None)
2879     }
2880
2881     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
2882     where
2883         T: DeserializeSeed<'de>,
2884     {
2885         match self.pending_content.take() {
2886             Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
2887             None => Err(Error::custom("value is missing")),
2888         }
2889     }
2890 }
2891
2892 #[cfg(any(feature = "std", feature = "alloc"))]
2893 pub struct FlatStructAccess<'a, 'de: 'a, E> {
2894     iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
2895     pending_content: Option<Content<'de>>,
2896     fields: &'static [&'static str],
2897     _marker: PhantomData<E>,
2898 }
2899
2900 #[cfg(any(feature = "std", feature = "alloc"))]
2901 impl<'a, 'de, E> FlatStructAccess<'a, 'de, E> {
2902     fn new(
2903         iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
2904         fields: &'static [&'static str],
2905     ) -> FlatStructAccess<'a, 'de, E> {
2906         FlatStructAccess {
2907             iter: iter,
2908             pending_content: None,
2909             fields: fields,
2910             _marker: PhantomData,
2911         }
2912     }
2913 }
2914
2915 #[cfg(any(feature = "std", feature = "alloc"))]
2916 impl<'a, 'de, E> MapAccess<'de> for FlatStructAccess<'a, 'de, E>
2917 where
2918     E: Error,
2919 {
2920     type Error = E;
2921
2922     fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
2923     where
2924         T: DeserializeSeed<'de>,
2925     {
2926         while let Some(item) = self.iter.next() {
2927             // items in the vector are nulled out when used.  So we can only use
2928             // an item if it's still filled in and if the field is one we care
2929             // about.  In case we do not know which fields we want, we take them all.
2930             let use_item = match *item {
2931                 None => false,
2932                 Some((ref c, _)) => c.as_str().map_or(false, |key| self.fields.contains(&key)),
2933             };
2934
2935             if use_item {
2936                 let (key, content) = item.take().unwrap();
2937                 self.pending_content = Some(content);
2938                 return seed.deserialize(ContentDeserializer::new(key)).map(Some);
2939             }
2940         }
2941         Ok(None)
2942     }
2943
2944     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
2945     where
2946         T: DeserializeSeed<'de>,
2947     {
2948         match self.pending_content.take() {
2949             Some(value) => seed.deserialize(ContentDeserializer::new(value)),
2950             None => Err(Error::custom("value is missing")),
2951         }
2952     }
2953 }
2954
2955 #[cfg(any(feature = "std", feature = "alloc"))]
2956 pub struct FlatInternallyTaggedAccess<'a, 'de: 'a, E> {
2957     iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
2958     pending: Option<&'a Content<'de>>,
2959     _marker: PhantomData<E>,
2960 }
2961
2962 #[cfg(any(feature = "std", feature = "alloc"))]
2963 impl<'a, 'de, E> MapAccess<'de> for FlatInternallyTaggedAccess<'a, 'de, E>
2964 where
2965     E: Error,
2966 {
2967     type Error = E;
2968
2969     fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
2970     where
2971         T: DeserializeSeed<'de>,
2972     {
2973         for item in &mut self.iter {
2974             if let Some((ref key, ref content)) = *item {
2975                 // Do not take(), instead borrow this entry. The internally tagged
2976                 // enum does its own buffering so we can't tell whether this entry
2977                 // is going to be consumed. Borrowing here leaves the entry
2978                 // available for later flattened fields.
2979                 self.pending = Some(content);
2980                 return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
2981             }
2982         }
2983         Ok(None)
2984     }
2985
2986     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
2987     where
2988         T: DeserializeSeed<'de>,
2989     {
2990         match self.pending.take() {
2991             Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
2992             None => panic!("value is missing"),
2993         }
2994     }
2995 }