src/vendor/serde_json/src/value/de.rs

   1 // Copyright 2017 Serde Developers
   2 //
   3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   6 // option. This file may not be copied, modified, or distributed
   7 // except according to those terms.
   8
   9 use std::borrow::Cow;
  10 use std::fmt;
  11 use std::i64;
  12 use std::io;
  13 use std::slice;
  14 use std::str;
  15 use std::vec;
  16
  17 use serde;
  18 use serde::de::{Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess,
  19                 SeqAccess, Unexpected, VariantAccess, Visitor};
  20
  21 use error::Error;
  22 use map::Map;
  23 use number::Number;
  24 use value::Value;
  25
  26 #[cfg(feature = "arbitrary_precision")]
  27 use serde::de;
  28
  29 #[cfg(feature = "arbitrary_precision")]
  30 use number::{NumberFromString, SERDE_STRUCT_FIELD_NAME};
  31
  32 impl<'de> Deserialize<'de> for Value {
  33     #[inline]
  34     fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
  35     where
  36         D: serde::Deserializer<'de>,
  37     {
  38         struct ValueVisitor;
  39
  40         impl<'de> Visitor<'de> for ValueVisitor {
  41             type Value = Value;
  42
  43             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  44                 formatter.write_str("any valid JSON value")
  45             }
  46
  47             #[inline]
  48             fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
  49                 Ok(Value::Bool(value))
  50             }
  51
  52             #[inline]
  53             fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
  54                 Ok(Value::Number(value.into()))
  55             }
  56
  57             #[inline]
  58             fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
  59                 Ok(Value::Number(value.into()))
  60             }
  61
  62             #[inline]
  63             fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
  64                 Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
  65             }
  66
  67             #[inline]
  68             fn visit_str<E>(self, value: &str) -> Result<Value, E>
  69             where
  70                 E: serde::de::Error,
  71             {
  72                 self.visit_string(String::from(value))
  73             }
  74
  75             #[inline]
  76             fn visit_string<E>(self, value: String) -> Result<Value, E> {
  77                 Ok(Value::String(value))
  78             }
  79
  80             #[inline]
  81             fn visit_none<E>(self) -> Result<Value, E> {
  82                 Ok(Value::Null)
  83             }
  84
  85             #[inline]
  86             fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
  87             where
  88                 D: serde::Deserializer<'de>,
  89             {
  90                 Deserialize::deserialize(deserializer)
  91             }
  92
  93             #[inline]
  94             fn visit_unit<E>(self) -> Result<Value, E> {
  95                 Ok(Value::Null)
  96             }
  97
  98             #[inline]
  99             fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
 100             where
 101                 V: SeqAccess<'de>,
 102             {
 103                 let mut vec = Vec::new();
 104
 105                 while let Some(elem) = try!(visitor.next_element()) {
 106                     vec.push(elem);
 107                 }
 108
 109                 Ok(Value::Array(vec))
 110             }
 111
 112             #[cfg(not(feature = "arbitrary_precision"))]
 113             fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
 114             where
 115                 V: MapAccess<'de>,
 116             {
 117                 let mut values = Map::new();
 118
 119                 while let Some((key, value)) = try!(visitor.next_entry()) {
 120                     values.insert(key, value);
 121                 }
 122
 123                 Ok(Value::Object(values))
 124             }
 125
 126             #[cfg(feature = "arbitrary_precision")]
 127             fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
 128             where
 129                 V: MapAccess<'de>,
 130             {
 131                 let mut key = String::new();
 132                 let number = visitor.next_key_seed(NumberOrObject { key: &mut key })?;
 133                 match number {
 134                     Some(true) => {
 135                         let number: NumberFromString = visitor.next_value()?;
 136                         return Ok(Value::Number(number.value));
 137                     }
 138                     None => return Ok(Value::Object(Map::new())),
 139                     Some(false) => {}
 140                 }
 141
 142                 let mut values = Map::new();
 143
 144                 values.insert(key, try!(visitor.next_value()));
 145                 while let Some((key, value)) = try!(visitor.next_entry()) {
 146                     values.insert(key, value);
 147                 }
 148
 149                 Ok(Value::Object(values))
 150             }
 151         }
 152
 153         deserializer.deserialize_any(ValueVisitor)
 154     }
 155 }
 156
 157 struct WriterFormatter<'a, 'b: 'a> {
 158     inner: &'a mut fmt::Formatter<'b>,
 159 }
 160
 161 impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
 162     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 163         fn io_error<E>(_: E) -> io::Error {
 164             // Value does not matter because fmt::Debug and fmt::Display impls
 165             // below just map it to fmt::Error
 166             io::Error::new(io::ErrorKind::Other, "fmt error")
 167         }
 168         let s = try!(str::from_utf8(buf).map_err(io_error));
 169         try!(self.inner.write_str(s).map_err(io_error));
 170         Ok(buf.len())
 171     }
 172
 173     fn flush(&mut self) -> io::Result<()> {
 174         Ok(())
 175     }
 176 }
 177
 178 impl fmt::Display for Value {
 179     /// Display a JSON value as a string.
 180     ///
 181     /// ```rust
 182     /// # #[macro_use]
 183     /// # extern crate serde_json;
 184     /// #
 185     /// # fn main() {
 186     /// let json = json!({ "city": "London", "street": "10 Downing Street" });
 187     ///
 188     /// // Compact format:
 189     /// //
 190     /// // {"city":"London","street":"10 Downing Street"}
 191     /// let compact = format!("{}", json);
 192     /// assert_eq!(compact,
 193     ///     "{\"city\":\"London\",\"street\":\"10 Downing Street\"}");
 194     ///
 195     /// // Pretty format:
 196     /// //
 197     /// // {
 198     /// //   "city": "London",
 199     /// //   "street": "10 Downing Street"
 200     /// // }
 201     /// let pretty = format!("{:#}", json);
 202     /// assert_eq!(pretty,
 203     ///     "{\n  \"city\": \"London\",\n  \"street\": \"10 Downing Street\"\n}");
 204     /// # }
 205     /// ```
 206     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 207         let alternate = f.alternate();
 208         let mut wr = WriterFormatter { inner: f };
 209         if alternate {
 210             // {:#}
 211             super::super::ser::to_writer_pretty(&mut wr, self).map_err(|_| fmt::Error)
 212         } else {
 213             // {}
 214             super::super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
 215         }
 216     }
 217 }
 218
 219 impl str::FromStr for Value {
 220     type Err = Error;
 221     fn from_str(s: &str) -> Result<Value, Error> {
 222         super::super::de::from_str(s)
 223     }
 224 }
 225
 226 macro_rules! deserialize_prim_number {
 227     ($method:ident) => {
 228         #[cfg(not(feature = "arbitrary_precision"))]
 229         fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
 230         where
 231             V: Visitor<'de>,
 232         {
 233             match self {
 234                 Value::Number(n) => n.deserialize_any(visitor),
 235                 _ => Err(self.invalid_type(&visitor)),
 236             }
 237         }
 238
 239         #[cfg(feature = "arbitrary_precision")]
 240         fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
 241         where
 242             V: Visitor<'de>,
 243         {
 244             match self {
 245                 Value::Number(n) => n.$method(visitor),
 246                 _ => self.deserialize_any(visitor),
 247             }
 248         }
 249     }
 250 }
 251
 252 fn visit_array<'de, V>(array: Vec<Value>, visitor: V) -> Result<V::Value, Error>
 253 where
 254     V: Visitor<'de>,
 255 {
 256     let len = array.len();
 257     let mut deserializer = SeqDeserializer::new(array);
 258     let seq = try!(visitor.visit_seq(&mut deserializer));
 259     let remaining = deserializer.iter.len();
 260     if remaining == 0 {
 261         Ok(seq)
 262     } else {
 263         Err(serde::de::Error::invalid_length(
 264             len,
 265             &"fewer elements in array",
 266         ))
 267     }
 268 }
 269
 270 fn visit_object<'de, V>(object: Map<String, Value>, visitor: V) -> Result<V::Value, Error>
 271 where
 272     V: Visitor<'de>,
 273 {
 274     let len = object.len();
 275     let mut deserializer = MapDeserializer::new(object);
 276     let map = try!(visitor.visit_map(&mut deserializer));
 277     let remaining = deserializer.iter.len();
 278     if remaining == 0 {
 279         Ok(map)
 280     } else {
 281         Err(serde::de::Error::invalid_length(
 282             len,
 283             &"fewer elements in map",
 284         ))
 285     }
 286 }
 287
 288 impl<'de> serde::Deserializer<'de> for Value {
 289     type Error = Error;
 290
 291     #[inline]
 292     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
 293     where
 294         V: Visitor<'de>,
 295     {
 296         match self {
 297             Value::Null => visitor.visit_unit(),
 298             Value::Bool(v) => visitor.visit_bool(v),
 299             Value::Number(n) => n.deserialize_any(visitor),
 300             Value::String(v) => visitor.visit_string(v),
 301             Value::Array(v) => visit_array(v, visitor),
 302             Value::Object(v) => visit_object(v, visitor),
 303         }
 304     }
 305
 306     deserialize_prim_number!(deserialize_i8);
 307     deserialize_prim_number!(deserialize_i16);
 308     deserialize_prim_number!(deserialize_i32);
 309     deserialize_prim_number!(deserialize_i64);
 310     deserialize_prim_number!(deserialize_u8);
 311     deserialize_prim_number!(deserialize_u16);
 312     deserialize_prim_number!(deserialize_u32);
 313     deserialize_prim_number!(deserialize_u64);
 314     deserialize_prim_number!(deserialize_f32);
 315     deserialize_prim_number!(deserialize_f64);
 316
 317     #[inline]
 318     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
 319     where
 320         V: Visitor<'de>,
 321     {
 322         match self {
 323             Value::Null => visitor.visit_none(),
 324             _ => visitor.visit_some(self),
 325         }
 326     }
 327
 328     #[inline]
 329     fn deserialize_enum<V>(
 330         self,
 331         _name: &str,
 332         _variants: &'static [&'static str],
 333         visitor: V,
 334     ) -> Result<V::Value, Error>
 335     where
 336         V: Visitor<'de>,
 337     {
 338         let (variant, value) = match self {
 339             Value::Object(value) => {
 340                 let mut iter = value.into_iter();
 341                 let (variant, value) = match iter.next() {
 342                     Some(v) => v,
 343                     None => {
 344                         return Err(serde::de::Error::invalid_value(
 345                             Unexpected::Map,
 346                             &"map with a single key",
 347                         ));
 348                     }
 349                 };
 350                 // enums are encoded in json as maps with a single key:value pair
 351                 if iter.next().is_some() {
 352                     return Err(serde::de::Error::invalid_value(
 353                         Unexpected::Map,
 354                         &"map with a single key",
 355                     ));
 356                 }
 357                 (variant, Some(value))
 358             }
 359             Value::String(variant) => (variant, None),
 360             other => {
 361                 return Err(serde::de::Error::invalid_type(
 362                     other.unexpected(),
 363                     &"string or map",
 364                 ));
 365             }
 366         };
 367
 368         visitor.visit_enum(EnumDeserializer {
 369             variant: variant,
 370             value: value,
 371         })
 372     }
 373
 374     #[inline]
 375     fn deserialize_newtype_struct<V>(
 376         self,
 377         _name: &'static str,
 378         visitor: V,
 379     ) -> Result<V::Value, Self::Error>
 380     where
 381         V: Visitor<'de>,
 382     {
 383         visitor.visit_newtype_struct(self)
 384     }
 385
 386     fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 387     where
 388         V: Visitor<'de>,
 389     {
 390         match self {
 391             Value::Bool(v) => visitor.visit_bool(v),
 392             _ => Err(self.invalid_type(&visitor)),
 393         }
 394     }
 395
 396     fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 397     where
 398         V: Visitor<'de>,
 399     {
 400         self.deserialize_string(visitor)
 401     }
 402
 403     fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 404     where
 405         V: Visitor<'de>,
 406     {
 407         self.deserialize_string(visitor)
 408     }
 409
 410     fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 411     where
 412         V: Visitor<'de>,
 413     {
 414         match self {
 415             Value::String(v) => visitor.visit_string(v),
 416             _ => Err(self.invalid_type(&visitor)),
 417         }
 418     }
 419
 420     fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 421     where
 422         V: Visitor<'de>,
 423     {
 424         self.deserialize_byte_buf(visitor)
 425     }
 426
 427     fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 428     where
 429         V: Visitor<'de>,
 430     {
 431         match self {
 432             Value::String(v) => visitor.visit_string(v),
 433             Value::Array(v) => visit_array(v, visitor),
 434             _ => Err(self.invalid_type(&visitor)),
 435         }
 436     }
 437
 438     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 439     where
 440         V: Visitor<'de>,
 441     {
 442         match self {
 443             Value::Null => visitor.visit_unit(),
 444             _ => Err(self.invalid_type(&visitor)),
 445         }
 446     }
 447
 448     fn deserialize_unit_struct<V>(
 449         self,
 450         _name: &'static str,
 451         visitor: V,
 452     ) -> Result<V::Value, Self::Error>
 453     where
 454         V: Visitor<'de>,
 455     {
 456         self.deserialize_unit(visitor)
 457     }
 458
 459     fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 460     where
 461         V: Visitor<'de>,
 462     {
 463         match self {
 464             Value::Array(v) => visit_array(v, visitor),
 465             _ => Err(self.invalid_type(&visitor)),
 466         }
 467     }
 468
 469     fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
 470     where
 471         V: Visitor<'de>,
 472     {
 473         self.deserialize_seq(visitor)
 474     }
 475
 476     fn deserialize_tuple_struct<V>(
 477         self,
 478         _name: &'static str,
 479         _len: usize,
 480         visitor: V,
 481     ) -> Result<V::Value, Self::Error>
 482     where
 483         V: Visitor<'de>,
 484     {
 485         self.deserialize_seq(visitor)
 486     }
 487
 488     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 489     where
 490         V: Visitor<'de>,
 491     {
 492         match self {
 493             Value::Object(v) => visit_object(v, visitor),
 494             _ => Err(self.invalid_type(&visitor)),
 495         }
 496     }
 497
 498     fn deserialize_struct<V>(
 499         self,
 500         _name: &'static str,
 501         _fields: &'static [&'static str],
 502         visitor: V,
 503     ) -> Result<V::Value, Self::Error>
 504     where
 505         V: Visitor<'de>,
 506     {
 507         match self {
 508             Value::Array(v) => visit_array(v, visitor),
 509             Value::Object(v) => visit_object(v, visitor),
 510             _ => Err(self.invalid_type(&visitor)),
 511         }
 512     }
 513
 514     fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 515     where
 516         V: Visitor<'de>,
 517     {
 518         self.deserialize_string(visitor)
 519     }
 520
 521     fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 522     where
 523         V: Visitor<'de>,
 524     {
 525         drop(self);
 526         visitor.visit_unit()
 527     }
 528 }
 529
 530 struct EnumDeserializer {
 531     variant: String,
 532     value: Option<Value>,
 533 }
 534
 535 impl<'de> EnumAccess<'de> for EnumDeserializer {
 536     type Error = Error;
 537     type Variant = VariantDeserializer;
 538
 539     fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
 540     where
 541         V: DeserializeSeed<'de>,
 542     {
 543         let variant = self.variant.into_deserializer();
 544         let visitor = VariantDeserializer { value: self.value };
 545         seed.deserialize(variant).map(|v| (v, visitor))
 546     }
 547 }
 548
 549 struct VariantDeserializer {
 550     value: Option<Value>,
 551 }
 552
 553 impl<'de> VariantAccess<'de> for VariantDeserializer {
 554     type Error = Error;
 555
 556     fn unit_variant(self) -> Result<(), Error> {
 557         match self.value {
 558             Some(value) => Deserialize::deserialize(value),
 559             None => Ok(()),
 560         }
 561     }
 562
 563     fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
 564     where
 565         T: DeserializeSeed<'de>,
 566     {
 567         match self.value {
 568             Some(value) => seed.deserialize(value),
 569             None => Err(serde::de::Error::invalid_type(
 570                 Unexpected::UnitVariant,
 571                 &"newtype variant",
 572             )),
 573         }
 574     }
 575
 576     fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
 577     where
 578         V: Visitor<'de>,
 579     {
 580         match self.value {
 581             Some(Value::Array(v)) => {
 582                 serde::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
 583             }
 584             Some(other) => Err(serde::de::Error::invalid_type(
 585                 other.unexpected(),
 586                 &"tuple variant",
 587             )),
 588             None => Err(serde::de::Error::invalid_type(
 589                 Unexpected::UnitVariant,
 590                 &"tuple variant",
 591             )),
 592         }
 593     }
 594
 595     fn struct_variant<V>(
 596         self,
 597         _fields: &'static [&'static str],
 598         visitor: V,
 599     ) -> Result<V::Value, Error>
 600     where
 601         V: Visitor<'de>,
 602     {
 603         match self.value {
 604             Some(Value::Object(v)) => {
 605                 serde::Deserializer::deserialize_any(MapDeserializer::new(v), visitor)
 606             }
 607             Some(other) => Err(serde::de::Error::invalid_type(
 608                 other.unexpected(),
 609                 &"struct variant",
 610             )),
 611             _ => Err(serde::de::Error::invalid_type(
 612                 Unexpected::UnitVariant,
 613                 &"struct variant",
 614             )),
 615         }
 616     }
 617 }
 618
 619 struct SeqDeserializer {
 620     iter: vec::IntoIter<Value>,
 621 }
 622
 623 impl SeqDeserializer {
 624     fn new(vec: Vec<Value>) -> Self {
 625         SeqDeserializer {
 626             iter: vec.into_iter(),
 627         }
 628     }
 629 }
 630
 631 impl<'de> serde::Deserializer<'de> for SeqDeserializer {
 632     type Error = Error;
 633
 634     #[inline]
 635     fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
 636     where
 637         V: Visitor<'de>,
 638     {
 639         let len = self.iter.len();
 640         if len == 0 {
 641             visitor.visit_unit()
 642         } else {
 643             let ret = try!(visitor.visit_seq(&mut self));
 644             let remaining = self.iter.len();
 645             if remaining == 0 {
 646                 Ok(ret)
 647             } else {
 648                 Err(serde::de::Error::invalid_length(
 649                     len,
 650                     &"fewer elements in array",
 651                 ))
 652             }
 653         }
 654     }
 655
 656     forward_to_deserialize_any! {
 657         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
 658         byte_buf option unit unit_struct newtype_struct seq tuple
 659         tuple_struct map struct enum identifier ignored_any
 660     }
 661 }
 662
 663 impl<'de> SeqAccess<'de> for SeqDeserializer {
 664     type Error = Error;
 665
 666     fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
 667     where
 668         T: DeserializeSeed<'de>,
 669     {
 670         match self.iter.next() {
 671             Some(value) => seed.deserialize(value).map(Some),
 672             None => Ok(None),
 673         }
 674     }
 675
 676     fn size_hint(&self) -> Option<usize> {
 677         match self.iter.size_hint() {
 678             (lower, Some(upper)) if lower == upper => Some(upper),
 679             _ => None,
 680         }
 681     }
 682 }
 683
 684 struct MapDeserializer {
 685     iter: <Map<String, Value> as IntoIterator>::IntoIter,
 686     value: Option<Value>,
 687 }
 688
 689 impl MapDeserializer {
 690     fn new(map: Map<String, Value>) -> Self {
 691         MapDeserializer {
 692             iter: map.into_iter(),
 693             value: None,
 694         }
 695     }
 696 }
 697
 698 impl<'de> MapAccess<'de> for MapDeserializer {
 699     type Error = Error;
 700
 701     fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
 702     where
 703         T: DeserializeSeed<'de>,
 704     {
 705         match self.iter.next() {
 706             Some((key, value)) => {
 707                 self.value = Some(value);
 708                 let key_de = MapKeyDeserializer {
 709                     key: Cow::Owned(key),
 710                 };
 711                 seed.deserialize(key_de).map(Some)
 712             }
 713             None => Ok(None),
 714         }
 715     }
 716
 717     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
 718     where
 719         T: DeserializeSeed<'de>,
 720     {
 721         match self.value.take() {
 722             Some(value) => seed.deserialize(value),
 723             None => Err(serde::de::Error::custom("value is missing")),
 724         }
 725     }
 726
 727     fn size_hint(&self) -> Option<usize> {
 728         match self.iter.size_hint() {
 729             (lower, Some(upper)) if lower == upper => Some(upper),
 730             _ => None,
 731         }
 732     }
 733 }
 734
 735 impl<'de> serde::Deserializer<'de> for MapDeserializer {
 736     type Error = Error;
 737
 738     #[inline]
 739     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
 740     where
 741         V: Visitor<'de>,
 742     {
 743         visitor.visit_map(self)
 744     }
 745
 746     forward_to_deserialize_any! {
 747         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
 748         byte_buf option unit unit_struct newtype_struct seq tuple
 749         tuple_struct map struct enum identifier ignored_any
 750     }
 751 }
 752
 753 macro_rules! deserialize_value_ref_number {
 754     ($method:ident) => {
 755         #[cfg(not(feature = "arbitrary_precision"))]
 756         fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
 757         where
 758             V: Visitor<'de>,
 759         {
 760             match *self {
 761                 Value::Number(ref n) => n.deserialize_any(visitor),
 762                 _ => Err(self.invalid_type(&visitor)),
 763             }
 764         }
 765
 766         #[cfg(feature = "arbitrary_precision")]
 767         fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
 768         where
 769             V: Visitor<'de>,
 770         {
 771             match *self {
 772                 Value::Number(ref n) => n.$method(visitor),
 773                 _ => self.deserialize_any(visitor),
 774             }
 775         }
 776     }
 777 }
 778
 779 fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error>
 780 where
 781     V: Visitor<'de>,
 782 {
 783     let len = array.len();
 784     let mut deserializer = SeqRefDeserializer::new(array);
 785     let seq = try!(visitor.visit_seq(&mut deserializer));
 786     let remaining = deserializer.iter.len();
 787     if remaining == 0 {
 788         Ok(seq)
 789     } else {
 790         Err(serde::de::Error::invalid_length(
 791             len,
 792             &"fewer elements in array",
 793         ))
 794     }
 795 }
 796
 797 fn visit_object_ref<'de, V>(object: &'de Map<String, Value>, visitor: V) -> Result<V::Value, Error>
 798 where
 799     V: Visitor<'de>,
 800 {
 801     let len = object.len();
 802     let mut deserializer = MapRefDeserializer::new(object);
 803     let map = try!(visitor.visit_map(&mut deserializer));
 804     let remaining = deserializer.iter.len();
 805     if remaining == 0 {
 806         Ok(map)
 807     } else {
 808         Err(serde::de::Error::invalid_length(
 809             len,
 810             &"fewer elements in map",
 811         ))
 812     }
 813 }
 814
 815 impl<'de> serde::Deserializer<'de> for &'de Value {
 816     type Error = Error;
 817
 818     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
 819     where
 820         V: Visitor<'de>,
 821     {
 822         match *self {
 823             Value::Null => visitor.visit_unit(),
 824             Value::Bool(v) => visitor.visit_bool(v),
 825             Value::Number(ref n) => n.deserialize_any(visitor),
 826             Value::String(ref v) => visitor.visit_borrowed_str(v),
 827             Value::Array(ref v) => visit_array_ref(v, visitor),
 828             Value::Object(ref v) => visit_object_ref(v, visitor),
 829         }
 830     }
 831
 832     deserialize_value_ref_number!(deserialize_i8);
 833     deserialize_value_ref_number!(deserialize_i16);
 834     deserialize_value_ref_number!(deserialize_i32);
 835     deserialize_value_ref_number!(deserialize_i64);
 836     deserialize_value_ref_number!(deserialize_u8);
 837     deserialize_value_ref_number!(deserialize_u16);
 838     deserialize_value_ref_number!(deserialize_u32);
 839     deserialize_value_ref_number!(deserialize_u64);
 840     deserialize_value_ref_number!(deserialize_f32);
 841     deserialize_value_ref_number!(deserialize_f64);
 842
 843     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
 844     where
 845         V: Visitor<'de>,
 846     {
 847         match *self {
 848             Value::Null => visitor.visit_none(),
 849             _ => visitor.visit_some(self),
 850         }
 851     }
 852
 853     fn deserialize_enum<V>(
 854         self,
 855         _name: &str,
 856         _variants: &'static [&'static str],
 857         visitor: V,
 858     ) -> Result<V::Value, Error>
 859     where
 860         V: Visitor<'de>,
 861     {
 862         let (variant, value) = match *self {
 863             Value::Object(ref value) => {
 864                 let mut iter = value.into_iter();
 865                 let (variant, value) = match iter.next() {
 866                     Some(v) => v,
 867                     None => {
 868                         return Err(serde::de::Error::invalid_value(
 869                             Unexpected::Map,
 870                             &"map with a single key",
 871                         ));
 872                     }
 873                 };
 874                 // enums are encoded in json as maps with a single key:value pair
 875                 if iter.next().is_some() {
 876                     return Err(serde::de::Error::invalid_value(
 877                         Unexpected::Map,
 878                         &"map with a single key",
 879                     ));
 880                 }
 881                 (variant, Some(value))
 882             }
 883             Value::String(ref variant) => (variant, None),
 884             ref other => {
 885                 return Err(serde::de::Error::invalid_type(
 886                     other.unexpected(),
 887                     &"string or map",
 888                 ));
 889             }
 890         };
 891
 892         visitor.visit_enum(EnumRefDeserializer {
 893             variant: variant,
 894             value: value,
 895         })
 896     }
 897
 898     #[inline]
 899     fn deserialize_newtype_struct<V>(
 900         self,
 901         _name: &'static str,
 902         visitor: V,
 903     ) -> Result<V::Value, Self::Error>
 904     where
 905         V: Visitor<'de>,
 906     {
 907         visitor.visit_newtype_struct(self)
 908     }
 909
 910     fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 911     where
 912         V: Visitor<'de>,
 913     {
 914         match *self {
 915             Value::Bool(v) => visitor.visit_bool(v),
 916             _ => Err(self.invalid_type(&visitor)),
 917         }
 918     }
 919
 920     fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 921     where
 922         V: Visitor<'de>,
 923     {
 924         self.deserialize_str(visitor)
 925     }
 926
 927     fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 928     where
 929         V: Visitor<'de>,
 930     {
 931         match *self {
 932             Value::String(ref v) => visitor.visit_borrowed_str(v),
 933             _ => Err(self.invalid_type(&visitor)),
 934         }
 935     }
 936
 937     fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 938     where
 939         V: Visitor<'de>,
 940     {
 941         self.deserialize_str(visitor)
 942     }
 943
 944     fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 945     where
 946         V: Visitor<'de>,
 947     {
 948         match *self {
 949             Value::String(ref v) => visitor.visit_borrowed_str(v),
 950             Value::Array(ref v) => visit_array_ref(v, visitor),
 951             _ => Err(self.invalid_type(&visitor)),
 952         }
 953     }
 954
 955     fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 956     where
 957         V: Visitor<'de>,
 958     {
 959         self.deserialize_bytes(visitor)
 960     }
 961
 962     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 963     where
 964         V: Visitor<'de>,
 965     {
 966         match *self {
 967             Value::Null => visitor.visit_unit(),
 968             _ => Err(self.invalid_type(&visitor)),
 969         }
 970     }
 971
 972     fn deserialize_unit_struct<V>(
 973         self,
 974         _name: &'static str,
 975         visitor: V,
 976     ) -> Result<V::Value, Self::Error>
 977     where
 978         V: Visitor<'de>,
 979     {
 980         self.deserialize_unit(visitor)
 981     }
 982
 983     fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 984     where
 985         V: Visitor<'de>,
 986     {
 987         match *self {
 988             Value::Array(ref v) => visit_array_ref(v, visitor),
 989             _ => Err(self.invalid_type(&visitor)),
 990         }
 991     }
 992
 993     fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
 994     where
 995         V: Visitor<'de>,
 996     {
 997         self.deserialize_seq(visitor)
 998     }
 999
