use std::str;
use std::collections::{ btree_map, BTreeMap };
use serde::de::{
Deserialize, DeserializeSeed, Deserializer, IntoDeserializer,
Visitor,
Expected, Unexpected, Error as DeError,
SeqAccess, MapAccess, EnumAccess, VariantAccess,
};
use crate::error::Error;
use crate::value::Value;
pub fn from_value_ref<'a, T: Deserialize<'a>>(value: &'a Value) -> Result<T, Error> {
<T as Deserialize>::deserialize(value)
}
fn type_err<T>(value: &Value, expected: &dyn Expected) -> Result<T, Error> {
Err(Error::invalid_type(Unexpected::from(value), expected))
}
fn length_err<T>(actual_len: usize, expected: &dyn Expected) -> Result<T, Error> {
Err(Error::invalid_length(actual_len, expected))
}
fn missing_enum_assoc_data_err<T>(expected: &str) -> Result<T, Error> {
Err(Error::invalid_type(Unexpected::UnitVariant, &expected))
}
fn deserialize_number<'de, V>(value: &Value, visitor: V) -> Result<V::Value, Error>
where
V: Visitor<'de>,
{
#[allow(clippy::wildcard_enum_match_arm)]
match *value {
Value::Int(i) => visitor.visit_i64(i),
Value::Uint(u) => visitor.visit_u64(u),
Value::Float(f) => visitor.visit_f64(f.into()),
_ => type_err(value, &visitor),
}
}
fn deserialize_array<'de, V: Visitor<'de>>(
array: &'de [Value],
visitor: V,
) -> Result<V::Value, Error> {
visitor.visit_seq(SeqDeserializer {
iter: array.iter()
})
}
fn deserialize_map<'de, V: Visitor<'de>>(
map: &'de BTreeMap<Value, Value>,
visitor: V,
) -> Result<V::Value, Error> {
visitor.visit_map(MapDeserializer {
iter: map.iter(),
next_value: None,
})
}
#[derive(Debug, Clone)]
struct SeqDeserializer<'de> {
iter: std::slice::Iter<'de, Value>,
}
impl<'de> SeqAccess<'de> for SeqDeserializer<'de> {
type Error = Error;
fn next_element_seed<T: DeserializeSeed<'de>>(&mut self, seed: T) -> Result<Option<T::Value>, Error> {
match self.iter.next() {
Some(value) => seed.deserialize(value).map(Some),
None => Ok(None),
}
}
fn size_hint(&self) -> Option<usize> {
self.iter.len().into()
}
}
#[derive(Debug)]
struct MapDeserializer<'de> {
iter: btree_map::Iter<'de, Value, Value>,
next_value: Option<&'de Value>,
}
impl<'de> MapAccess<'de> for MapDeserializer<'de> {
type Error = Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
where
K: DeserializeSeed<'de>,
{
if self.next_value.is_none() {
match self.iter.next() {
Some((key, value)) => {
self.next_value = Some(value);
seed.deserialize(key).map(Some)
}
None => Ok(None)
}
} else {
Err(Error::custom("attempted to deserialize two keys in a row"))
}
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
where
V: DeserializeSeed<'de>,
{
#[allow(clippy::option_if_let_else)]
if let Some(value) = self.next_value.take() {
seed.deserialize(value)
} else {
Err(Error::custom("attempted to deserialize value without a key"))
}
}
#[allow(clippy::type_complexity)]
fn next_entry_seed<K, V>(
&mut self,
key_seed: K,
val_seed: V
) -> Result<Option<(K::Value, V::Value)>, Self::Error> where
K: DeserializeSeed<'de>,
V: DeserializeSeed<'de>,
{
if self.next_value.is_none() {
match self.iter.next() {
Some((k, v)) => {
let key = key_seed.deserialize(k)?;
let val = val_seed.deserialize(v)?;
Ok(Some((key, val)))
}
None => Ok(None)
}
} else {
Err(Error::custom("attempted to deserialize two keys in a row"))
}
}
fn size_hint(&self) -> Option<usize> {
self.iter.len().into()
}
}
#[derive(Debug, Clone)]
struct EnumDeserializer<'de> {
name: &'de str,
payload: Option<&'de Value>,
}
impl<'de> EnumAccess<'de> for EnumDeserializer<'de> {
type Error = Error;
type Variant = VariantDeserializer<'de>;
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
where
V: DeserializeSeed<'de>,
{
use serde::de::value::BorrowedStrDeserializer;
let de = BorrowedStrDeserializer::<Error>::new(self.name);
let variant = seed.deserialize(de)?;
let visitor = VariantDeserializer { payload: self.payload };
Ok((variant, visitor))
}
}
#[derive(Debug, Clone)]
struct VariantDeserializer<'de> {
payload: Option<&'de Value>,
}
impl<'de> VariantAccess<'de> for VariantDeserializer<'de> {
type Error = Error;
fn unit_variant(self) -> Result<(), Self::Error> {
match self.payload {
Some(value) => Deserialize::deserialize(value),
None => Ok(()),
}
}
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
where
T: DeserializeSeed<'de>,
{
match self.payload {
Some(value) => seed.deserialize(value),
None => missing_enum_assoc_data_err(
"newtype variant (missing associated data)"
),
}
}
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self.payload {
Some(&Value::Array(ref array)) => deserialize_array(array, visitor),
Some(other) => type_err(other, &"tuple variant"),
None => missing_enum_assoc_data_err(
"tuple variant (missing associated data)"
),
}
}
fn struct_variant<V>(
self,
_fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
match self.payload {
Some(&Value::Map(ref map)) => deserialize_map(map, visitor),
Some(other) => type_err(other, &"struct variant"),
None => missing_enum_assoc_data_err(
"struct variant (missing associated data)"
),
}
}
}
impl<'de> Deserializer<'de> for &'de Value {
type Error = Error;
fn is_human_readable(&self) -> bool {
true
}
fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
match *self {
Value::Null => visitor.visit_unit(),
Value::Opt(ref inner) => visitor.visit_some(&**inner),
Value::Bool(b) => visitor.visit_bool(b),
Value::Int(i) => visitor.visit_i64(i),
Value::Uint(u) => visitor.visit_u64(u),
Value::Float(f) => visitor.visit_f64(f.into()),
Value::String(ref s) => visitor.visit_borrowed_str(s),
Value::Blob(ref bytes) => visitor.visit_borrowed_bytes(bytes),
Value::Array(ref array) => deserialize_array(array, visitor),
Value::Map(ref map) => deserialize_map(map, visitor),
}
}
fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
#[allow(clippy::wildcard_enum_match_arm)]
match *self {
Value::Bool(b) => visitor.visit_bool(b),
_ => type_err(self, &visitor),
}
}
fn deserialize_i8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_i16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_i32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_i128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_u8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_u16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_u32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_u128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_f32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_f64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
deserialize_number(self, visitor)
}
fn deserialize_char<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
self.deserialize_str(visitor)
}
fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
#[allow(clippy::wildcard_enum_match_arm)]
match *self {
Value::String(ref s) => visitor.visit_borrowed_str(s),
Value::Blob(ref bytes) => {
let s = str::from_utf8(bytes)?;
visitor.visit_borrowed_str(s)
},
_ => type_err(self, &visitor),
}
}
fn deserialize_string<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
self.deserialize_str(visitor)
}
fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
#[allow(clippy::wildcard_enum_match_arm)]
match *self {
Value::Blob(ref bytes) => visitor.visit_borrowed_bytes(bytes),
Value::String(ref s) => visitor.visit_borrowed_str(s),
Value::Array(ref array) => deserialize_array(array, visitor), _ => type_err(self, &visitor),
}
}
fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
self.deserialize_bytes(visitor)
}
fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
#[allow(clippy::wildcard_enum_match_arm)]
match *self {
Value::Null => visitor.visit_none(),
Value::Opt(ref inner) => visitor.visit_some(&**inner),
_ => type_err(self, &visitor),
}
}
fn deserialize_unit<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
#[allow(clippy::wildcard_enum_match_arm)]
match *self {
Value::Null => visitor.visit_unit(),
_ => type_err(self, &visitor),
}
}
fn deserialize_unit_struct<V: Visitor<'de>>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error> {
self.deserialize_unit(visitor)
}
fn deserialize_newtype_struct<V: Visitor<'de>>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error> {
visitor.visit_newtype_struct(self)
}
fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
#[allow(clippy::wildcard_enum_match_arm)]
match *self {
Value::Array(ref array) => deserialize_array(array, visitor),
_ => type_err(self, &visitor),
}
}
fn deserialize_tuple<V: Visitor<'de>>(
self,
_len: usize,
visitor: V,
) -> Result<V::Value, Self::Error> {
self.deserialize_seq(visitor)
}
fn deserialize_tuple_struct<V: Visitor<'de>>(
self,
_name: &'static str,
len: usize,
visitor: V,
) -> Result<V::Value, Self::Error> {
self.deserialize_tuple(len, visitor)
}
fn deserialize_map<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
#[allow(clippy::wildcard_enum_match_arm)]
match *self {
Value::Map(ref map) => deserialize_map(map, visitor),
_ => type_err(self, &visitor),
}
}
fn deserialize_struct<V: Visitor<'de>>(
self,
_name: &'static str,
_fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error> {
self.deserialize_map(visitor)
}
fn deserialize_enum<V: Visitor<'de>>(
self,
_type_name: &'static str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error> {
#[allow(clippy::wildcard_enum_match_arm)]
let (name, payload) = match *self {
Value::String(ref s) => (s, None),
Value::Map(ref map) => if map.len() == 1 {
if let Some((key, val)) = map.iter().next() {
if let Value::String(ref s) = *key {
(s, Some(val))
} else {
return type_err(key, &"variant name as string");
}
} else {
return length_err(0, &"map.len() == 1 but empty iterator");
}
} else {
return length_err(map.len(), &"enum as single-key map");
},
_ => return type_err(self, &"enum as string or single-key map"),
};
visitor.visit_enum(EnumDeserializer { name, payload })
}
fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
self.deserialize_str(visitor)
}
fn deserialize_ignored_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
visitor.visit_unit()
}
}
impl<'de> IntoDeserializer<'de, Error> for &'de Value {
type Deserializer = Self;
fn into_deserializer(self) -> Self::Deserializer {
self
}
}