use crate::error::{Error, ErrorCode}; use crate::map::Map; use crate::number::Number; use crate::value::Value; use alloc::borrow::{Cow, ToOwned}; use alloc::string::String; #[cfg(feature = "raw_value")] use alloc::string::ToString; use alloc::vec::{self, Vec}; use core::fmt; use core::slice; use core::str::FromStr; use serde::de::{ self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, SeqAccess, Unexpected, VariantAccess, Visitor, }; use serde::forward_to_deserialize_any; #[cfg(feature = "arbitrary_precision")] use crate::number::NumberFromString; impl<'de> Deserialize<'de> for Value { #[inline] fn deserialize(deserializer: D) -> Result 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(self, value: bool) -> Result { Ok(Value::Bool(value)) } #[inline] fn visit_i64(self, value: i64) -> Result { Ok(Value::Number(value.into())) } #[inline] fn visit_u64(self, value: u64) -> Result { Ok(Value::Number(value.into())) } #[inline] fn visit_f64(self, value: f64) -> Result { Ok(Number::from_f64(value).map_or(Value::Null, Value::Number)) } #[cfg(any(feature = "std", feature = "alloc"))] #[inline] fn visit_str(self, value: &str) -> Result where E: serde::de::Error, { self.visit_string(String::from(value)) } #[cfg(any(feature = "std", feature = "alloc"))] #[inline] fn visit_string(self, value: String) -> Result { Ok(Value::String(value)) } #[inline] fn visit_none(self) -> Result { Ok(Value::Null) } #[inline] fn visit_some(self, deserializer: D) -> Result where D: serde::Deserializer<'de>, { Deserialize::deserialize(deserializer) } #[inline] fn visit_unit(self) -> Result { Ok(Value::Null) } #[inline] fn visit_seq(self, mut visitor: V) -> Result where V: SeqAccess<'de>, { let mut vec = Vec::new(); while let Some(elem) = tri!(visitor.next_element()) { vec.push(elem); } Ok(Value::Array(vec)) } #[cfg(any(feature = "std", feature = "alloc"))] fn visit_map(self, mut visitor: V) -> Result where V: MapAccess<'de>, { match tri!(visitor.next_key_seed(KeyClassifier)) { #[cfg(feature = "arbitrary_precision")] Some(KeyClass::Number) => { let number: NumberFromString = tri!(visitor.next_value()); Ok(Value::Number(number.value)) } #[cfg(feature = "raw_value")] Some(KeyClass::RawValue) => { let value = tri!(visitor.next_value_seed(crate::raw::BoxedFromString)); crate::from_str(value.get()).map_err(de::Error::custom) } Some(KeyClass::Map(first_key)) => { let mut values = Map::new(); values.insert(first_key, tri!(visitor.next_value())); while let Some((key, value)) = tri!(visitor.next_entry()) { values.insert(key, value); } Ok(Value::Object(values)) } None => Ok(Value::Object(Map::new())), } } } deserializer.deserialize_any(ValueVisitor) } } impl FromStr for Value { type Err = Error; fn from_str(s: &str) -> Result { super::super::de::from_str(s) } } macro_rules! deserialize_number { ($method:ident) => { #[cfg(not(feature = "arbitrary_precision"))] fn $method(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Number(n) => n.deserialize_any(visitor), _ => Err(self.invalid_type(&visitor)), } } #[cfg(feature = "arbitrary_precision")] fn $method(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Number(n) => n.$method(visitor), _ => self.deserialize_any(visitor), } } }; } fn visit_array<'de, V>(array: Vec, visitor: V) -> Result where V: Visitor<'de>, { let len = array.len(); let mut deserializer = SeqDeserializer::new(array); let seq = tri!(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, visitor: V) -> Result where V: Visitor<'de>, { let len = object.len(); let mut deserializer = MapDeserializer::new(object); let map = tri!(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(self, visitor: V) -> Result 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), #[cfg(any(feature = "std", feature = "alloc"))] Value::String(v) => visitor.visit_string(v), Value::Array(v) => visit_array(v, visitor), Value::Object(v) => visit_object(v, visitor), } } deserialize_number!(deserialize_i8); deserialize_number!(deserialize_i16); deserialize_number!(deserialize_i32); deserialize_number!(deserialize_i64); deserialize_number!(deserialize_i128); deserialize_number!(deserialize_u8); deserialize_number!(deserialize_u16); deserialize_number!(deserialize_u32); deserialize_number!(deserialize_u64); deserialize_number!(deserialize_u128); deserialize_number!(deserialize_f32); deserialize_number!(deserialize_f64); #[inline] fn deserialize_option(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Null => visitor.visit_none(), _ => visitor.visit_some(self), } } #[inline] fn deserialize_enum( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result 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, value }) } #[inline] fn deserialize_newtype_struct( self, name: &'static str, visitor: V, ) -> Result where V: Visitor<'de>, { #[cfg(feature = "raw_value")] { if name == crate::raw::TOKEN { return visitor.visit_map(crate::raw::OwnedRawDeserializer { raw_value: Some(self.to_string()), }); } } let _ = name; visitor.visit_newtype_struct(self) } fn deserialize_bool(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Bool(v) => visitor.visit_bool(v), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_char(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_string(visitor) } fn deserialize_str(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_string(visitor) } fn deserialize_string(self, visitor: V) -> Result where V: Visitor<'de>, { match self { #[cfg(any(feature = "std", feature = "alloc"))] Value::String(v) => visitor.visit_string(v), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_bytes(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_byte_buf(visitor) } fn deserialize_byte_buf(self, visitor: V) -> Result where V: Visitor<'de>, { match self { #[cfg(any(feature = "std", feature = "alloc"))] Value::String(v) => visitor.visit_string(v), Value::Array(v) => visit_array(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_unit(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Null => visitor.visit_unit(), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_unit_struct(self, _name: &'static str, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_unit(visitor) } fn deserialize_seq(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Array(v) => visit_array(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_tuple(self, _len: usize, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_seq(visitor) } fn deserialize_tuple_struct( self, _name: &'static str, _len: usize, visitor: V, ) -> Result where V: Visitor<'de>, { self.deserialize_seq(visitor) } fn deserialize_map(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Object(v) => visit_object(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_struct( self, _name: &'static str, _fields: &'static [&'static str], visitor: V, ) -> Result 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(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_string(visitor) } fn deserialize_ignored_any(self, visitor: V) -> Result where V: Visitor<'de>, { drop(self); visitor.visit_unit() } } struct EnumDeserializer { variant: String, value: Option, } impl<'de> EnumAccess<'de> for EnumDeserializer { type Error = Error; type Variant = VariantDeserializer; fn variant_seed(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)) } } impl<'de> IntoDeserializer<'de, Error> for Value { type Deserializer = Self; fn into_deserializer(self) -> Self::Deserializer { self } } impl<'de> IntoDeserializer<'de, Error> for &'de Value { type Deserializer = Self; fn into_deserializer(self) -> Self::Deserializer { self } } struct VariantDeserializer { value: Option, } 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(self, seed: T) -> Result 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(self, _len: usize, visitor: V) -> Result where V: Visitor<'de>, { match self.value { Some(Value::Array(v)) => { if v.is_empty() { visitor.visit_unit() } else { visit_array(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( self, _fields: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { match self.value { Some(Value::Object(v)) => visit_object(v, visitor), Some(other) => Err(serde::de::Error::invalid_type( other.unexpected(), &"struct variant", )), None => Err(serde::de::Error::invalid_type( Unexpected::UnitVariant, &"struct variant", )), } } } struct SeqDeserializer { iter: vec::IntoIter, } impl SeqDeserializer { fn new(vec: Vec) -> Self { SeqDeserializer { iter: vec.into_iter(), } } } impl<'de> SeqAccess<'de> for SeqDeserializer { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result, Error> where T: DeserializeSeed<'de>, { match self.iter.next() { Some(value) => seed.deserialize(value).map(Some), None => Ok(None), } } fn size_hint(&self) -> Option { match self.iter.size_hint() { (lower, Some(upper)) if lower == upper => Some(upper), _ => None, } } } struct MapDeserializer { iter: as IntoIterator>::IntoIter, value: Option, } impl MapDeserializer { fn new(map: Map) -> Self { MapDeserializer { iter: map.into_iter(), value: None, } } } impl<'de> MapAccess<'de> for MapDeserializer { type Error = Error; fn next_key_seed(&mut self, seed: T) -> Result, 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(&mut self, seed: T) -> Result 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 { match self.iter.size_hint() { (lower, Some(upper)) if lower == upper => Some(upper), _ => None, } } } macro_rules! deserialize_value_ref_number { ($method:ident) => { #[cfg(not(feature = "arbitrary_precision"))] fn $method(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Number(n) => n.deserialize_any(visitor), _ => Err(self.invalid_type(&visitor)), } } #[cfg(feature = "arbitrary_precision")] fn $method(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Number(n) => n.$method(visitor), _ => self.deserialize_any(visitor), } } }; } fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result where V: Visitor<'de>, { let len = array.len(); let mut deserializer = SeqRefDeserializer::new(array); let seq = tri!(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, visitor: V) -> Result where V: Visitor<'de>, { let len = object.len(); let mut deserializer = MapRefDeserializer::new(object); let map = tri!(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(self, visitor: V) -> Result 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_borrowed_str(v), Value::Array(v) => visit_array_ref(v, visitor), Value::Object(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_number!(deserialize_i128); 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_number!(deserialize_u128); deserialize_value_ref_number!(deserialize_f32); deserialize_value_ref_number!(deserialize_f64); fn deserialize_option(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Null => visitor.visit_none(), _ => visitor.visit_some(self), } } fn deserialize_enum( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result 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(EnumRefDeserializer { variant, value }) } #[inline] fn deserialize_newtype_struct( self, name: &'static str, visitor: V, ) -> Result where V: Visitor<'de>, { #[cfg(feature = "raw_value")] { if name == crate::raw::TOKEN { return visitor.visit_map(crate::raw::OwnedRawDeserializer { raw_value: Some(self.to_string()), }); } } let _ = name; visitor.visit_newtype_struct(self) } fn deserialize_bool(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Bool(v) => visitor.visit_bool(v), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_char(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_str(visitor) } fn deserialize_str(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::String(v) => visitor.visit_borrowed_str(v), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_string(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_str(visitor) } fn deserialize_bytes(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::String(v) => visitor.visit_borrowed_str(v), Value::Array(v) => visit_array_ref(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_byte_buf(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_bytes(visitor) } fn deserialize_unit(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Null => visitor.visit_unit(), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_unit_struct(self, _name: &'static str, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_unit(visitor) } fn deserialize_seq(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Array(v) => visit_array_ref(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_tuple(self, _len: usize, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_seq(visitor) } fn deserialize_tuple_struct( self, _name: &'static str, _len: usize, visitor: V, ) -> Result where V: Visitor<'de>, { self.deserialize_seq(visitor) } fn deserialize_map(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Object(v) => visit_object_ref(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_struct( self, _name: &'static str, _fields: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { match self { Value::Array(v) => visit_array_ref(v, visitor), Value::Object(v) => visit_object_ref(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_identifier(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_str(visitor) } fn deserialize_ignored_any(self, visitor: V) -> Result 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(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(self, seed: T) -> Result 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(self, _len: usize, visitor: V) -> Result where V: Visitor<'de>, { match self.value { Some(Value::Array(v)) => { if v.is_empty() { visitor.visit_unit() } else { visit_array_ref(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( self, _fields: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { match self.value { Some(Value::Object(v)) => visit_object_ref(v, visitor), Some(other) => Err(serde::de::Error::invalid_type( other.unexpected(), &"struct variant", )), None => 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> SeqAccess<'de> for SeqRefDeserializer<'de> { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result, Error> where T: DeserializeSeed<'de>, { match self.iter.next() { Some(value) => seed.deserialize(value).map(Some), None => Ok(None), } } fn size_hint(&self) -> Option { match self.iter.size_hint() { (lower, Some(upper)) if lower == upper => Some(upper), _ => None, } } } struct MapRefDeserializer<'de> { iter: <&'de Map as IntoIterator>::IntoIter, value: Option<&'de Value>, } impl<'de> MapRefDeserializer<'de> { fn new(map: &'de Map) -> Self { MapRefDeserializer { iter: map.into_iter(), value: None, } } } impl<'de> MapAccess<'de> for MapRefDeserializer<'de> { type Error = Error; fn next_key_seed(&mut self, seed: T) -> Result, 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(&mut self, seed: T) -> Result 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 { match self.iter.size_hint() { (lower, Some(upper)) if lower == upper => Some(upper), _ => None, } } } struct MapKeyDeserializer<'de> { key: Cow<'de, str>, } macro_rules! deserialize_numeric_key { ($method:ident) => { deserialize_numeric_key!($method, deserialize_number); }; ($method:ident, $using:ident) => { fn $method(self, visitor: V) -> Result where V: Visitor<'de>, { let mut de = crate::Deserializer::from_str(&self.key); match tri!(de.peek()) { Some(b'0'..=b'9' | b'-') => {} _ => return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0)), } let number = tri!(de.$using(visitor)); if tri!(de.peek()).is_some() { return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0)); } Ok(number) } }; } impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> { type Error = Error; fn deserialize_any(self, visitor: V) -> Result where V: Visitor<'de>, { BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor) } deserialize_numeric_key!(deserialize_i8); deserialize_numeric_key!(deserialize_i16); deserialize_numeric_key!(deserialize_i32); deserialize_numeric_key!(deserialize_i64); deserialize_numeric_key!(deserialize_u8); deserialize_numeric_key!(deserialize_u16); deserialize_numeric_key!(deserialize_u32); deserialize_numeric_key!(deserialize_u64); #[cfg(not(feature = "float_roundtrip"))] deserialize_numeric_key!(deserialize_f32); deserialize_numeric_key!(deserialize_f64); #[cfg(feature = "float_roundtrip")] deserialize_numeric_key!(deserialize_f32, do_deserialize_f32); deserialize_numeric_key!(deserialize_i128, do_deserialize_i128); deserialize_numeric_key!(deserialize_u128, do_deserialize_u128); fn deserialize_bool(self, visitor: V) -> Result where V: Visitor<'de>, { if self.key == "true" { visitor.visit_bool(true) } else if self.key == "false" { visitor.visit_bool(false) } else { Err(serde::de::Error::invalid_type( Unexpected::Str(&self.key), &visitor, )) } } #[inline] fn deserialize_option(self, visitor: V) -> Result where V: Visitor<'de>, { // Map keys cannot be null. visitor.visit_some(self) } #[inline] fn deserialize_newtype_struct( self, _name: &'static str, visitor: V, ) -> Result where V: Visitor<'de>, { visitor.visit_newtype_struct(self) } fn deserialize_enum( self, name: &'static str, variants: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { self.key .into_deserializer() .deserialize_enum(name, variants, visitor) } forward_to_deserialize_any! { char str string bytes byte_buf unit unit_struct seq tuple tuple_struct map struct identifier ignored_any } } struct KeyClassifier; enum KeyClass { Map(String), #[cfg(feature = "arbitrary_precision")] Number, #[cfg(feature = "raw_value")] RawValue, } impl<'de> DeserializeSeed<'de> for KeyClassifier { type Value = KeyClass; fn deserialize(self, deserializer: D) -> Result where D: serde::Deserializer<'de>, { deserializer.deserialize_str(self) } } impl<'de> Visitor<'de> for KeyClassifier { type Value = KeyClass; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a string key") } fn visit_str(self, s: &str) -> Result where E: de::Error, { match s { #[cfg(feature = "arbitrary_precision")] crate::number::TOKEN => Ok(KeyClass::Number), #[cfg(feature = "raw_value")] crate::raw::TOKEN => Ok(KeyClass::RawValue), _ => Ok(KeyClass::Map(s.to_owned())), } } #[cfg(any(feature = "std", feature = "alloc"))] fn visit_string(self, s: String) -> Result where E: de::Error, { match s.as_str() { #[cfg(feature = "arbitrary_precision")] crate::number::TOKEN => Ok(KeyClass::Number), #[cfg(feature = "raw_value")] crate::raw::TOKEN => Ok(KeyClass::RawValue), _ => Ok(KeyClass::Map(s)), } } } impl Value { #[cold] fn invalid_type(&self, exp: &dyn 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(n) => n.unexpected(), Value::String(s) => Unexpected::Str(s), Value::Array(_) => Unexpected::Seq, Value::Object(_) => Unexpected::Map, } } } struct BorrowedCowStrDeserializer<'de> { value: Cow<'de, str>, } impl<'de> BorrowedCowStrDeserializer<'de> { fn new(value: Cow<'de, str>) -> Self { BorrowedCowStrDeserializer { value } } } impl<'de> de::Deserializer<'de> for BorrowedCowStrDeserializer<'de> { type Error = Error; fn deserialize_any(self, visitor: V) -> Result where V: de::Visitor<'de>, { match self.value { Cow::Borrowed(string) => visitor.visit_borrowed_str(string), #[cfg(any(feature = "std", feature = "alloc"))] Cow::Owned(string) => visitor.visit_string(string), } } fn deserialize_enum( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result where V: de::Visitor<'de>, { visitor.visit_enum(self) } forward_to_deserialize_any! { bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string bytes byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct map struct identifier ignored_any } } impl<'de> de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> { type Error = Error; type Variant = UnitOnly; fn variant_seed(self, seed: T) -> Result<(T::Value, Self::Variant), Error> where T: de::DeserializeSeed<'de>, { let value = tri!(seed.deserialize(self)); Ok((value, UnitOnly)) } } struct UnitOnly; impl<'de> de::VariantAccess<'de> for UnitOnly { type Error = Error; fn unit_variant(self) -> Result<(), Error> { Ok(()) } fn newtype_variant_seed(self, _seed: T) -> Result where T: de::DeserializeSeed<'de>, { Err(de::Error::invalid_type( Unexpected::UnitVariant, &"newtype variant", )) } fn tuple_variant(self, _len: usize, _visitor: V) -> Result where V: de::Visitor<'de>, { Err(de::Error::invalid_type( Unexpected::UnitVariant, &"tuple variant", )) } fn struct_variant( self, _fields: &'static [&'static str], _visitor: V, ) -> Result where V: de::Visitor<'de>, { Err(de::Error::invalid_type( Unexpected::UnitVariant, &"struct variant", )) } }