use std::slice;
use std::borrow::Cow;
use serde::de::{self, Visitor, IntoDeserializer};
use serde::de::value::SeqDeserializer;
use crate::value::{UniNode, Object};
use crate::serialize::error::{UniNodeSerError, Result};
use super::mapkey::MapKeyDeserializer;
fn visit_array<'de, T, I, V>(iter: I, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
I: Iterator<Item = T>,
T: IntoDeserializer<'de, UniNodeSerError>,
{
let mut deserializer = SeqDeserializer::new(iter);
let seq = visitor.visit_seq(&mut deserializer)?;
deserializer.end()?;
Ok(seq)
}
fn visit_object<'de, V>(object: &'de Object, visitor: V) -> Result<V::Value>
where
V: de::Visitor<'de>,
{
let len = object.len();
let mut deserializer = MapDeserializer::new(object);
let map = visitor.visit_map(&mut deserializer)?;
let remaining = deserializer.iter.len();
if remaining == 0 {
Ok(map)
} else {
Err(de::Error::invalid_length(len, &"fewer elements in map"))
}
}
impl<'de> de::Deserializer<'de> for &'de UniNode {
type Error = UniNodeSerError;
serde::forward_to_deserialize_any! {
i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 bool
}
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
where
V: de::Visitor<'de>,
{
match self {
UniNode::Null => visitor.visit_unit(),
UniNode::Boolean(v) => visitor.visit_bool(*v),
UniNode::Integer(v) => visitor.visit_i64(*v),
UniNode::UInteger(v) => visitor.visit_u64(*v),
UniNode::Float(v) => visitor.visit_f64(*v),
UniNode::String(v) => visitor.visit_borrowed_str(v),
UniNode::Bytes(v) => visitor.visit_bytes(v),
UniNode::Array(v) => visit_array(v.iter(), visitor),
UniNode::Object(v) => visit_object(v, visitor),
}
}
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
self.deserialize_str(visitor)
}
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
self.deserialize_str(visitor)
}
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
match self {
UniNode::String(v) => visitor.visit_borrowed_str(v),
_ => Err(self.invalid_type(&visitor)),
}
}
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
self.deserialize_str(visitor)
}
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
match self {
UniNode::String(v) => visitor.visit_borrowed_str(v),
UniNode::Array(v) => visit_array(v.iter(), visitor),
UniNode::Bytes(v) => visitor.visit_borrowed_bytes(v),
_ => Err(self.invalid_type(&visitor)),
}
}
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
self.deserialize_bytes(visitor)
}
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
match self {
UniNode::Null => visitor.visit_none(),
_ => visitor.visit_some(self),
}
}
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
match self {
UniNode::Null => visitor.visit_unit(),
_ => Err(self.invalid_type(&visitor)),
}
}
fn deserialize_unit_struct<V>(
self, _name: &'static str, visitor: V,
) -> Result<V::Value>
where
V: Visitor<'de>,
{
self.deserialize_unit(visitor)
}
fn deserialize_newtype_struct<V>(
self, _name: &'static str, visitor: V,
) -> Result<V::Value>
where
V: Visitor<'de>,
{
visitor.visit_newtype_struct(self)
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
match self {
UniNode::Array(v) => visit_array(v.iter(), visitor),
UniNode::Bytes(v) => {
let len = v.len();
let mut deserializer = BytesAccessor::new(v);
let seq = visitor.visit_seq(&mut deserializer)?;
let remaining = deserializer.iter.len();
if remaining == 0 {
Ok(seq)
} else {
Err(de::Error::invalid_length(
len,
&"fewer elements in array",
))
}
},
_ => visit_array(std::iter::once(self), visitor),
}
}
fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
self.deserialize_seq(visitor)
}
fn deserialize_tuple_struct<V>(
self, _name: &'static str, _len: usize, visitor: V,
) -> Result<V::Value>
where
V: Visitor<'de>,
{
self.deserialize_seq(visitor)
}
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
match self {
UniNode::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>
where
V: Visitor<'de>,
{
match self {
UniNode::Array(v) => visit_array(v.iter(), visitor),
UniNode::Object(v) => visit_object(v, visitor),
_ => Err(self.invalid_type(&visitor)),
}
}
fn deserialize_enum<V>(
self, _name: &str, _variants: &'static [&'static str], visitor: V,
) -> Result<V::Value>
where
V: Visitor<'de>,
{
let (variant, value) = match self {
UniNode::Object(value) => {
let mut iter = value.iter();
let (variant, value) = match iter.next() {
Some(v) => v,
None => {
return Err(de::Error::invalid_value(
de::Unexpected::Map,
&"map with a single key",
));
},
};
if iter.next().is_some() {
return Err(de::Error::invalid_value(
de::Unexpected::Map,
&"map with a single key",
));
}
(variant, Some(value))
},
UniNode::String(variant) => (variant, None),
other => return Err(other.invalid_type(&"string or map")),
};
visitor.visit_enum(EnumDeserializer { variant, value })
}
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
visitor.visit_unit()
}
}
impl<'de> IntoDeserializer<'de, UniNodeSerError> for &'de UniNode {
type Deserializer = &'de UniNode;
fn into_deserializer(self) -> Self::Deserializer {
self
}
}
struct BytesAccessor<'de> {
iter: slice::Iter<'de, u8>,
}
impl<'de> BytesAccessor<'de> {
fn new(slice: &'de [u8]) -> Self {
Self { iter: slice.iter() }
}
}
impl<'de> de::SeqAccess<'de> for BytesAccessor<'de> {
type Error = UniNodeSerError;
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
where
T: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some(value) => {
let deserializer = (*value).into_deserializer();
seed.deserialize(deserializer).map(Some)
},
_ => Ok(None),
}
}
fn size_hint(&self) -> Option<usize> {
match self.iter.size_hint() {
(lower, Some(upper)) if lower == upper => Some(upper),
_ => None,
}
}
}
struct MapDeserializer<'de> {
iter: <&'de Object as IntoIterator>::IntoIter,
value: Option<&'de UniNode>,
}
impl<'de> MapDeserializer<'de> {
fn new(map: &'de Object) -> Self {
Self {
iter: map.iter(),
value: None,
}
}
}
impl<'de> de::Deserializer<'de> for MapDeserializer<'de> {
type Error = UniNodeSerError;
serde::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 enum identifier ignored_any
}
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
visitor.visit_map(self)
}
}
impl<'de> de::MapAccess<'de> for MapDeserializer<'de> {
type Error = UniNodeSerError;
fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
where
T: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some((key, value)) => {
self.value = Some(value);
let key_de = MapKeyDeserializer::new(Cow::Borrowed(&**key));
seed.deserialize(key_de).map(Some)
},
None => Ok(None),
}
}
fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value>
where
T: de::DeserializeSeed<'de>,
{
match self.value.take() {
Some(value) => seed.deserialize(value),
None => Err(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,
}
}
}
struct EnumDeserializer<'de> {
variant: &'de str,
value: Option<&'de UniNode>,
}
impl<'de> de::EnumAccess<'de> for EnumDeserializer<'de> {
type Error = UniNodeSerError;
type Variant = VariantDeserializer<'de>;
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
where
V: de::DeserializeSeed<'de>,
{
let variant = self.variant.into_deserializer();
let visitor = VariantDeserializer { value: self.value };
seed.deserialize(variant).map(|v| (v, visitor))
}
}
struct VariantDeserializer<'de> {
value: Option<&'de UniNode>,
}
impl<'de> de::VariantAccess<'de> for VariantDeserializer<'de> {
type Error = UniNodeSerError;
fn unit_variant(self) -> Result<()> {
match self.value {
Some(value) => de::Deserialize::deserialize(value),
None => Ok(()),
}
}
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
where
T: de::DeserializeSeed<'de>,
{
match self.value {
Some(value) => seed.deserialize(value),
None => Err(de::Error::invalid_type(
de::Unexpected::UnitVariant,
&"newtype variant",
)),
}
}
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
where
V: Visitor<'de>,
{
match self.value {
Some(&UniNode::Array(ref v)) => de::Deserializer::deserialize_any(
SeqDeserializer::new(v.iter()),
visitor,
),
Some(other) => Err(other.invalid_type(&"tuple variant")),
None => Err(de::Error::invalid_type(
de::Unexpected::UnitVariant,
&"tuple variant",
)),
}
}
fn struct_variant<V>(
self, _fields: &'static [&'static str], visitor: V,
) -> Result<V::Value>
where
V: Visitor<'de>,
{
match self.value {
Some(&UniNode::Object(ref v)) => {
serde::Deserializer::deserialize_any(
MapDeserializer::new(v),
visitor,
)
},
Some(other) => Err(other.invalid_type(&"struct variant")),
None => Err(de::Error::invalid_type(
de::Unexpected::UnitVariant,
&"struct variant",
)),
}
}
}