Blocktree/crates/btserde/src/ser.rs

// SPDX-License-Identifier: AGPL-3.0-or-later
use serde::{
    ser::{
        self, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
        SerializeTupleStruct, SerializeTupleVariant,
    },
    Serialize,
};
use std::convert::TryFrom;
use std::io::Write;

use super::error::{Error, MapError, Result};

type Ok = ();

pub struct Serializer<W: Write> {
    output: W,
}

impl<W: Write> Serializer<W> {
    pub fn new(write: W) -> Serializer<W> {
        Serializer { output: write }
    }
}

pub fn to_vec<T: Serialize + ?Sized>(value: &T) -> Result<Vec<u8>> {
    let mut vec = Vec::new();
    write_to(value, &mut vec)?;
    Ok(vec)
}

pub fn write_to<T: Serialize + ?Sized, W: Write>(value: &T, write: W) -> Result<()> {
    let mut serializer = Serializer::new(write);
    value.serialize(&mut serializer)
}

fn try_convert(len: Option<usize>) -> Result<u32> {
    match len {
        Some(count) => {
            let length = u32::try_from(count).map_err(|_| Error::SequenceTooLong(count))?;
            Ok(length)
        }
        None => Err(Error::UnknownLength),
    }
}

fn convert_variant_index(index: u32) -> Result<u16> {
    u16::try_from(index).map_err(|_| Error::TooManyVariants(index))
}

impl<'a, T: Write> ser::Serializer for &'a mut Serializer<T> {
    type Ok = Ok;
    type Error = Error;
    type SerializeSeq = Self;
    type SerializeTuple = Self;
    type SerializeTupleVariant = Self;
    type SerializeTupleStruct = Self;
    type SerializeMap = Self;
    type SerializeStruct = Self;
    type SerializeStructVariant = Self;

