buni-rs 1.0.0

use crate::deserialize::adapter::deserialize::Deserializer;
use crate::deserialize::Item;
use crate::DeserializeError;
use nom::Input;
use serde::de::{DeserializeSeed, MapAccess};
use std::cell::Cell;
use std::fmt::{Debug, Display};
use std::marker::PhantomData;
use nom::error::ErrorKind;

pub struct MapDeserializer<I: Input + Debug + Display, R: Iterator<Item = Item>> {
    pub items: R,
    pub next_value: Cell<Option<Vec<Item>>>,
    pub phantom_data: PhantomData<I>
}

impl<'de, I: Input + Debug + Display, R: Iterator<Item = Item>> MapAccess<'de> for MapDeserializer<I, R> {
    type Error = DeserializeError<I>;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
    where
        K: DeserializeSeed<'de>
    {
        match self.items.next() {
            None => Ok(None),
            Some(next) => {
                match next {
                    Item::AnnotatedList(item) => {
                        self.next_value.set(Some(item.1));
                        seed.deserialize(&mut Deserializer::from_item(*item.0)).map(Some)
                    }
                    _ => Err(DeserializeError::ExpectedAnnotatedList)
                }
            }
        }
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
    where
        V: DeserializeSeed<'de>
    {
        match self.next_value.take() {
            None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
            Some(list) =>
                if list.len() == 1 {
                    match list.into_iter().next() {
                        None => Err(DeserializeError::ParseError(None, ErrorKind::Eof)),
                        Some(item) => seed.deserialize(&mut Deserializer::from_item(item))
                    }
                } else {
                    seed.deserialize(&mut Deserializer::from_item(Item::List(list)))
                }
        }
    }
}