| use crate::value::tagged::{self, TagStringVisitor}; |
| use crate::value::TaggedValue; |
| use crate::{number, Error, Mapping, Sequence, Value}; |
| use serde::de::value::{BorrowedStrDeserializer, StrDeserializer}; |
| use serde::de::{ |
| self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error as _, Expected, MapAccess, |
| SeqAccess, Unexpected, VariantAccess, Visitor, |
| }; |
| use serde::forward_to_deserialize_any; |
| use std::fmt; |
| use std::slice; |
| use std::vec; |
| |
| impl<'de> Deserialize<'de> for Value { |
| fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> |
| where |
| D: 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 YAML value") |
| } |
| |
| fn visit_bool<E>(self, b: bool) -> Result<Value, E> |
| where |
| E: de::Error, |
| { |
| Ok(Value::Bool(b)) |
| } |
| |
| fn visit_i64<E>(self, i: i64) -> Result<Value, E> |
| where |
| E: de::Error, |
| { |
| Ok(Value::Number(i.into())) |
| } |
| |
| fn visit_u64<E>(self, u: u64) -> Result<Value, E> |
| where |
| E: de::Error, |
| { |
| Ok(Value::Number(u.into())) |
| } |
| |
| fn visit_f64<E>(self, f: f64) -> Result<Value, E> |
| where |
| E: de::Error, |
| { |
| Ok(Value::Number(f.into())) |
| } |
| |
| fn visit_str<E>(self, s: &str) -> Result<Value, E> |
| where |
| E: de::Error, |
| { |
| Ok(Value::String(s.to_owned())) |
| } |
| |
| fn visit_string<E>(self, s: String) -> Result<Value, E> |
| where |
| E: de::Error, |
| { |
| Ok(Value::String(s)) |
| } |
| |
| fn visit_unit<E>(self) -> Result<Value, E> |
| where |
| E: de::Error, |
| { |
| Ok(Value::Null) |
| } |
| |
| fn visit_none<E>(self) -> Result<Value, E> |
| where |
| E: de::Error, |
| { |
| Ok(Value::Null) |
| } |
| |
| fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error> |
| where |
| D: Deserializer<'de>, |
| { |
| Deserialize::deserialize(deserializer) |
| } |
| |
| fn visit_seq<A>(self, data: A) -> Result<Value, A::Error> |
| where |
| A: SeqAccess<'de>, |
| { |
| let de = serde::de::value::SeqAccessDeserializer::new(data); |
| let sequence = Sequence::deserialize(de)?; |
| Ok(Value::Sequence(sequence)) |
| } |
| |
| fn visit_map<A>(self, data: A) -> Result<Value, A::Error> |
| where |
| A: MapAccess<'de>, |
| { |
| let de = serde::de::value::MapAccessDeserializer::new(data); |
| let mapping = Mapping::deserialize(de)?; |
| Ok(Value::Mapping(mapping)) |
| } |
| |
| fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error> |
| where |
| A: EnumAccess<'de>, |
| { |
| let (tag, contents) = data.variant_seed(TagStringVisitor)?; |
| let value = contents.newtype_variant()?; |
| Ok(Value::Tagged(Box::new(TaggedValue { tag, value }))) |
| } |
| } |
| |
| deserializer.deserialize_any(ValueVisitor) |
| } |
| } |
| |
| impl Value { |
| fn deserialize_number<'de, V>(&self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.untag_ref() { |
| Value::Number(n) => n.deserialize_any(visitor), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| } |
| |
| fn visit_sequence<'de, V>(sequence: Sequence, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let len = sequence.len(); |
| let mut deserializer = SeqDeserializer::new(sequence); |
| let seq = visitor.visit_seq(&mut deserializer)?; |
| let remaining = deserializer.iter.len(); |
| if remaining == 0 { |
| Ok(seq) |
| } else { |
| Err(Error::invalid_length(len, &"fewer elements in sequence")) |
| } |
| } |
| |
| fn visit_sequence_ref<'de, V>(sequence: &'de Sequence, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let len = sequence.len(); |
| let mut deserializer = SeqRefDeserializer::new(sequence); |
| let seq = visitor.visit_seq(&mut deserializer)?; |
| let remaining = deserializer.iter.len(); |
| if remaining == 0 { |
| Ok(seq) |
| } else { |
| Err(Error::invalid_length(len, &"fewer elements in sequence")) |
| } |
| } |
| |
| fn visit_mapping<'de, V>(mapping: Mapping, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let len = mapping.len(); |
| let mut deserializer = MapDeserializer::new(mapping); |
| let map = visitor.visit_map(&mut deserializer)?; |
| let remaining = deserializer.iter.len(); |
| if remaining == 0 { |
| Ok(map) |
| } else { |
| Err(Error::invalid_length(len, &"fewer elements in map")) |
| } |
| } |
| |
| fn visit_mapping_ref<'de, V>(mapping: &'de Mapping, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let len = mapping.len(); |
| let mut deserializer = MapRefDeserializer::new(mapping); |
| let map = visitor.visit_map(&mut deserializer)?; |
| let remaining = deserializer.iter.unwrap().len(); |
| if remaining == 0 { |
| Ok(map) |
| } else { |
| Err(Error::invalid_length(len, &"fewer elements in map")) |
| } |
| } |
| |
| impl<'de> Deserializer<'de> for 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(n) => n.deserialize_any(visitor), |
| Value::String(v) => visitor.visit_string(v), |
| Value::Sequence(v) => visit_sequence(v, visitor), |
| Value::Mapping(v) => visit_mapping(v, visitor), |
| Value::Tagged(tagged) => visitor.visit_enum(*tagged), |
| } |
| } |
| |
| fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.untag() { |
| Value::Bool(v) => visitor.visit_bool(v), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_string(visitor) |
| } |
| |
| fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_string(visitor) |
| } |
| |
| fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.untag() { |
| Value::String(v) => visitor.visit_string(v), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_byte_buf(visitor) |
| } |
| |
| fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.untag() { |
| Value::String(v) => visitor.visit_string(v), |
| Value::Sequence(v) => visit_sequence(v, visitor), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| |
| 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_unit<V>(self, visitor: V) -> Result<V::Value, 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, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_unit(visitor) |
| } |
| |
| 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_seq<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.untag() { |
| Value::Sequence(v) => visit_sequence(v, visitor), |
| Value::Null => visit_sequence(Sequence::new(), visitor), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, 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, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_seq(visitor) |
| } |
| |
| fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.untag() { |
| Value::Mapping(v) => visit_mapping(v, visitor), |
| Value::Null => visit_mapping(Mapping::new(), visitor), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_struct<V>( |
| self, |
| _name: &'static str, |
| _fields: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_map(visitor) |
| } |
| |
| fn deserialize_enum<V>( |
| self, |
| _name: &str, |
| _variants: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| let tag; |
| visitor.visit_enum(match self { |
| Value::Tagged(tagged) => EnumDeserializer { |
| tag: { |
| tag = tagged.tag.string; |
| tagged::nobang(&tag) |
| }, |
| value: Some(tagged.value), |
| }, |
| Value::String(variant) => EnumDeserializer { |
| tag: { |
| tag = variant; |
| &tag |
| }, |
| value: None, |
| }, |
| other => { |
| return Err(Error::invalid_type( |
| other.unexpected(), |
| &"a Value::Tagged enum", |
| )); |
| } |
| }) |
| } |
| |
| fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_string(visitor) |
| } |
| |
| fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| drop(self); |
| visitor.visit_unit() |
| } |
| } |
| |
| struct EnumDeserializer<'a> { |
| tag: &'a str, |
| value: Option<Value>, |
| } |
| |
| impl<'a, 'de> EnumAccess<'de> for EnumDeserializer<'a> { |
| type Error = Error; |
| type Variant = VariantDeserializer; |
| |
| fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error> |
| where |
| V: DeserializeSeed<'de>, |
| { |
| let str_de = StrDeserializer::<Error>::new(self.tag); |
| let variant = seed.deserialize(str_de)?; |
| let visitor = VariantDeserializer { value: self.value }; |
| Ok((variant, 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) => value.unit_variant(), |
| None => Ok(()), |
| } |
| } |
| |
| fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error> |
| where |
| T: DeserializeSeed<'de>, |
| { |
| match self.value { |
| Some(value) => value.newtype_variant_seed(seed), |
| None => Err(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) => value.tuple_variant(len, visitor), |
| None => Err(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) => value.struct_variant(fields, visitor), |
| None => Err(Error::invalid_type( |
| Unexpected::UnitVariant, |
| &"struct variant", |
| )), |
| } |
| } |
| } |
| |
| pub(crate) struct SeqDeserializer { |
| iter: vec::IntoIter<Value>, |
| } |
| |
| impl SeqDeserializer { |
| pub(crate) fn new(vec: Vec<Value>) -> Self { |
| SeqDeserializer { |
| iter: vec.into_iter(), |
| } |
| } |
| } |
| |
| impl<'de> 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 = visitor.visit_seq(&mut self)?; |
| let remaining = self.iter.len(); |
| if remaining == 0 { |
| Ok(ret) |
| } else { |
| Err(Error::invalid_length(len, &"fewer elements in sequence")) |
| } |
| } |
| } |
| |
| fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| drop(self); |
| visitor.visit_unit() |
| } |
| |
| 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 |
| } |
| } |
| |
| 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, |
| } |
| } |
| } |
| |
| pub(crate) struct MapDeserializer { |
| iter: <Mapping as IntoIterator>::IntoIter, |
| value: Option<Value>, |
| } |
| |
| impl MapDeserializer { |
| pub(crate) fn new(map: Mapping) -> 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); |
| seed.deserialize(key).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 => panic!("visit_value called before visit_key"), |
| } |
| } |
| |
| fn size_hint(&self) -> Option<usize> { |
| match self.iter.size_hint() { |
| (lower, Some(upper)) if lower == upper => Some(upper), |
| _ => None, |
| } |
| } |
| } |
| |
| impl<'de> 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) |
| } |
| |
| fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| drop(self); |
| visitor.visit_unit() |
| } |
| |
| 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 |
| } |
| } |
| |
| impl<'de> 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(n) => n.deserialize_any(visitor), |
| Value::String(v) => visitor.visit_borrowed_str(v), |
| Value::Sequence(v) => visit_sequence_ref(v, visitor), |
| Value::Mapping(v) => visit_mapping_ref(v, visitor), |
| Value::Tagged(tagged) => visitor.visit_enum(&**tagged), |
| } |
| } |
| |
| fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.untag_ref() { |
| Value::Bool(v) => visitor.visit_bool(*v), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_number(visitor) |
| } |
| |
| fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_string(visitor) |
| } |
| |
| fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.untag_ref() { |
| Value::String(v) => visitor.visit_borrowed_str(v), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_str(visitor) |
| } |
| |
| fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.untag_ref() { |
| Value::String(v) => visitor.visit_borrowed_str(v), |
| Value::Sequence(v) => visit_sequence_ref(v, visitor), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_bytes(visitor) |
| } |
| |
| 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_unit<V>(self, visitor: V) -> Result<V::Value, 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, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_unit(visitor) |
| } |
| |
| 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_seq<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| static EMPTY: Sequence = Sequence::new(); |
| match self.untag_ref() { |
| Value::Sequence(v) => visit_sequence_ref(v, visitor), |
| Value::Null => visit_sequence_ref(&EMPTY, visitor), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, 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, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_seq(visitor) |
| } |
| |
| fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| match self.untag_ref() { |
| Value::Mapping(v) => visit_mapping_ref(v, visitor), |
| Value::Null => visitor.visit_map(&mut MapRefDeserializer { |
| iter: None, |
| value: None, |
| }), |
| other => Err(other.invalid_type(&visitor)), |
| } |
| } |
| |
| fn deserialize_struct<V>( |
| self, |
| _name: &'static str, |
| _fields: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_map(visitor) |
| } |
| |
| fn deserialize_enum<V>( |
| self, |
| _name: &str, |
| _variants: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| visitor.visit_enum(match self { |
| Value::Tagged(tagged) => EnumRefDeserializer { |
| tag: tagged::nobang(&tagged.tag.string), |
| value: Some(&tagged.value), |
| }, |
| Value::String(variant) => EnumRefDeserializer { |
| tag: variant, |
| value: None, |
| }, |
| other => { |
| return Err(Error::invalid_type( |
| other.unexpected(), |
| &"a Value::Tagged enum", |
| )); |
| } |
| }) |
| } |
| |
| fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| self.deserialize_string(visitor) |
| } |
| |
| fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| visitor.visit_unit() |
| } |
| } |
| |
| struct EnumRefDeserializer<'de> { |
| tag: &'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 str_de = BorrowedStrDeserializer::<Error>::new(self.tag); |
| let variant = seed.deserialize(str_de)?; |
| let visitor = VariantRefDeserializer { value: self.value }; |
| Ok((variant, 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) => value.unit_variant(), |
| None => Ok(()), |
| } |
| } |
| |
| fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error> |
| where |
| T: DeserializeSeed<'de>, |
| { |
| match self.value { |
| Some(value) => value.newtype_variant_seed(seed), |
| None => Err(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) => value.tuple_variant(len, visitor), |
| None => Err(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) => value.struct_variant(fields, visitor), |
| None => Err(Error::invalid_type( |
| Unexpected::UnitVariant, |
| &"struct variant", |
| )), |
| } |
| } |
| } |
| |
| pub(crate) struct SeqRefDeserializer<'de> { |
| iter: slice::Iter<'de, Value>, |
| } |
| |
| impl<'de> SeqRefDeserializer<'de> { |
| pub(crate) fn new(slice: &'de [Value]) -> Self { |
| SeqRefDeserializer { iter: slice.iter() } |
| } |
| } |
| |
| impl<'de> 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 = visitor.visit_seq(&mut self)?; |
| let remaining = self.iter.len(); |
| if remaining == 0 { |
| Ok(ret) |
| } else { |
| Err(Error::invalid_length(len, &"fewer elements in sequence")) |
| } |
| } |
| } |
| |
| fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| visitor.visit_unit() |
| } |
| |
| 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 |
| } |
| } |
| |
| 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, |
| } |
| } |
| } |
| |
| pub(crate) struct MapRefDeserializer<'de> { |
| iter: Option<<&'de Mapping as IntoIterator>::IntoIter>, |
| value: Option<&'de Value>, |
| } |
| |
| impl<'de> MapRefDeserializer<'de> { |
| pub(crate) fn new(map: &'de Mapping) -> Self { |
| MapRefDeserializer { |
| iter: Some(map.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.as_mut().and_then(Iterator::next) { |
| Some((key, value)) => { |
| self.value = Some(value); |
| seed.deserialize(key).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 => panic!("visit_value called before visit_key"), |
| } |
| } |
| |
| fn size_hint(&self) -> Option<usize> { |
| match self.iter.as_ref()?.size_hint() { |
| (lower, Some(upper)) if lower == upper => Some(upper), |
| _ => None, |
| } |
| } |
| } |
| |
| impl<'de> 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) |
| } |
| |
| fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error> |
| where |
| V: Visitor<'de>, |
| { |
| visitor.visit_unit() |
| } |
| |
| 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 |
| } |
| } |
| |
| impl Value { |
| #[cold] |
| fn invalid_type<E>(&self, exp: &dyn Expected) -> E |
| where |
| E: de::Error, |
| { |
| de::Error::invalid_type(self.unexpected(), exp) |
| } |
| |
| #[cold] |
| pub(crate) fn unexpected(&self) -> Unexpected { |
| match self { |
| Value::Null => Unexpected::Unit, |
| Value::Bool(b) => Unexpected::Bool(*b), |
| Value::Number(n) => number::unexpected(n), |
| Value::String(s) => Unexpected::Str(s), |
| Value::Sequence(_) => Unexpected::Seq, |
| Value::Mapping(_) => Unexpected::Map, |
| Value::Tagged(_) => Unexpected::Enum, |
| } |
| } |
| } |