weavatrix-refactor-plan 0.1.0

//! `serde::Serializer` surface for [`CanonicalSerializer`].

use super::compound::{MapEncoder, SeqEncoder, VariantMapEncoder, VariantSeqEncoder};
use super::{CanonicalError, CanonicalSerializer};
use serde::{Serialize, ser};
use std::io;

impl<'a, W: io::Write> ser::Serializer for &'a mut CanonicalSerializer<W> {
    type Ok = ();
    type Error = CanonicalError;
    type SerializeSeq = SeqEncoder<'a, W>;
    type SerializeTuple = SeqEncoder<'a, W>;
    type SerializeTupleStruct = SeqEncoder<'a, W>;
    type SerializeTupleVariant = VariantSeqEncoder<'a, W>;
    type SerializeMap = MapEncoder<'a, W>;
    type SerializeStruct = MapEncoder<'a, W>;
    type SerializeStructVariant = VariantMapEncoder<'a, W>;

    fn serialize_bool(self, value: bool) -> Result<(), CanonicalError> {
        self.emit(if value { b"true" } else { b"false" })
    }

    fn serialize_i8(self, value: i8) -> Result<(), CanonicalError> {
        self.emit_i64(i64::from(value))
    }

    fn serialize_i16(self, value: i16) -> Result<(), CanonicalError> {
        self.emit_i64(i64::from(value))
    }

    fn serialize_i32(self, value: i32) -> Result<(), CanonicalError> {
        self.emit_i64(i64::from(value))
    }

    fn serialize_i64(self, value: i64) -> Result<(), CanonicalError> {
        self.emit_i64(value)
    }

    fn serialize_i128(self, value: i128) -> Result<(), CanonicalError> {
        let value = i64::try_from(value).map_err(ser::Error::custom)?;
        self.emit_i64(value)
    }

    fn serialize_u8(self, value: u8) -> Result<(), CanonicalError> {
        self.emit_u64(u64::from(value))
    }

    fn serialize_u16(self, value: u16) -> Result<(), CanonicalError> {
        self.emit_u64(u64::from(value))
    }

    fn serialize_u32(self, value: u32) -> Result<(), CanonicalError> {
        self.emit_u64(u64::from(value))
    }

    fn serialize_u64(self, value: u64) -> Result<(), CanonicalError> {
        self.emit_u64(value)
    }

    fn serialize_u128(self, value: u128) -> Result<(), CanonicalError> {
        let value = u64::try_from(value).map_err(ser::Error::custom)?;
        self.emit_u64(value)
    }

    fn serialize_f32(self, value: f32) -> Result<(), CanonicalError> {
        self.emit_f64(f64::from(value))
    }

    fn serialize_f64(self, value: f64) -> Result<(), CanonicalError> {
        self.emit_f64(value)
    }

    fn serialize_char(self, value: char) -> Result<(), CanonicalError> {
        let mut buffer = [0_u8; 4];
        self.emit_string(value.encode_utf8(&mut buffer))
    }

    fn serialize_str(self, value: &str) -> Result<(), CanonicalError> {
        self.emit_string(value)
    }

    fn serialize_bytes(self, value: &[u8]) -> Result<(), CanonicalError> {
        let mut sequence = ser::Serializer::serialize_seq(&mut *self, Some(value.len()))?;
        for byte in value {
            ser::SerializeSeq::serialize_element(&mut sequence, byte)?;
        }
        ser::SerializeSeq::end(sequence)
    }

    fn serialize_none(self) -> Result<(), CanonicalError> {
        self.emit(b"null")
    }

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

    fn serialize_unit(self) -> Result<(), CanonicalError> {
        self.emit(b"null")
    }

    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), CanonicalError> {
        self.emit(b"null")
    }

    fn serialize_unit_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
    ) -> Result<(), CanonicalError> {
        self.emit_string(variant)
    }

    fn serialize_newtype_struct<T>(
        self,
        _name: &'static str,
        value: &T,
    ) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        value.serialize(self)
    }

    fn serialize_newtype_variant<T>(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        value: &T,
    ) -> Result<(), CanonicalError>
    where
        T: ?Sized + Serialize,
    {
        self.begin_object();
        let (key_start, key_end) = self.open_static_key(variant);
        value.serialize(&mut *self)?;
        self.push_member(key_start, key_end);
        self.end_object()
    }

    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, CanonicalError> {
        self.emit(b"[")?;
        Ok(SeqEncoder {
            serializer: self,
            first: true,
        })
    }

    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, CanonicalError> {
        ser::Serializer::serialize_seq(self, Some(len))
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        len: usize,
    ) -> Result<Self::SerializeTupleStruct, CanonicalError> {
        ser::Serializer::serialize_seq(self, Some(len))
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant, CanonicalError> {
        self.begin_object();
        let (key_start, key_end) = self.open_static_key(variant);
        self.emit(b"[")?;
        Ok(VariantSeqEncoder {
            serializer: self,
            key_start,
            key_end,
            first: true,
        })
    }

    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, CanonicalError> {
        self.begin_object();
        Ok(MapEncoder {
            serializer: self,
            key_start: 0,
            key_end: 0,
        })
    }

    fn serialize_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct, CanonicalError> {
        ser::Serializer::serialize_map(self, None)
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant, CanonicalError> {
        self.begin_object();
        let (key_start, key_end) = self.open_static_key(variant);
        self.begin_object();
        Ok(VariantMapEncoder {
            serializer: self,
            key_start,
            key_end,
        })
    }
}