simple_ringbuf 0.1.2

//! Serde implementations, here so they can be feature gated more easily

use crate::RingBuffer;
use serde::{
    de,
    de::{SeqAccess, Visitor},
    ser::SerializeSeq,
    Deserialize, Deserializer, Serialize, Serializer,
};

use std::{fmt, marker::PhantomData};

impl<T> Serialize for RingBuffer<T>
where
    T: Serialize,
{
    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut seq = ser.serialize_seq(Some(self.len + 1))?;
        seq.serialize_element(&self.cap)?;
        for el in self.iter().rev() {
            seq.serialize_element(el)?;
        }
        seq.end()
    }
}

#[derive(Deserialize)]
#[serde(field_identifier, rename_all = "lowercase")]
enum Field {
    Cap,
    Elements,
}

struct RingBufVisitor<T> {
    _pd: PhantomData<T>,
}

impl<T> RingBufVisitor<T> {
    fn new() -> Self {
        RingBufVisitor { _pd: PhantomData }
    }
}

impl<'de, T> Visitor<'de> for RingBufVisitor<T>
where
    T: Deserialize<'de>,
{
    type Value = RingBuffer<T>;

    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "struct RingBuffer")
    }

    fn visit_seq<V>(self, mut seq: V) -> Result<RingBuffer<T>, V::Error>
    where
        V: SeqAccess<'de>,
    {
        let cap = seq
            .next_element()?
            .ok_or_else(|| de::Error::invalid_length(0, &self))?;

        let mut me: RingBuffer<T> = RingBuffer::new(cap);

        while let Some(el) = seq.next_element()? {
            if me.len == cap {
                return Err(de::Error::invalid_length(me.len + 1, &self));
            }
            me.push(el);
        }

        Ok(me)
    }
}

impl<'a, T> Deserialize<'a> for RingBuffer<T>
where
    T: Deserialize<'a>,
{
    fn deserialize<D>(de: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'a>,
    {
        de.deserialize_seq(RingBufVisitor::new())
    }
}