| // Copyright 2017 Serde Developers |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| use std::prelude::v1::*; |
| use std::borrow::Cow; |
| use std::fmt; |
| use std::i64; |
| use std::io; |
| use std::slice; |
| use std::str; |
| use std::vec; |
| |
| use serde; |
| use serde::de::{Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, |
| SeqAccess, Unexpected, VariantAccess, Visitor}; |
| |
| use error::Error; |
| use map::Map; |
| use number::Number; |
| use value::Value; |
| |
| #[cfg(feature = "arbitrary_precision")] |
| use serde::de; |
| |
| #[cfg(feature = "arbitrary_precision")] |
| use number::{NumberFromString, SERDE_STRUCT_FIELD_NAME}; |
| |
| impl<'de> Deserialize<'de> for Value { |
| #[inline] |
| fn deserialize<D>(deserializer: D) -> Result<Value, D::Error> |
| where |
| D: serde::Deserializer<'de>, |
| { |
| struct ValueVisitor; |
| |
| impl<'de> Visitor<'de> for ValueVisitor { |
| type Value = Value; |
| |
| fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("any valid JSON value") |
| } |
| |
| #[inline] |
| fn visit_bool<E>(self, value: bool) -> Result<Value, E> { |
| Ok(Value::Bool(value)) |
| } |
| |
| #[inline] |
| fn visit_i64<E>(self, value: i64) -> Result<Value, E> { |
| Ok(Value::Number(value.into())) |
| } |
| |
| #[inline] |
| fn visit_u64<E>(self, value: u64) -> Result<Value, E> { |
| Ok(Value::Number(value.into())) |
| } |
| |
| #[inline] |
| fn visit_f64<E>(self, value: f64) -> Result<Value, E> { |
| Ok(Number::from_f64(value).map_or(Value::Null, Value::Number)) |
| } |
| |
| #[inline] |
| fn visit_str<E>(self, value: &str) -> Result<Value, E> |
| where |
| E: serde::de::Error, |
| { |
| self.visit_string(String::from(value)) |
| } |
| |
| #[inline] |
| fn visit_string<E>(self, value: String) -> Result<Value, E> { |
| Ok(Value::String(value)) |
| } |
| |
| #[inline] |
| fn visit_none<E>(self) -> Result<Value, E> { |
| Ok(Value::Null) |
| } |
| |
| #[inline] |
| fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error> |
| where |
| D: serde::Deserializer<'de>, |
| { |
| Deserialize::deserialize(deserializer) |
| } |
| |
| #[inline] |
| fn visit_unit<E>(self) -> Result<Value, E> { |
| Ok(Value::Null) |
| } |
| |
| #[inline] |
| fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error> |
| where |
| V: SeqAccess<'de>, |
| { |
| let mut vec = Vec::new(); |
| |
| while let Some(elem) = try!(visitor.next_element()) { |
| vec.push(elem); |
| } |
| |
| Ok(Value::Array(vec)) |
| } |
| |
| #[cfg(not(feature = "arbitrary_precision"))] |
| fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error> |
| where |
| V: MapAccess<'de>, |
| { |
| let mut values = Map::new(); |
| |
| while let Some((key, value)) = try!(visitor.next_entry()) { |
| values.insert(key, value); |
| } |
| |
| Ok(Value::Object(values)) |
| } |
| |
| #[cfg(feature = "arbitrary_precision")] |
| fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error> |
| where |
| V: MapAccess<'de>, |
| { |
| let mut key = String::new(); |
| let number = visitor.next_key_seed(NumberOrObject { key: &mut key })?; |
| match number { |
| Some(true) => { |
| let number: NumberFromString = visitor.next_value()?; |
| return Ok(Value::Number(number.value)); |
| } |
| None => return Ok(Value::Object(Map::new())), |
| Some(false) => {} |
| } |
| |
| let mut values = Map::new(); |
| |
| values.insert(key, try!(visitor.next_value())); |
| while let Some((key, value)) = try!(visitor.next_entry()) { |
| values.insert(key, value); |
| } |
| |
| Ok(Value::Object(values)) |
| } |
| } |
| |
| deserializer.deserialize_any(ValueVisitor) |
| } |
| } |
| |
| struct WriterFormatter<'a, 'b: 'a> { |
| inner: &'a mut fmt::Formatter<'b>, |
| } |
| |
| impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> { |
| fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
| fn io_error<E>(_: E) -> io::Error { |
| // Value does not matter because fmt::Debug and fmt::Display impls |
| // below just map it to fmt::Error |
| io::Error::new(io::ErrorKind::Other, "fmt error") |
| } |
| let s = try!(str::from_utf8(buf).map_err(io_error)); |
| try!(self.inner.write_str(s).map_err(io_error)); |
| Ok(buf.len()) |
| } |
| |
| fn flush(&mut self) -> io::Result<()> { |
| Ok(()) |
| } |
| } |
| |
| impl fmt::Display for Value { |
| /// Display a JSON value as a string. |
| /// |
| /// ```rust |
| /// # #[macro_use] |
| /// # extern crate serde_json; |
| /// # |
| /// # fn main() { |
| /// let json = json!({ "city": "London", "street": "10 Downing Street" }); |
| /// |
| /// // Compact format: |
| /// // |
| /// // {"city":"London","street":"10 Downing Street"} |
| /// let compact = format!("{}", json); |
| /// assert_eq!(compact, |
| /// "{\"city\":\"London\",\"street\":\"10 Downing Street\"}"); |
| /// |
| /// // Pretty format: |
| /// // |
| /// // { |
| /// // "city": "London", |
| /// // "street": "10 Downing Street" |
| /// // } |
| /// let pretty = format!("{:#}", json); |
| /// assert_eq!(pretty, |
| /// "{\n \"city\": \"London\",\n \"street\": \"10 Downing Street\"\n}"); |
| /// # } |
| /// ``` |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| let alternate = f.alternate(); |
| let mut wr = WriterFormatter { inner: f }; |
| if alternate { |
| // {:#} |
| super::super::ser::to_writer_pretty(&mut wr, self).map_err(|_| fmt::Error) |
| } else { |
| // {} |
| super::super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error) |
| } |
| } |
| } |
| |
| impl str::FromStr for Value { |
| type Err = Error; |
| fn from_str(s: &str) -> Result<Value, Error> { |
| super::super::de::from_str(s) |
| } |
| } |
| |
| macro_rules! deserialize_prim_number { |
| ($method:ident) => { |
| #[cfg(not(feature = "arbitrary_precision"))] |
| fn $method<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::Number(n) => n.deserialize_any(visitor), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| #[cfg(feature = "arbitrary_precision")] |
| fn $method<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::Number(n) => n.$method(visitor), |
| _ => self.deserialize_any(visitor), |
| } |
| } |
| } |
| } |
| |
| fn visit_array<'de, V>(array: Vec<Value>, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let len = array.len(); |
| let mut deserializer = SeqDeserializer::new(array); |
| let seq = try!(visitor.visit_seq(&mut deserializer)); |
| let remaining = deserializer.iter.len(); |
| if remaining == 0 { |
| Ok(seq) |
| } else { |
| Err(serde::de::Error::invalid_length( |
| len, |
| &"fewer elements in array", |
| )) |
| } |
| } |
| |
| fn visit_object<'de, V>(object: Map<String, Value>, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let len = object.len(); |
| let mut deserializer = MapDeserializer::new(object); |
| let map = try!(visitor.visit_map(&mut deserializer)); |
| let remaining = deserializer.iter.len(); |
| if remaining == 0 { |
| Ok(map) |
| } else { |
| Err(serde::de::Error::invalid_length( |
| len, |
| &"fewer elements in map", |
| )) |
| } |
| } |
| |
| impl<'de> serde::Deserializer<'de> for Value { |
| type Error = Error; |
| |
| #[inline] |
| fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::Null => visitor.visit_unit(), |
| Value::Bool(v) => visitor.visit_bool(v), |
| Value::Number(n) => n.deserialize_any(visitor), |
| Value::String(v) => visitor.visit_string(v), |
| Value::Array(v) => visit_array(v, visitor), |
| Value::Object(v) => visit_object(v, visitor), |
| } |
| } |
| |
| deserialize_prim_number!(deserialize_i8); |
| deserialize_prim_number!(deserialize_i16); |
| deserialize_prim_number!(deserialize_i32); |
| deserialize_prim_number!(deserialize_i64); |
| deserialize_prim_number!(deserialize_u8); |
| deserialize_prim_number!(deserialize_u16); |
| deserialize_prim_number!(deserialize_u32); |
| deserialize_prim_number!(deserialize_u64); |
| deserialize_prim_number!(deserialize_f32); |
| deserialize_prim_number!(deserialize_f64); |
| |
| #[inline] |
| fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::Null => visitor.visit_none(), |
| _ => visitor.visit_some(self), |
| } |
| } |
| |
| #[inline] |
| fn deserialize_enum<V>( |
| self, |
| _name: &str, |
| _variants: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let (variant, value) = match self { |
| Value::Object(value) => { |
| let mut iter = value.into_iter(); |
| let (variant, value) = match iter.next() { |
| Some(v) => v, |
| None => { |
| return Err(serde::de::Error::invalid_value( |
| Unexpected::Map, |
| &"map with a single key", |
| )); |
| } |
| }; |
| // enums are encoded in json as maps with a single key:value pair |
| if iter.next().is_some() { |
| return Err(serde::de::Error::invalid_value( |
| Unexpected::Map, |
| &"map with a single key", |
| )); |
| } |
| (variant, Some(value)) |
| } |
| Value::String(variant) => (variant, None), |
| other => { |
| return Err(serde::de::Error::invalid_type( |
| other.unexpected(), |
| &"string or map", |
| )); |
| } |
| }; |
| |
| visitor.visit_enum(EnumDeserializer { |
| variant: variant, |
| value: value, |
| }) |
| } |
| |
| #[inline] |
| fn deserialize_newtype_struct<V>( |
| self, |
| _name: &'static str, |
| visitor: V, |
| ) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| visitor.visit_newtype_struct(self) |
| } |
| |
| fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::Bool(v) => visitor.visit_bool(v), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_string(visitor) |
| } |
| |
| fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_string(visitor) |
| } |
| |
| fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::String(v) => visitor.visit_string(v), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_byte_buf(visitor) |
| } |
| |
| fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::String(v) => visitor.visit_string(v), |
| Value::Array(v) => visit_array(v, visitor), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::Null => visitor.visit_unit(), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_unit_struct<V>( |
| self, |
| _name: &'static str, |
| visitor: V, |
| ) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_unit(visitor) |
| } |
| |
| fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::Array(v) => visit_array(v, visitor), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_seq(visitor) |
| } |
| |
| fn deserialize_tuple_struct<V>( |
| self, |
| _name: &'static str, |
| _len: usize, |
| visitor: V, |
| ) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_seq(visitor) |
| } |
| |
| fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::Object(v) => visit_object(v, visitor), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_struct<V>( |
| self, |
| _name: &'static str, |
| _fields: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self { |
| Value::Array(v) => visit_array(v, visitor), |
| Value::Object(v) => visit_object(v, visitor), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_string(visitor) |
| } |
| |
| fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| drop(self); |
| visitor.visit_unit() |
| } |
| } |
| |
| struct EnumDeserializer { |
| variant: String, |
| value: Option<Value>, |
| } |
| |
| impl<'de> EnumAccess<'de> for EnumDeserializer { |
| type Error = Error; |
| type Variant = VariantDeserializer; |
| |
| fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error> |
| where |
| V: DeserializeSeed<'de>, |
| { |
| let variant = self.variant.into_deserializer(); |
| let visitor = VariantDeserializer { value: self.value }; |
| seed.deserialize(variant).map(|v| (v, visitor)) |
| } |
| } |
| |
| struct VariantDeserializer { |
| value: Option<Value>, |
| } |
| |
| impl<'de> VariantAccess<'de> for VariantDeserializer { |
| type Error = Error; |
| |
| fn unit_variant(self) -> Result<(), Error> { |
| match self.value { |
| Some(value) => Deserialize::deserialize(value), |
| None => Ok(()), |
| } |
| } |
| |
| fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error> |
| where |
| T: DeserializeSeed<'de>, |
| { |
| match self.value { |
| Some(value) => seed.deserialize(value), |
| None => Err(serde::de::Error::invalid_type( |
| Unexpected::UnitVariant, |
| &"newtype variant", |
| )), |
| } |
| } |
| |
| fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.value { |
| Some(Value::Array(v)) => { |
| serde::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor) |
| } |
| Some(other) => Err(serde::de::Error::invalid_type( |
| other.unexpected(), |
| &"tuple variant", |
| )), |
| None => Err(serde::de::Error::invalid_type( |
| Unexpected::UnitVariant, |
| &"tuple variant", |
| )), |
| } |
| } |
| |
| fn struct_variant<V>( |
| self, |
| _fields: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.value { |
| Some(Value::Object(v)) => { |
| serde::Deserializer::deserialize_any(MapDeserializer::new(v), visitor) |
| } |
| Some(other) => Err(serde::de::Error::invalid_type( |
| other.unexpected(), |
| &"struct variant", |
| )), |
| _ => Err(serde::de::Error::invalid_type( |
| Unexpected::UnitVariant, |
| &"struct variant", |
| )), |
| } |
| } |
| } |
| |
| struct SeqDeserializer { |
| iter: vec::IntoIter<Value>, |
| } |
| |
| impl SeqDeserializer { |
| fn new(vec: Vec<Value>) -> Self { |
| SeqDeserializer { |
| iter: vec.into_iter(), |
| } |
| } |
| } |
| |
| impl<'de> serde::Deserializer<'de> for SeqDeserializer { |
| type Error = Error; |
| |
| #[inline] |
| fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let len = self.iter.len(); |
| if len == 0 { |
| visitor.visit_unit() |
| } else { |
| let ret = try!(visitor.visit_seq(&mut self)); |
| let remaining = self.iter.len(); |
| if remaining == 0 { |
| Ok(ret) |
| } else { |
| Err(serde::de::Error::invalid_length( |
| len, |
| &"fewer elements in array", |
| )) |
| } |
| } |
| } |
| |
| forward_to_deserialize_any! { |
| bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes |
| byte_buf option unit unit_struct newtype_struct seq tuple |
| tuple_struct map struct enum identifier ignored_any |
| } |
| } |
| |
| impl<'de> SeqAccess<'de> for SeqDeserializer { |
| type Error = Error; |
| |
| fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error> |
| where |
| T: DeserializeSeed<'de>, |
| { |
| match self.iter.next() { |
| Some(value) => seed.deserialize(value).map(Some), |
| None => Ok(None), |
| } |
| } |
| |
| fn size_hint(&self) -> Option<usize> { |
| match self.iter.size_hint() { |
| (lower, Some(upper)) if lower == upper => Some(upper), |
| _ => None, |
| } |
| } |
| } |
| |
| struct MapDeserializer { |
| iter: <Map<String, Value> as IntoIterator>::IntoIter, |
| value: Option<Value>, |
| } |
| |
| impl MapDeserializer { |
| fn new(map: Map<String, Value>) -> Self { |
| MapDeserializer { |
| iter: map.into_iter(), |
| value: None, |
| } |
| } |
| } |
| |
| impl<'de> MapAccess<'de> for MapDeserializer { |
| type Error = Error; |
| |
| fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error> |
| where |
| T: DeserializeSeed<'de>, |
| { |
| match self.iter.next() { |
| Some((key, value)) => { |
| self.value = Some(value); |
| let key_de = MapKeyDeserializer { |
| key: Cow::Owned(key), |
| }; |
| seed.deserialize(key_de).map(Some) |
| } |
| None => Ok(None), |
| } |
| } |
| |
| fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error> |
| where |
| T: DeserializeSeed<'de>, |
| { |
| match self.value.take() { |
| Some(value) => seed.deserialize(value), |
| None => Err(serde::de::Error::custom("value is missing")), |
| } |
| } |
| |
| fn size_hint(&self) -> Option<usize> { |
| match self.iter.size_hint() { |
| (lower, Some(upper)) if lower == upper => Some(upper), |
| _ => None, |
| } |
| } |
| } |
| |
| impl<'de> serde::Deserializer<'de> for MapDeserializer { |
| type Error = Error; |
| |
| #[inline] |
| fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| visitor.visit_map(self) |
| } |
| |
| forward_to_deserialize_any! { |
| bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes |
| byte_buf option unit unit_struct newtype_struct seq tuple |
| tuple_struct map struct enum identifier ignored_any |
| } |
| } |
| |
| macro_rules! deserialize_value_ref_number { |
| ($method:ident) => { |
| #[cfg(not(feature = "arbitrary_precision"))] |
| fn $method<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::Number(ref n) => n.deserialize_any(visitor), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| #[cfg(feature = "arbitrary_precision")] |
| fn $method<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::Number(ref n) => n.$method(visitor), |
| _ => self.deserialize_any(visitor), |
| } |
| } |
| } |
| } |
| |
| fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let len = array.len(); |
| let mut deserializer = SeqRefDeserializer::new(array); |
| let seq = try!(visitor.visit_seq(&mut deserializer)); |
| let remaining = deserializer.iter.len(); |
| if remaining == 0 { |
| Ok(seq) |
| } else { |
| Err(serde::de::Error::invalid_length( |
| len, |
| &"fewer elements in array", |
| )) |
| } |
| } |
| |
| fn visit_object_ref<'de, V>(object: &'de Map<String, Value>, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let len = object.len(); |
| let mut deserializer = MapRefDeserializer::new(object); |
| let map = try!(visitor.visit_map(&mut deserializer)); |
| let remaining = deserializer.iter.len(); |
| if remaining == 0 { |
| Ok(map) |
| } else { |
| Err(serde::de::Error::invalid_length( |
| len, |
| &"fewer elements in map", |
| )) |
| } |
| } |
| |
| impl<'de> serde::Deserializer<'de> for &'de Value { |
| type Error = Error; |
| |
| fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::Null => visitor.visit_unit(), |
| Value::Bool(v) => visitor.visit_bool(v), |
| Value::Number(ref n) => n.deserialize_any(visitor), |
| Value::String(ref v) => visitor.visit_borrowed_str(v), |
| Value::Array(ref v) => visit_array_ref(v, visitor), |
| Value::Object(ref v) => visit_object_ref(v, visitor), |
| } |
| } |
| |
| deserialize_value_ref_number!(deserialize_i8); |
| deserialize_value_ref_number!(deserialize_i16); |
| deserialize_value_ref_number!(deserialize_i32); |
| deserialize_value_ref_number!(deserialize_i64); |
| deserialize_value_ref_number!(deserialize_u8); |
| deserialize_value_ref_number!(deserialize_u16); |
| deserialize_value_ref_number!(deserialize_u32); |
| deserialize_value_ref_number!(deserialize_u64); |
| deserialize_value_ref_number!(deserialize_f32); |
| deserialize_value_ref_number!(deserialize_f64); |
| |
| fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::Null => visitor.visit_none(), |
| _ => visitor.visit_some(self), |
| } |
| } |
| |
| fn deserialize_enum<V>( |
| self, |
| _name: &str, |
| _variants: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let (variant, value) = match *self { |
| Value::Object(ref value) => { |
| let mut iter = value.into_iter(); |
| let (variant, value) = match iter.next() { |
| Some(v) => v, |
| None => { |
| return Err(serde::de::Error::invalid_value( |
| Unexpected::Map, |
| &"map with a single key", |
| )); |
| } |
| }; |
| // enums are encoded in json as maps with a single key:value pair |
| if iter.next().is_some() { |
| return Err(serde::de::Error::invalid_value( |
| Unexpected::Map, |
| &"map with a single key", |
| )); |
| } |
| (variant, Some(value)) |
| } |
| Value::String(ref variant) => (variant, None), |
| ref other => { |
| return Err(serde::de::Error::invalid_type( |
| other.unexpected(), |
| &"string or map", |
| )); |
| } |
| }; |
| |
| visitor.visit_enum(EnumRefDeserializer { |
| variant: variant, |
| value: value, |
| }) |
| } |
| |
| #[inline] |
| fn deserialize_newtype_struct<V>( |
| self, |
| _name: &'static str, |
| visitor: V, |
| ) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| visitor.visit_newtype_struct(self) |
| } |
| |
| fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::Bool(v) => visitor.visit_bool(v), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_str(visitor) |
| } |
| |
| fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::String(ref v) => visitor.visit_borrowed_str(v), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_str(visitor) |
| } |
| |
| fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::String(ref v) => visitor.visit_borrowed_str(v), |
| Value::Array(ref v) => visit_array_ref(v, visitor), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_bytes(visitor) |
| } |
| |
| fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::Null => visitor.visit_unit(), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_unit_struct<V>( |
| self, |
| _name: &'static str, |
| visitor: V, |
| ) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_unit(visitor) |
| } |
| |
| fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::Array(ref v) => visit_array_ref(v, visitor), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_seq(visitor) |
| } |
| |
| fn deserialize_tuple_struct<V>( |
| self, |
| _name: &'static str, |
| _len: usize, |
| visitor: V, |
| ) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_seq(visitor) |
| } |
| |
| fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::Object(ref v) => visit_object_ref(v, visitor), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_struct<V>( |
| self, |
| _name: &'static str, |
| _fields: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| match *self { |
| Value::Array(ref v) => visit_array_ref(v, visitor), |
| Value::Object(ref v) => visit_object_ref(v, visitor), |
| _ => Err(self.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_str(visitor) |
| } |
| |
| fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| where |
| V: Visitor<'de>, |
| { |
| visitor.visit_unit() |
| } |
| } |
| |
| struct EnumRefDeserializer<'de> { |
| variant: &'de str, |
| value: Option<&'de Value>, |
| } |
| |
| impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> { |
| type Error = Error; |
| type Variant = VariantRefDeserializer<'de>; |
| |
| fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error> |
| where |
| V: DeserializeSeed<'de>, |
| { |
| let variant = self.variant.into_deserializer(); |
| let visitor = VariantRefDeserializer { value: self.value }; |
| seed.deserialize(variant).map(|v| (v, visitor)) |
| } |
| } |
| |
| struct VariantRefDeserializer<'de> { |
| value: Option<&'de Value>, |
| } |
| |
| impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> { |
| type Error = Error; |
| |
| fn unit_variant(self) -> Result<(), Error> { |
| match self.value { |
| Some(value) => Deserialize::deserialize(value), |
| None => Ok(()), |
| } |
| } |
| |
| fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error> |
| where |
| T: DeserializeSeed<'de>, |
| { |
| match self.value { |
| Some(value) => seed.deserialize(value), |
| None => Err(serde::de::Error::invalid_type( |
| Unexpected::UnitVariant, |
| &"newtype variant", |
| )), |
| } |
| } |
| |
| fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.value { |
| Some(&Value::Array(ref v)) => { |
| serde::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor) |
| } |
| Some(other) => Err(serde::de::Error::invalid_type( |
| other.unexpected(), |
| &"tuple variant", |
| )), |
| None => Err(serde::de::Error::invalid_type( |
| Unexpected::UnitVariant, |
| &"tuple variant", |
| )), |
| } |
| } |
| |
| fn struct_variant<V>( |
| self, |
| _fields: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.value { |
| Some(&Value::Object(ref v)) => { |
| serde::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor) |
| } |
| Some(other) => Err(serde::de::Error::invalid_type( |
| other.unexpected(), |
| &"struct variant", |
| )), |
| _ => Err(serde::de::Error::invalid_type( |
| Unexpected::UnitVariant, |
| &"struct variant", |
| )), |
| } |
| } |
| } |
| |
| struct SeqRefDeserializer<'de> { |
| iter: slice::Iter<'de, Value>, |
| } |
| |
| impl<'de> SeqRefDeserializer<'de> { |
| fn new(slice: &'de [Value]) -> Self { |
| SeqRefDeserializer { iter: slice.iter() } |
| } |
| } |
| |
| impl<'de> serde::Deserializer<'de> for SeqRefDeserializer<'de> { |
| type Error = Error; |
| |
| #[inline] |
| fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let len = self.iter.len(); |
| if len == 0 { |
| visitor.visit_unit() |
| } else { |
| let ret = try!(visitor.visit_seq(&mut self)); |
| let remaining = self.iter.len(); |
| if remaining == 0 { |
| Ok(ret) |
| } else { |
| Err(serde::de::Error::invalid_length( |
| len, |
| &"fewer elements in array", |
| )) |
| } |
| } |
| } |
| |
| forward_to_deserialize_any! { |
| bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes |
| byte_buf option unit unit_struct newtype_struct seq tuple |
| tuple_struct map struct enum identifier ignored_any |
| } |
| } |
| |
| impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> { |
| type Error = Error; |
| |
| fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error> |
| where |
| T: DeserializeSeed<'de>, |
| { |
| match self.iter.next() { |
| Some(value) => seed.deserialize(value).map(Some), |
| None => Ok(None), |
| } |
| } |
| |
| fn size_hint(&self) -> Option<usize> { |
| match self.iter.size_hint() { |
| (lower, Some(upper)) if lower == upper => Some(upper), |
| _ => None, |
| } |
| } |
| } |
| |
| struct MapRefDeserializer<'de> { |
| iter: <&'de Map<String, Value> as IntoIterator>::IntoIter, |
| value: Option<&'de Value>, |
| } |
| |
| impl<'de> MapRefDeserializer<'de> { |
| fn new(map: &'de Map<String, Value>) -> Self { |
| MapRefDeserializer { |
| iter: map.into_iter(), |
| value: None, |
| } |
| } |
| } |
| |
| impl<'de> MapAccess<'de> for MapRefDeserializer<'de> { |
| type Error = Error; |
| |
| fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error> |
| where |
| T: DeserializeSeed<'de>, |
| { |
| match self.iter.next() { |
| Some((key, value)) => { |
| self.value = Some(value); |
| let key_de = MapKeyDeserializer { |
| key: Cow::Borrowed(&**key), |
| }; |
| seed.deserialize(key_de).map(Some) |
| } |
| None => Ok(None), |
| } |
| } |
| |
| fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error> |
| where |
| T: DeserializeSeed<'de>, |
| { |
| match self.value.take() { |
| Some(value) => seed.deserialize(value), |
| None => Err(serde::de::Error::custom("value is missing")), |
| } |
| } |
| |
| fn size_hint(&self) -> Option<usize> { |
| match self.iter.size_hint() { |
| (lower, Some(upper)) if lower == upper => Some(upper), |
| _ => None, |
| } |
| } |
| } |
| |
| impl<'de> serde::Deserializer<'de> for MapRefDeserializer<'de> { |
| type Error = Error; |
| |
| #[inline] |
| fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| visitor.visit_map(self) |
| } |
| |
| forward_to_deserialize_any! { |
| bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes |
| byte_buf option unit unit_struct newtype_struct seq tuple |
| tuple_struct map struct enum identifier ignored_any |
| } |
| } |
| |
| struct MapKeyDeserializer<'de> { |
| key: Cow<'de, str>, |
| } |
| |
| macro_rules! deserialize_integer_key { |
| ($method:ident => $visit:ident) => { |
| fn $method<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match (self.key.parse(), self.key) { |
| (Ok(integer), _) => visitor.$visit(integer), |
| (Err(_), Cow::Borrowed(s)) => visitor.visit_borrowed_str(s), |
| (Err(_), Cow::Owned(s)) => visitor.visit_string(s), |
| } |
| } |
| } |
| } |
| |
| impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> { |
| type Error = Error; |
| |
| fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.key.into_deserializer().deserialize_any(visitor) |
| } |
| |
| deserialize_integer_key!(deserialize_i8 => visit_i8); |
| deserialize_integer_key!(deserialize_i16 => visit_i16); |
| deserialize_integer_key!(deserialize_i32 => visit_i32); |
| deserialize_integer_key!(deserialize_i64 => visit_i64); |
| deserialize_integer_key!(deserialize_u8 => visit_u8); |
| deserialize_integer_key!(deserialize_u16 => visit_u16); |
| deserialize_integer_key!(deserialize_u32 => visit_u32); |
| deserialize_integer_key!(deserialize_u64 => visit_u64); |
| |
| #[inline] |
| fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| // Map keys cannot be null. |
| visitor.visit_some(self) |
| } |
| |
| #[inline] |
| fn deserialize_newtype_struct<V>( |
| self, |
| _name: &'static str, |
| visitor: V, |
| ) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| visitor.visit_newtype_struct(self) |
| } |
| |
| fn deserialize_enum<V>( |
| self, |
| name: &'static str, |
| variants: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.key |
| .into_deserializer() |
| .deserialize_enum(name, variants, visitor) |
| } |
| |
| forward_to_deserialize_any! { |
| bool f32 f64 char str string bytes byte_buf unit unit_struct seq tuple |
| tuple_struct map struct identifier ignored_any |
| } |
| } |
| |
| #[cfg(feature = "arbitrary_precision")] |
| struct NumberOrObject<'a> { |
| key: &'a mut String, |
| } |
| |
| #[cfg(feature = "arbitrary_precision")] |
| impl<'a, 'de> DeserializeSeed<'de> for NumberOrObject<'a> { |
| type Value = bool; |
| |
| fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> |
| where |
| D: serde::Deserializer<'de>, |
| { |
| deserializer.deserialize_any(self) |
| } |
| } |
| |
| #[cfg(feature = "arbitrary_precision")] |
| impl<'a, 'de> Visitor<'de> for NumberOrObject<'a> { |
| type Value = bool; |
| |
| fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("a string key") |
| } |
| |
| fn visit_str<E>(self, s: &str) -> Result<bool, E> |
| where |
| E: de::Error, |
| { |
| if s == SERDE_STRUCT_FIELD_NAME { |
| Ok(true) |
| } else { |
| self.key.push_str(s); |
| Ok(false) |
| } |
| } |
| |
| fn visit_string<E>(self, s: String) -> Result<bool, E> |
| where |
| E: de::Error, |
| { |
| if s == SERDE_STRUCT_FIELD_NAME { |
| Ok(true) |
| } else { |
| *self.key = s; |
| Ok(false) |
| } |
| } |
| } |
| |
| impl Value { |
| #[cold] |
| fn invalid_type<E>(&self, exp: &Expected) -> E |
| where |
| E: serde::de::Error, |
| { |
| serde::de::Error::invalid_type(self.unexpected(), exp) |
| } |
| |
| #[cold] |
| fn unexpected(&self) -> Unexpected { |
| match *self { |
| Value::Null => Unexpected::Unit, |
| Value::Bool(b) => Unexpected::Bool(b), |
| Value::Number(ref n) => n.unexpected(), |
| Value::String(ref s) => Unexpected::Str(s), |
| Value::Array(_) => Unexpected::Seq, |
| Value::Object(_) => Unexpected::Map, |
| } |
| } |
| } |