weavatrix-refactor-plan 0.1.0

//! Compound sequence, map, and variant encoders for [`CanonicalSerializer`].

use super::key::KeySink;
use super::{CanonicalError, CanonicalSerializer};
use serde::{Serialize, ser};
use std::io;

pub(crate) struct SeqEncoder<'a, W: io::Write> {
    pub(super) serializer: &'a mut CanonicalSerializer<W>,
    pub(super) first: bool,
}

impl<W: io::Write> SeqEncoder<'_, W> {
    fn element<T>(&mut self, value: &T) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        if self.first {
            self.first = false;
        } else {
            self.serializer.emit(b",")?;
        }
        value.serialize(&mut *self.serializer)
    }
}

impl<W: io::Write> ser::SerializeSeq for SeqEncoder<'_, W> {
    type Ok = ();
    type Error = CanonicalError;

    fn serialize_element<T>(&mut self, value: &T) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        self.element(value)
    }

    fn end(self) -> Result<(), CanonicalError> {
        self.serializer.emit(b"]")
    }
}

impl<W: io::Write> ser::SerializeTuple for SeqEncoder<'_, W> {
    type Ok = ();
    type Error = CanonicalError;

    fn serialize_element<T>(&mut self, value: &T) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        self.element(value)
    }

    fn end(self) -> Result<(), CanonicalError> {
        ser::SerializeSeq::end(self)
    }
}

impl<W: io::Write> ser::SerializeTupleStruct for SeqEncoder<'_, W> {
    type Ok = ();
    type Error = CanonicalError;

    fn serialize_field<T>(&mut self, value: &T) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        self.element(value)
    }

    fn end(self) -> Result<(), CanonicalError> {
        ser::SerializeSeq::end(self)
    }
}

pub(crate) struct VariantSeqEncoder<'a, W: io::Write> {
    pub(super) serializer: &'a mut CanonicalSerializer<W>,
    pub(super) key_start: usize,
    pub(super) key_end: usize,
    pub(super) first: bool,
}

impl<W: io::Write> ser::SerializeTupleVariant for VariantSeqEncoder<'_, W> {
    type Ok = ();
    type Error = CanonicalError;

    fn serialize_field<T>(&mut self, value: &T) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        if self.first {
            self.first = false;
        } else {
            self.serializer.emit(b",")?;
        }
        value.serialize(&mut *self.serializer)
    }

    fn end(self) -> Result<(), CanonicalError> {
        self.serializer.emit(b"]")?;
        self.serializer.push_member(self.key_start, self.key_end);
        self.serializer.end_object()
    }
}

pub(crate) struct MapEncoder<'a, W: io::Write> {
    pub(super) serializer: &'a mut CanonicalSerializer<W>,
    pub(super) key_start: usize,
    pub(super) key_end: usize,
}

impl<W: io::Write> ser::SerializeMap for MapEncoder<'_, W> {
    type Ok = ();
    type Error = CanonicalError;

    fn serialize_key<T>(&mut self, key: &T) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        self.key_start = self.serializer.buf.len();
        key.serialize(KeySink::new(&mut *self.serializer))?;
        self.key_end = self.serializer.buf.len();
        Ok(())
    }

    fn serialize_value<T>(&mut self, value: &T) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        value.serialize(&mut *self.serializer)?;
        self.serializer.push_member(self.key_start, self.key_end);
        Ok(())
    }

    fn end(self) -> Result<(), CanonicalError> {
        self.serializer.end_object()
    }
}

impl<W: io::Write> ser::SerializeStruct for MapEncoder<'_, W> {
    type Ok = ();
    type Error = CanonicalError;

    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        let (key_start, key_end) = self.serializer.open_static_key(key);
        value.serialize(&mut *self.serializer)?;
        self.serializer.push_member(key_start, key_end);
        Ok(())
    }

    fn end(self) -> Result<(), CanonicalError> {
        self.serializer.end_object()
    }
}

pub(crate) struct VariantMapEncoder<'a, W: io::Write> {
    pub(super) serializer: &'a mut CanonicalSerializer<W>,
    pub(super) key_start: usize,
    pub(super) key_end: usize,
}

impl<W: io::Write> ser::SerializeStructVariant for VariantMapEncoder<'_, W> {
    type Ok = ();
    type Error = CanonicalError;

    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        let (key_start, key_end) = self.serializer.open_static_key(key);
        value.serialize(&mut *self.serializer)?;
        self.serializer.push_member(key_start, key_end);
        Ok(())
    }

    fn end(self) -> Result<(), CanonicalError> {
        self.serializer.end_object()?;
        self.serializer.push_member(self.key_start, self.key_end);
        self.serializer.end_object()
    }
}