    /// A bool is serialized by writing the byte 1 if true and 0 if false.
    #[allow(clippy::bool_to_int_with_if)]
    fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
        self.output
            .write_all(&[if v { 1 } else { 0 }])
            .map_error()?;
        Ok(())
    }

    /// The output format of a signed byte is two's complement, so we can just output
    /// Rust's binary representation.
    fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// The output format of a signed integer is two's complement, so we can just output
    /// Rust's binary representation in little endian order.
    fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// The output format of a signed integer is two's complement, so we can just output
    /// Rust's binary representation in little endian order.
    fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// The output format of a signed integer is two's complement, so we can just output
    /// Rust's binary representation in little endian order.
    fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// The output format of a signed integer is two's complement, so we can just output
    /// Rust's binary representation in little endian order.
    fn serialize_i128(self, v: i128) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// The given byte is written directly to the output.
    fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
        self.output.write_all(&[v]).map_error()?;
        Ok(())
    }

    /// The underlying bytes of the given unsigned integer are written to the output in little
    /// endian order.
    fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// The underlying bytes of the given unsigned integer are written to the output in little
    /// endian order.
    fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// The underlying bytes of the given unsigned integer are written to the output in little
    /// endian order.
    fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// The underlying bytes of the given unsigned integer are written to the output in little
    /// endian order.
    fn serialize_u128(self, v: u128) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// Since the output format is IEEE 754, we can just write the underlying bytes to the output
    /// in little endian order.
    fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// Since the output format is IEEE 754, we can just write the underlying bytes to the output
    /// in little endian order.
    fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
        self.output.write_all(&v.to_le_bytes()).map_error()?;
        Ok(())
    }

    /// The given char is cast to a u8 then written to the output.
    fn serialize_char(self, c: char) -> Result<Self::Ok> {
        self.output.write_all(&[c as u8]).map_error()?;
        Ok(())
    }

    /// A slice of bytes is stored by first writing its length (in LE order) and then the slice.
    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
        let len = v.len() as u32;
        self.output.write_all(&len.to_le_bytes()).map_error()?;
        self.output.write_all(v).map_error()?;
        Ok(())
    }

    /// A str is just serialized as a sequence of UTF8 bytes.
    fn serialize_str(self, v: &str) -> Result<Self::Ok> {
        self.serialize_bytes(v.as_bytes())
    }

    /// The none variant is stored by serializing false.
    fn serialize_none(self) -> Result<Self::Ok> {
        self.serialize_bool(false)?;
        Ok(())
    }

    /// A some variant is stored by serializing true before the of its value.
    fn serialize_some<U: ?Sized + Serialize>(self, value: &U) -> Result<Self::Ok> {
        self.serialize_bool(true)?;
        value.serialize(self)?;
        Ok(())
    }

    /// The unit is a type which can be represented with zero bytes, so we faithfully represent it
    /// as nothing.
    fn serialize_unit(self) -> Result<()> {
        Ok(())
    }

    /// Forwards to serialize_unit.
    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
        self.serialize_unit()
    }

    /// The index of the unit variant is written to the output.
    fn serialize_unit_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
    ) -> Result<Self::Ok> {
        let index = convert_variant_index(variant_index)?;
        self.serialize_u16(index)?;
        Ok(())
    }

    /// The value of the newtype struct is serialized and its name is ignored.
    fn serialize_newtype_struct<U: ?Sized + Serialize>(
        self,
        _name: &'static str,
        value: &U,
    ) -> Result<Self::Ok> {
        value.serialize(self)?;
        Ok(())
    }

    /// The index of the variant is serialized and written out, followed by the serialization of
    /// its value.
    fn serialize_newtype_variant<U: ?Sized + Serialize>(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        value: &U,
    ) -> Result<Self::Ok> {
        let index = convert_variant_index(variant_index)?;
        self.serialize_u16(index)?;
        value.serialize(self)?;
        Ok(())
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
        let length = try_convert(len)?;
        self.serialize_u32(length)?;
        Ok(self)
    }

    /// A tuple's length is not stored, only its entries.
    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
        Ok(self)
    }

    /// A tuple struct is serialized the same way as a tuple, its name is ignore.
    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct> {
        Ok(self)
    }

    /// The variant index is stored before the tuples values.
    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct> {
        let index = convert_variant_index(variant_index)?;
        self.serialize_u16(index)?;
        Ok(self)
    }

    /// The number of entries in the map is stored as a u32 prior to serializing the key value
    /// pairs in the map. If there are more entries than a u32 can represent, then an error is
    /// returned.
    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
        let length = try_convert(len)?;
        self.serialize_u32(length)?;
        Ok(self)
    }

    /// Since the members of a struct a known at compile time, no additional information is stored.
    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
        Ok(self)
    }

    /// The variant index is stored before the struct's members.
    fn serialize_struct_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        let index = convert_variant_index(variant_index)?;
        self.serialize_u16(index)?;
        Ok(self)
    }

    fn is_human_readable(&self) -> bool {
        false
    }
}

impl<'a, W: Write> SerializeSeq for &'a mut Serializer<W> {
    type Ok = Ok;
    type Error = Error;

    fn serialize_element<U: ?Sized + Serialize>(&mut self, value: &U) -> Result<Ok> {
        value.serialize(&mut **self)?;
        Ok(())
    }

    /// No marker is added to the end of the sequence because we know its length.
    fn end(self) -> Result<Ok> {
        Ok(())
    }
}

impl<'a, W: Write> SerializeTuple for &'a mut Serializer<W> {
    type Ok = Ok;
    type Error = Error;

    fn serialize_element<U: ?Sized + Serialize>(&mut self, value: &U) -> Result<Ok> {
        value.serialize(&mut **self)?;
        Ok(())
    }

    fn end(self) -> Result<Ok> {
        Ok(())
    }
}

impl<'a, W: Write> SerializeTupleStruct for &'a mut Serializer<W> {
    type Ok = Ok;
    type Error = Error;

    fn serialize_field<U: ?Sized + Serialize>(&mut self, value: &U) -> Result<Ok> {
        value.serialize(&mut **self)?;
        Ok(())
    }

    fn end(self) -> Result<Ok> {
        Ok(())
    }
}

impl<'a, W: Write> SerializeTupleVariant for &'a mut Serializer<W> {
    type Ok = Ok;
    type Error = Error;

    fn serialize_field<U: ?Sized + Serialize>(&mut self, value: &U) -> Result<Ok> {
        value.serialize(&mut **self)?;
        Ok(())
    }

    fn end(self) -> Result<Ok> {
        Ok(())
    }
}

impl<'a, W: Write> SerializeMap for &'a mut Serializer<W> {
    type Ok = Ok;
    type Error = Error;

