deser-serde 0.10.1

//! Sinks that collect the events of a value for serde.
use std::borrow::Cow;

use deser_core::de::{LexicalRules, Sink, SinkHandle};
use deser_core::{Atom, Event, State};

use crate::de::{Single, ValueDe};
use crate::error::Error;

/// Receives the events of a value.
pub(crate) trait Push<'de>: Send {
    fn push(&mut self, event: Event<'de>, state: &State) -> Result<(), deser_core::Error>;
}

/// Turns the events of a map or sequence into a serde value.
pub(crate) trait Collector<'de, T>: Push<'de> {
    /// Begins the value with its first event.
    fn begin(&mut self, event: Event<'de>, state: &State) -> Result<(), deser_core::Error>;

    /// Returns the value after the last event.
    fn finish(&mut self) -> Result<T, deser_core::Error>;
}

/// Deserializes a serde value from a single atom.
///
/// Most serde values that are used with deser are atoms (like `Url` or
/// `IpAddr`), these are deserialized directly.
fn deserialize_atom<'de, T: serde::Deserialize<'de>>(
    atom: Atom<'de>,
    state: &State,
) -> Result<T, deser_core::Error> {
    let mut src = Single(Some(Event::Atom(atom)), LexicalRules::of(state));
    T::deserialize(ValueDe::new(&mut src)).map_err(Error::into_deser)
}

/// The sink for a serde value.
pub(crate) struct RootSink<'a, T, C> {
    out: &'a mut Option<T>,
    collector: C,
    end: Option<Event<'static>>,
}

impl<'a, T, C> RootSink<'a, T, C> {
    pub(crate) fn new(out: &'a mut Option<T>, collector: C) -> RootSink<'a, T, C> {
        RootSink {
            out,
            collector,
            end: None,
        }
    }
}

impl<'a, 'de, T, C> Sink<'de> for RootSink<'a, T, C>
where
    T: serde::Deserialize<'de> + Send,
    C: Collector<'de, T>,
{
    fn atom(&mut self, atom: Atom, state: &mut State) -> Result<(), deser_core::Error> {
        *self.out = Some(deserialize_atom(atom.to_static(), state)?);
        Ok(())
    }

    fn borrowed_atom(
        &mut self,
        atom: Atom<'de>,
        state: &mut State,
    ) -> Result<(), deser_core::Error> {
        *self.out = Some(deserialize_atom(atom, state)?);
        Ok(())
    }

    fn map(&mut self, state: &mut State) -> Result<(), deser_core::Error> {
        let event = Event::MapStart(state.container_shape());
        self.collector.begin(event, state)?;
        self.end = Some(Event::MapEnd);
        Ok(())
    }

    fn seq(&mut self, state: &mut State) -> Result<(), deser_core::Error> {
        let event = Event::SeqStart(state.container_shape());
        self.collector.begin(event, state)?;
        self.end = Some(Event::SeqEnd);
        Ok(())
    }

    fn next_key(&mut self, state: &mut State) -> Result<SinkHandle<'_, 'de>, deser_core::Error> {
        Ok(ChildSink::handle(&mut self.collector, state))
    }

    fn next_value(&mut self, state: &mut State) -> Result<SinkHandle<'_, 'de>, deser_core::Error> {
        Ok(ChildSink::handle(&mut self.collector, state))
    }

    fn __private_key_atom(
        &mut self,
        atom: Atom,
        state: &mut State,
    ) -> Result<(), deser_core::Error> {
        self.collector.push(Event::Atom(atom.to_static()), state)
    }

    fn __private_value_atom(
        &mut self,
        atom: Atom,
        state: &mut State,
    ) -> Result<(), deser_core::Error> {
        self.collector.push(Event::Atom(atom.to_static()), state)
    }

    fn __private_borrowed_key_atom(
        &mut self,
        atom: Atom<'de>,
        state: &mut State,
    ) -> Result<(), deser_core::Error> {
        self.collector.push(Event::Atom(atom), state)
    }

    fn __private_borrowed_value_atom(
        &mut self,
        atom: Atom<'de>,
        state: &mut State,
    ) -> Result<(), deser_core::Error> {
        self.collector.push(Event::Atom(atom), state)
    }

    fn finish(&mut self, state: &mut State) -> Result<(), deser_core::Error> {
        if let Some(end) = self.end.take() {
            self.collector.push(end, state)?;
            *self.out = Some(self.collector.finish()?);
        }
        Ok(())
    }

    fn expecting(&self) -> Cow<'_, str> {
        Cow::Borrowed("serde value")
    }
}

/// The sink for the values within a serde value.
struct ChildSink<'b, C: ?Sized> {
    collector: &'b mut C,
    end: Option<Event<'static>>,
}

impl<'b, C: ?Sized> ChildSink<'b, C> {
    fn handle<'de>(collector: &'b mut C, state: &mut State) -> SinkHandle<'b, 'de>
    where
        C: Push<'de>,
    {
        SinkHandle::arena(
            ChildSink {
                collector,
                end: None,
            },
            state,
        )
    }
}

impl<'b, 'de, C: Push<'de> + ?Sized> Sink<'de> for ChildSink<'b, C> {
    fn atom(&mut self, atom: Atom, state: &mut State) -> Result<(), deser_core::Error> {
        self.collector.push(Event::Atom(atom.to_static()), state)
    }

    fn borrowed_atom(
        &mut self,
        atom: Atom<'de>,
        state: &mut State,
    ) -> Result<(), deser_core::Error> {
        self.collector.push(Event::Atom(atom), state)
    }

    fn map(&mut self, state: &mut State) -> Result<(), deser_core::Error> {
        self.collector
            .push(Event::MapStart(state.container_shape()), state)?;
        self.end = Some(Event::MapEnd);
        Ok(())
    }

    fn seq(&mut self, state: &mut State) -> Result<(), deser_core::Error> {
        self.collector
            .push(Event::SeqStart(state.container_shape()), state)?;
        self.end = Some(Event::SeqEnd);
        Ok(())
    }

    fn next_key(&mut self, state: &mut State) -> Result<SinkHandle<'_, 'de>, deser_core::Error> {
        Ok(ChildSink::handle(&mut *self.collector, state))
    }

    fn next_value(&mut self, state: &mut State) -> Result<SinkHandle<'_, 'de>, deser_core::Error> {
        Ok(ChildSink::handle(&mut *self.collector, state))
    }

    fn __private_key_atom(
        &mut self,
        atom: Atom,
        state: &mut State,
    ) -> Result<(), deser_core::Error> {
        self.collector.push(Event::Atom(atom.to_static()), state)
    }

    fn __private_value_atom(
        &mut self,
        atom: Atom,
        state: &mut State,
    ) -> Result<(), deser_core::Error> {
        self.collector.push(Event::Atom(atom.to_static()), state)
    }

    fn __private_borrowed_key_atom(
        &mut self,
        atom: Atom<'de>,
        state: &mut State,
    ) -> Result<(), deser_core::Error> {
        self.collector.push(Event::Atom(atom), state)
    }

    fn __private_borrowed_value_atom(
        &mut self,
        atom: Atom<'de>,
        state: &mut State,
    ) -> Result<(), deser_core::Error> {
        self.collector.push(Event::Atom(atom), state)
    }

    fn finish(&mut self, state: &mut State) -> Result<(), deser_core::Error> {
        match self.end.take() {
            Some(end) => self.collector.push(end, state),
            None => Ok(()),
        }
    }

    fn expecting(&self) -> Cow<'_, str> {
        Cow::Borrowed("serde value")
    }
}