use crate::deserialize::adapter::enum_deserializer::EnumDeserializer;
use crate::deserialize::adapter::map_deserializer::MapDeserializer;
use crate::deserialize::adapter::sequence_deserializer::SequenceDeserializer;
use crate::deserialize::Item;
use crate::DeserializeError;
use nom::error::ErrorKind;
use nom::Input;
use serde::de::{IntoDeserializer, Visitor};
use serde::forward_to_deserialize_any;
use std::cell::Cell;
use std::fmt::{Debug, Display};
use std::iter::Peekable;
use std::marker::PhantomData;
use crate::deserialize::adapter::iterators::ElementIterator;
pub struct Deserializer<I: Input, R: Iterator<Item = Item>> {
pub items: Cell<Option<Peekable<R>>>,
pub phantom_data: PhantomData<I>
}
impl<'de, 'a, I: Input + Debug + Display, R: Iterator<Item = Item>> Deserializer<I, R> {
pub fn new(items: R) -> Deserializer<I, R> {
Deserializer {
items: Cell::new(Some(items.peekable())),
phantom_data: PhantomData,
}
}
}
impl<'de, 'a, I: Input + Debug + Display> Deserializer<I, ElementIterator<Item>> {
pub fn from_item(item: Item) -> Deserializer<I, ElementIterator<Item>> {
Self::new(ElementIterator::new(item))
}
}
impl<'de, 'a, I: Input + Debug + Display, R: Iterator<Item = Item>> serde::Deserializer<'de> for &'a mut Deserializer<I, R> {
type Error = DeserializeError<I>;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::List(item) => visitor.visit_seq(SequenceDeserializer {
items: item.into_iter(),
phantom_data: PhantomData,
}),
Item::String(item) => visitor.visit_string(item),
Item::Bool(item) => visitor.visit_bool(item),
Item::Int(item) => visitor.visit_i64(item),
Item::UInt(item) => visitor.visit_u64(item),
Item::Float(item) => visitor.visit_f64(item),
Item::Null => visitor.visit_unit(),
Item::AnnotatedList(_) => Err(DeserializeError::UnexpectedNamedList)
}
}
}
}
forward_to_deserialize_any! {
bool string seq i64 u64 f64 unit ignored_any tuple tuple_struct
}
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::Int(item) => visitor.visit_i8(item.try_into().map_err(DeserializeError::map_to_conversion_error)?),
Item::UInt(item) => visitor.visit_u8(item.try_into().map_err(DeserializeError::map_to_conversion_error)?),
_ => Err(DeserializeError::ExpectedInteger)
}
}
}
}
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::Int(item) => visitor.visit_i16(item.try_into().map_err(DeserializeError::map_to_conversion_error)?),
Item::UInt(item) => visitor.visit_u16(item.try_into().map_err(DeserializeError::map_to_conversion_error)?),
_ => Err(DeserializeError::ExpectedInteger)
}
}
}
}
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::Int(item) => visitor.visit_i32(item.try_into().map_err(DeserializeError::map_to_conversion_error)?),
Item::UInt(item) => visitor.visit_u32(item.try_into().map_err(DeserializeError::map_to_conversion_error)?),
_ => Err(DeserializeError::ExpectedInteger)
}
}
}
}
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::UInt(item) => visitor.visit_u8(item.try_into().map_err(DeserializeError::map_to_conversion_error)?),
_ => Err(DeserializeError::ExpectedInteger)
}
}
}
}
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::UInt(item) => visitor.visit_u16(item.try_into().map_err(DeserializeError::map_to_conversion_error)?),
_ => Err(DeserializeError::ExpectedInteger)
}
}
}
}
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::UInt(item) => visitor.visit_u32(item.try_into().map_err(DeserializeError::map_to_conversion_error)?),
_ => Err(DeserializeError::ExpectedInteger)
}
}
}
}
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::Float(item) => visitor.visit_f32(item as f32),
_ => Err(DeserializeError::ExpectedInteger)
}
}
}
}
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::String(item) => {
match item.chars().last() {
None => Err(DeserializeError::EmptyString),
Some(c) => visitor.visit_char(c)
}
},
_ => Err(DeserializeError::ExpectedString)
}
}
}
}
fn deserialize_str<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
Err(DeserializeError::NotSupported)
}
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::List(item) => {
visitor.visit_bytes(&*item.iter().map(|item| {
match item {
Item::UInt(item) => (*item).try_into().map_err(DeserializeError::map_to_conversion_error),
_ => Err(DeserializeError::ExpectedInteger)
}
}).collect::<Result<Vec<_>, _>>()?)
},
_ => Err(DeserializeError::ExpectedList)
}
}
}
}
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::List(item) => {
visitor.visit_byte_buf(item.iter().map(|item| {
match item {
Item::UInt(item) => (*item).try_into().map_err(DeserializeError::map_to_conversion_error),
_ => Err(DeserializeError::ExpectedInteger)
}
}).collect::<Result<Vec<_>, _>>()?)
},
_ => Err(DeserializeError::ExpectedList)
}
}
}
}
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::List(_) => {
visitor.visit_some(&mut Deserializer::from_item(item))
},
Item::Null => visitor.visit_none(),
_ => Err(DeserializeError::ExpectedListOrNull)
}
}
}
}
fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::Null => visitor.visit_unit(),
_ => Err(DeserializeError::ExpectedListOrNull)
}
}
}
}
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_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
let iter_option = self.items.take();
match iter_option {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(mut iter) => match iter.peek() {
Some(item) => {
match item {
Item::List(_) => match iter.next() {
None => Err(DeserializeError::ExpectedList),
Some(item) => match item {
Item::List(item) => visitor.visit_map(MapDeserializer {
items: item.into_iter(),
next_value: Cell::new(None),
phantom_data: PhantomData,
}),
_ => Err(DeserializeError::ExpectedList)
}
},
_ => visitor.visit_map(MapDeserializer {
items: iter,
next_value: Cell::new(None),
phantom_data: PhantomData,
})
}
},
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
}
}
}
fn deserialize_struct<V>(self, _name: &'static str, _fields: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
self.deserialize_map(visitor)
}
fn deserialize_enum<V>(self, _name: &'static str, _variants: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
match self.items.get_mut() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(iter) => match iter.next() {
None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
Some(item) => match item {
Item::String(str) => {
visitor.visit_enum(str.as_str().into_deserializer())
}
Item::AnnotatedList(item) => visitor.visit_enum(
EnumDeserializer::new(item),
),
_ => Err(DeserializeError::ExpectedListOrString)
}
}
}
}
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>
{
self.deserialize_string(visitor)
}
fn is_human_readable(&self) -> bool {
true
}
}