    fn serialize_key<U: ?Sized + Serialize>(&mut self, key: &U) -> Result<Ok> {
        key.serialize(&mut **self)?;
        Ok(())
    }

    fn serialize_value<U: ?Sized + Serialize>(&mut self, value: &U) -> Result<Ok> {
        value.serialize(&mut **self)?;
        Ok(())
    }

    fn end(self) -> Result<Ok> {
        Ok(())
    }
}

impl<'a, W: Write> SerializeStruct for &'a mut Serializer<W> {
    type Ok = Ok;
    type Error = Error;

    fn serialize_field<U: ?Sized + Serialize>(
        &mut self,
        _key: &'static str,
        value: &U,
    ) -> Result<Ok> {
        value.serialize(&mut **self)?;
        Ok(())
    }

    fn end(self) -> Result<Ok> {
        Ok(())
    }
}

impl<'a, W: Write> SerializeStructVariant for &'a mut Serializer<W> {
    type Ok = Ok;
    type Error = Error;

    fn serialize_field<U: ?Sized + Serialize>(
        &mut self,
        _key: &'static str,
        value: &U,
    ) -> Result<Ok> {
        value.serialize(&mut **self)?;
        Ok(())
    }

    fn end(self) -> Result<Ok> {
        Ok(())
    }
}

#[cfg(test)]
mod test {
    // This is actually used in every method below.
    use super::Result;
    // This is also used in several methods below.
    use serde::Serialize;

    #[test]
    fn serialize_bool() -> Result<()> {
        {
            let buffer = super::to_vec(&true)?;
            assert_eq!(vec![1], buffer);
        }
        {
            let buffer = super::to_vec(&false)?;
            assert_eq!(vec![0], buffer);
        }
        Ok(())
    }

    #[test]
    fn serialize_i8() -> Result<()> {
        {
            let buffer = super::to_vec(&5i8)?;
            assert_eq!(vec![0b00000101], buffer);
        }
        {
            let value: i8 = -1;
            let buffer = super::to_vec(&value)?;
            assert_eq!(vec![0b11111111], buffer);
        }
        Ok(())
    }

    #[test]
    fn serialize_i16() -> Result<()> {
        {
            let buffer = super::to_vec(&1i16)?;
            assert_eq!(vec![0x01, 0x00], buffer);
        }
        {
            let value: i16 = -2;
            let buffer = super::to_vec(&value)?;
            assert_eq!(vec![0xFE, 0xFF], buffer);
        }
        Ok(())
    }

    #[test]
    fn serialize_i32() -> Result<()> {
        {
            let buffer = super::to_vec(&1i32)?;
            assert_eq!(vec![0x01, 0x00, 0x00, 0x00], buffer);
        }
        {
            let value: i32 = -2;
            let buffer = super::to_vec(&value)?;
            assert_eq!(vec![0xFE, 0xFF, 0xFF, 0xFF], buffer);
        }
        Ok(())
    }