1000     fn deserialize_tuple_struct<V>(
1001         self,
1002         _name: &'static str,
1003         _len: usize,
1004         visitor: V,
1005     ) -> Result<V::Value, Self::Error>
1006     where
1007         V: Visitor<'de>,
1008     {
1009         self.deserialize_seq(visitor)
1010     }
1011
1012     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1013     where
1014         V: Visitor<'de>,
1015     {
1016         match *self {
1017             Value::Object(ref v) => visit_object_ref(v, visitor),
1018             _ => Err(self.invalid_type(&visitor)),
1019         }
1020     }
1021
1022     fn deserialize_struct<V>(
1023         self,
1024         _name: &'static str,
1025         _fields: &'static [&'static str],
1026         visitor: V,
1027     ) -> Result<V::Value, Self::Error>
1028     where
1029         V: Visitor<'de>,
1030     {
1031         match *self {
1032             Value::Array(ref v) => visit_array_ref(v, visitor),
1033             Value::Object(ref v) => visit_object_ref(v, visitor),
1034             _ => Err(self.invalid_type(&visitor)),
1035         }
1036     }
1037
1038     fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1039     where
1040         V: Visitor<'de>,
1041     {
1042         self.deserialize_str(visitor)
1043     }
1044
1045     fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1046     where
1047         V: Visitor<'de>,
1048     {
1049         visitor.visit_unit()
1050     }
1051 }
1052
1053 struct EnumRefDeserializer<'de> {
1054     variant: &'de str,
1055     value: Option<&'de Value>,
1056 }
1057
1058 impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
1059     type Error = Error;
1060     type Variant = VariantRefDeserializer<'de>;
1061
1062     fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
1063     where
1064         V: DeserializeSeed<'de>,
1065     {
1066         let variant = self.variant.into_deserializer();
1067         let visitor = VariantRefDeserializer { value: self.value };
1068         seed.deserialize(variant).map(|v| (v, visitor))
1069     }
1070 }
1071
1072 struct VariantRefDeserializer<'de> {
1073     value: Option<&'de Value>,
1074 }
1075
1076 impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
1077     type Error = Error;
1078
1079     fn unit_variant(self) -> Result<(), Error> {
1080         match self.value {
1081             Some(value) => Deserialize::deserialize(value),
1082             None => Ok(()),
1083         }
1084     }
1085
1086     fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
1087     where
1088         T: DeserializeSeed<'de>,
1089     {
1090         match self.value {
1091             Some(value) => seed.deserialize(value),
1092             None => Err(serde::de::Error::invalid_type(
1093                 Unexpected::UnitVariant,
1094                 &"newtype variant",
1095             )),
1096         }
1097     }
1098
1099     fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
1100     where
1101         V: Visitor<'de>,
1102     {
1103         match self.value {
1104             Some(&Value::Array(ref v)) => {
1105                 serde::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
1106             }
1107             Some(other) => Err(serde::de::Error::invalid_type(
1108                 other.unexpected(),
1109                 &"tuple variant",
1110             )),
1111             None => Err(serde::de::Error::invalid_type(
1112                 Unexpected::UnitVariant,
1113                 &"tuple variant",
1114             )),
1115         }
1116     }
1117
1118     fn struct_variant<V>(
1119         self,
1120         _fields: &'static [&'static str],
1121         visitor: V,
1122     ) -> Result<V::Value, Error>
1123     where
1124         V: Visitor<'de>,
1125     {
1126         match self.value {
1127             Some(&Value::Object(ref v)) => {
1128                 serde::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
1129             }
1130             Some(other) => Err(serde::de::Error::invalid_type(
1131                 other.unexpected(),
1132                 &"struct variant",
1133             )),
1134             _ => Err(serde::de::Error::invalid_type(
1135                 Unexpected::UnitVariant,
1136                 &"struct variant",
1137             )),
1138         }
1139     }
1140 }
1141
1142 struct SeqRefDeserializer<'de> {
1143     iter: slice::Iter<'de, Value>,
1144 }
1145
1146 impl<'de> SeqRefDeserializer<'de> {
1147     fn new(slice: &'de [Value]) -> Self {
1148         SeqRefDeserializer { iter: slice.iter() }
1149     }
1150 }
1151
1152 impl<'de> serde::Deserializer<'de> for SeqRefDeserializer<'de> {
1153     type Error = Error;
1154
1155     #[inline]
1156     fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
1157     where
1158         V: Visitor<'de>,
1159     {
1160         let len = self.iter.len();
1161         if len == 0 {
1162             visitor.visit_unit()
1163         } else {
1164             let ret = try!(visitor.visit_seq(&mut self));
1165             let remaining = self.iter.len();
1166             if remaining == 0 {
1167                 Ok(ret)
1168             } else {
1169                 Err(serde::de::Error::invalid_length(
1170                     len,
1171                     &"fewer elements in array",
1172                 ))
1173             }
1174         }
1175     }
1176
1177     forward_to_deserialize_any! {
1178         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1179         byte_buf option unit unit_struct newtype_struct seq tuple
1180         tuple_struct map struct enum identifier ignored_any
1181     }
1182 }
1183
1184 impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> {
1185     type Error = Error;
1186
1187     fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1188     where
1189         T: DeserializeSeed<'de>,
1190     {
1191         match self.iter.next() {
1192             Some(value) => seed.deserialize(value).map(Some),
1193             None => Ok(None),
1194         }
1195     }
1196
1197     fn size_hint(&self) -> Option<usize> {
1198         match self.iter.size_hint() {
1199             (lower, Some(upper)) if lower == upper => Some(upper),
1200             _ => None,
1201         }
1202     }
1203 }
1204
1205 struct MapRefDeserializer<'de> {
1206     iter: <&'de Map<String, Value> as IntoIterator>::IntoIter,
1207     value: Option<&'de Value>,
1208 }
1209
1210 impl<'de> MapRefDeserializer<'de> {
1211     fn new(map: &'de Map<String, Value>) -> Self {
1212         MapRefDeserializer {
1213             iter: map.into_iter(),
1214             value: None,
1215         }
1216     }
1217 }
1218
1219 impl<'de> MapAccess<'de> for MapRefDeserializer<'de> {
1220     type Error = Error;
1221
1222     fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1223     where
1224         T: DeserializeSeed<'de>,
1225     {
1226         match self.iter.next() {
1227             Some((key, value)) => {
1228                 self.value = Some(value);
1229                 let key_de = MapKeyDeserializer {
1230                     key: Cow::Borrowed(&**key),
1231                 };
1232                 seed.deserialize(key_de).map(Some)
1233             }
1234             None => Ok(None),
1235         }
1236     }
1237
1238     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
1239     where
1240         T: DeserializeSeed<'de>,
1241     {
1242         match self.value.take() {
1243             Some(value) => seed.deserialize(value),
1244             None => Err(serde::de::Error::custom("value is missing")),
1245         }
1246     }
1247
1248     fn size_hint(&self) -> Option<usize> {
1249         match self.iter.size_hint() {
1250             (lower, Some(upper)) if lower == upper => Some(upper),
1251             _ => None,
1252         }
1253     }
1254 }
1255
1256 impl<'de> serde::Deserializer<'de> for MapRefDeserializer<'de> {
1257     type Error = Error;
1258
1259     #[inline]
1260     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1261     where
1262         V: Visitor<'de>,
1263     {
1264         visitor.visit_map(self)
1265     }
1266
1267     forward_to_deserialize_any! {
1268         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1269         byte_buf option unit unit_struct newtype_struct seq tuple
1270         tuple_struct map struct enum identifier ignored_any
1271     }
1272 }
1273
1274 struct MapKeyDeserializer<'de> {
1275     key: Cow<'de, str>,
1276 }
1277
1278 macro_rules! deserialize_integer_key {
1279     ($method:ident => $visit:ident) => {
1280         fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
1281         where
1282             V: Visitor<'de>,
1283         {
1284             match (self.key.parse(), self.key) {
1285                 (Ok(integer), _) => visitor.$visit(integer),
1286                 (Err(_), Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
1287                 (Err(_), Cow::Owned(s)) => visitor.visit_string(s),
1288             }
1289         }
1290     }
1291 }
1292
1293 impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
1294     type Error = Error;
1295
1296     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1297     where
1298         V: Visitor<'de>,
1299     {
1300         self.key.into_deserializer().deserialize_any(visitor)
1301     }
1302
1303     deserialize_integer_key!(deserialize_i8 => visit_i8);
1304     deserialize_integer_key!(deserialize_i16 => visit_i16);
1305     deserialize_integer_key!(deserialize_i32 => visit_i32);
1306     deserialize_integer_key!(deserialize_i64 => visit_i64);
1307     deserialize_integer_key!(deserialize_u8 => visit_u8);
1308     deserialize_integer_key!(deserialize_u16 => visit_u16);
1309     deserialize_integer_key!(deserialize_u32 => visit_u32);
1310     deserialize_integer_key!(deserialize_u64 => visit_u64);
1311
1312     #[inline]
1313     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
1314     where
1315         V: Visitor<'de>,
1316     {
1317         // Map keys cannot be null.
1318         visitor.visit_some(self)
1319     }
1320
1321     #[inline]
1322     fn deserialize_newtype_struct<V>(
1323         self,
1324         _name: &'static str,
1325         visitor: V,
1326     ) -> Result<V::Value, Error>
1327     where
1328         V: Visitor<'de>,
1329     {
1330         visitor.visit_newtype_struct(self)
1331     }
1332
1333     fn deserialize_enum<V>(
1334         self,
1335         name: &'static str,
1336         variants: &'static [&'static str],
1337         visitor: V,
1338     ) -> Result<V::Value, Error>
1339     where
1340         V: Visitor<'de>,
1341     {
1342         self.key
1343             .into_deserializer()
1344             .deserialize_enum(name, variants, visitor)
1345     }
1346
1347     forward_to_deserialize_any! {
1348         bool f32 f64 char str string bytes byte_buf unit unit_struct seq tuple
1349         tuple_struct map struct identifier ignored_any
1350     }
1351 }
1352
1353 #[cfg(feature = "arbitrary_precision")]
1354 struct NumberOrObject<'a> {
1355     key: &'a mut String,
1356 }
1357
1358 #[cfg(feature = "arbitrary_precision")]
1359 impl<'a, 'de> DeserializeSeed<'de> for NumberOrObject<'a> {
1360     type Value = bool;
1361
1362     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1363     where
1364         D: serde::Deserializer<'de>,
1365     {
1366         deserializer.deserialize_any(self)
1367     }
1368 }
1369
1370 #[cfg(feature = "arbitrary_precision")]
1371 impl<'a, 'de> Visitor<'de> for NumberOrObject<'a> {
1372     type Value = bool;
1373
1374     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1375         formatter.write_str("a string key")
1376     }
1377
1378     fn visit_str<E>(self, s: &str) -> Result<bool, E>
1379     where
1380         E: de::Error,
1381     {
1382         if s == SERDE_STRUCT_FIELD_NAME {
1383             Ok(true)
1384         } else {
1385             self.key.push_str(s);
1386             Ok(false)
1387         }
1388     }
1389
1390     fn visit_string<E>(self, s: String) -> Result<bool, E>
1391     where
1392         E: de::Error,
1393     {
1394         if s == SERDE_STRUCT_FIELD_NAME {
1395             Ok(true)
1396         } else {
1397             *self.key = s;
1398             Ok(false)
1399         }
1400     }
1401 }
1402
1403 impl Value {
1404     #[cold]
1405     fn invalid_type<E>(&self, exp: &Expected) -> E
1406     where
1407         E: serde::de::Error,
1408     {
1409         serde::de::Error::invalid_type(self.unexpected(), exp)
1410     }
1411
1412     fn unexpected(&self) -> Unexpected {
1413         match *self {
1414             Value::Null => Unexpected::Unit,
1415             Value::Bool(b) => Unexpected::Bool(b),
1416             Value::Number(ref n) => n.unexpected(),
1417             Value::String(ref s) => Unexpected::Str(s),
1418             Value::Array(_) => Unexpected::Seq,
1419             Value::Object(_) => Unexpected::Map,
1420         }
1421     }
1422 }