    #[test]
    fn serialize_i64() -> Result<()> {
        {
            let buffer = super::to_vec(&1i64)?;
            assert_eq!(vec![0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], buffer);
        }
        {
            let value: i64 = -2;
            let buffer = super::to_vec(&value)?;
            assert_eq!(vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], buffer);
        }
        Ok(())
    }

    #[test]
    fn serialize_i128() -> Result<()> {
        {
            let buffer = super::to_vec(&1i128)?;
            assert_eq!(
                vec![
                    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                    0x00, 0x00, 0x00
                ],
                buffer
            );
        }
        {
            let value: i128 = -2;
            let buffer = super::to_vec(&value)?;
            assert_eq!(
                vec![
                    0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                    0xFF, 0xFF, 0xFF
                ],
                buffer
            );
        }
        Ok(())
    }

    #[test]
    fn serialize_u8() -> Result<()> {
        let value: u8 = 42;
        let buffer = super::to_vec(&value)?;
        assert_eq!(vec![value], buffer);
        Ok(())
    }

    #[test]
    fn serialize_u16() -> Result<()> {
        let buffer = super::to_vec(&1u16)?;
        assert_eq!(vec![0x01, 0x00], buffer);
        Ok(())
    }

    #[test]
    fn serialize_u32() -> Result<()> {
        let buffer = super::to_vec(&1u32)?;
        assert_eq!(vec![0x01, 0x00, 0x00, 0x00], buffer);
        Ok(())
    }

    #[test]
    fn serialize_u64() -> Result<()> {
        let buffer = super::to_vec(&1u64)?;
        assert_eq!(vec![0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], buffer);
        Ok(())
    }

    #[test]
    fn serialize_u128() -> Result<()> {
        let buffer = super::to_vec(&1u128)?;
        assert_eq!(
            vec![
                0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00
            ],
            buffer
        );
        Ok(())
    }

    #[test]
    fn serialize_f32() -> Result<()> {
        let buffer = super::to_vec(&0.15625f32)?;
        assert_eq!(vec![0x00, 0x00, 0x20, 0x3E], buffer);
        Ok(())
    }

    #[test]
    fn serialize_f64() -> Result<()> {
        let buffer = super::to_vec(&1f64)?;
        assert_eq!(vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F], buffer);
        Ok(())
    }

    #[test]
    fn serialize_char() -> Result<()> {
        let c: char = '*';
        let buffer = super::to_vec(&c)?;
        assert_eq!(vec![42], buffer);
        Ok(())
    }

    #[test]
    fn serialize_bytes() -> Result<()> {
        let mut bytes: Vec<u8> = vec![41, 23, 72, 61];
        let buffer = super::to_vec(bytes.as_slice())?;
        let length = bytes.len() as u32;
        let mut expected = length.to_le_bytes().to_vec();
        expected.append(&mut bytes);
        assert_eq!(expected, buffer);
        Ok(())
    }

    #[test]
    fn serialize_str() -> Result<()> {
        let message = "vapid 😑";
        let buffer = super::to_vec(message)?;
        assert_eq!(
            vec![10, 0, 0, 0, 118, 97, 112, 105, 100, 32, 240, 159, 152, 145],
            buffer
        );
        Ok(())
    }

    #[test]
    fn serialize_none() -> Result<()> {
        let none: Option<i32> = Option::None;
        let buffer = super::to_vec(&none)?;
        assert_eq!(vec![0], buffer);
        Ok(())
    }

    #[test]
    fn serialize_some() -> Result<()> {
        // Sometimes I use decimal, sometimes I use hex. So what, want to fight about it?
        let some: Option<i32> = Option::Some(0x02D8);
        let buffer = super::to_vec(&some)?;
        assert_eq!(vec![0x01, 0xD8, 0x02, 0x00, 0x00], buffer);
        Ok(())
    }

    #[test]
    fn serialize_unit() -> Result<()> {
        let buffer = super::to_vec(&())?;
        let expected: Vec<u8> = Vec::new();
        assert_eq!(expected, buffer);
        Ok(())
    }

    #[test]
    fn serialize_unit_struct() -> Result<()> {
        #[derive(Serialize)]
        struct UnitStruct;

        let test = UnitStruct {};
        let buffer = super::to_vec(&test)?;
        let expected: Vec<u8> = Vec::new();
        assert_eq!(expected, buffer);
        Ok(())
    }

    #[test]
    fn serialize_unit_variant() -> Result<()> {
        #[derive(Serialize)]
        #[allow(dead_code)]
        enum Matter {
            Condensate,
            Solid,
            Liquid,
            Gas,
            Plasma,
            Cat,
        }
        let test = Matter::Liquid;
        let buffer = super::to_vec(&test)?;
        assert_eq!(vec![0x02, 0x00], buffer);
        Ok(())
    }

    #[test]
    fn serialize_newtype_struct() -> Result<()> {
        #[derive(Serialize)]
        struct Score(u16);
        let score = Score(512);
        let buffer = super::to_vec(&score)?;
        assert_eq!(vec![0x00, 0x02], buffer);
        Ok(())
    }

    #[test]
    fn serialize_newtype_variant() -> Result<()> {
        #[derive(Serialize)]
        #[allow(dead_code)]
        enum Currency {
            Usd(i32),
            Btc(i32),
            Fil(i32),
            Eth(i32),
        }
        let value = Currency::Fil(1024);
        let buffer = super::to_vec(&value)?;
        let expected = vec![
            0x02, 0x00, // The variant index.
            0x00, 0x04, 0x00, 0x00, // The value contained within.
        ];
        assert_eq!(expected, buffer);
        Ok(())
    }

    #[test]
    fn serialize_unit_struct_variant() -> Result<()> {
        #[derive(Serialize)]
        #[allow(dead_code)]
        enum UnitStructVariant {
            Zeroth {},
            First {},
            Second {},
            Third {},
        }
        let test = UnitStructVariant::Second {};
        let buffer = super::to_vec(&test)?;
        assert_eq!(vec![2, 0], buffer);
        Ok(())
    }

    #[test]
    fn serialize_tuple() -> Result<()> {
        let value = (5u16, -1i8);
        let buffer = super::to_vec(&value)?;
        assert_eq!(vec![0x05, 0x00 /* == 5u16 */, 0xFF /* == -1i8 */], buffer);
        Ok(())
    }

    #[test]
    fn serialize_tuple_struct() -> Result<()> {
        #[derive(Serialize)]
        struct Contrived(i8, String);
        let value = Contrived(-2, "-2".to_string());
        let buffer = super::to_vec(&value)?;
        let expected = vec![
            0xFE, // The value -2.
            0x02, 0x00, 0x00, 0x00, // The length of the string.
            0x2D, 0x32, // The characters '-' and '2'.
        ];
        assert_eq!(expected, buffer);
        Ok(())
    }

    #[test]
    fn serialize_tuple_variant() -> Result<()> {
        #[derive(Serialize)]
        #[allow(dead_code)]
        enum ByteVector {
            Dim2(u8, u8),
            Dim3(u8, u8, u8),
        }
        let value = ByteVector::Dim3(5, 9, 42);
        let buffer = super::to_vec(&value)?;
        let expected = vec![
            0x01, 0x00, // The variant index.
            0x05, // The first entry.
            0x09, // The second entry.
            0x2A, // The last entry.
        ];
        assert_eq!(expected, buffer);
        Ok(())
    }

    #[test]
    fn serialize_map() -> Result<()> {
        use std::collections::HashMap;

        #[derive(PartialEq, Eq, Hash, Serialize)]
        enum Color {
            Red,
            Blue,
        }
        let mut map: HashMap<Color, u16> = HashMap::new();
        map.insert(Color::Red, 5);
        map.insert(Color::Blue, 256);
        let buffer = super::to_vec(&map)?;
        assert_eq!(12, buffer.len());
        assert_eq!(vec![0x02, 0x00, 0x00, 0x00], &buffer[..4]);

        // The entries could be output in an arbitrary order.
        let mut expected_map: HashMap<[u8; 2], [u8; 2]> = HashMap::new();
        expected_map.insert([0x00, 0x00], [0x05, 0x00]);
        expected_map.insert([0x01, 0x00], [0x00, 0x01]);
        assert_eq!(expected_map.get(&buffer[4..6]).unwrap(), &buffer[6..8]);
        assert_eq!(expected_map.get(&buffer[8..10]).unwrap(), &buffer[10..12]);
        Ok(())
    }

    #[test]
    fn serialize_struct() -> Result<()> {
        #[derive(Serialize)]
        struct Bag {
            name: &'static str,
            weight: u16,
            value: i8,
        }
        let value = Bag {
            name: "box",
            weight: 10,
            value: -1,
        };
        let buffer = super::to_vec(&value)?;
        let expected = vec![
            0x03, 0x00, 0x00, 0x00, 'b' as u8, 'o' as u8, 'x' as u8, // name
            0x0A, 0x00, // weight
            0xFF, // value
        ];
        assert_eq!(expected, buffer);
        Ok(())
    }

    #[test]
    fn serialize_struct_variant() -> Result<()> {
        #[derive(Serialize)]
        #[allow(dead_code)]
        enum Shape {
            Rectangle {
                upper_left_corner: (u16, u16),
                width: u16,
                height: u16,
            },
            Circle {
                center: (u16, u16),
                radius: u16,
            },
        }
        let value = Shape::Circle {
            center: (0x1D42, 0x9FE0),
            radius: 0xA100,
        };
        let buffer = super::to_vec(&value)?;
        let expected = vec![
            0x01, 0x00, // The variant index.
            0x42, 0x1D, 0xE0, 0x9F, // The center.
            0x00, 0xA1, // The radius.
        ];
        assert_eq!(expected, buffer);
        Ok(())
    }
}