minicbor-serde 0.7.1

use minicbor::encode::{self, Encoder, Write};
use serde::Serialize;
use serde::ser::{self, SerializeSeq, SerializeTuple, SerializeTupleStruct};
use serde::ser::{SerializeMap, SerializeStruct, SerializeStructVariant, SerializeTupleVariant};

use crate::{error::EncodeError, tag::{TAG_CONTAINER_IDENTIFIER, TAG_IDENTIFIER, NO_TAG_IDENTIFIER}};

#[cfg(feature = "alloc")]
use alloc::vec::Vec;

/// Serialise a type implementing [`serde::Serialize`] and return the encoded byte vector.
#[cfg(feature = "alloc")]
pub fn to_vec<T: Serialize>(val: T) -> Result<Vec<u8>, EncodeError<core::convert::Infallible>> {
    let mut v = Vec::new();
    val.serialize(&mut Serializer::new(&mut v))?;
    Ok(v)
}

/// An implementation of [`serde::Serializer`] using a [`minicbor::Encoder`].
#[derive(Debug, Clone)]
pub struct Serializer<W> {
    encoder: Encoder<W>,
    unit_as_null: bool
}

impl<W: Write> Serializer<W> {
    pub fn new(w: W) -> Self {
        Self::from(Encoder::new(w))
    }

    pub fn encoder(&self) -> &Encoder<W> {
        &self.encoder
    }

    pub fn encoder_mut(&mut self) -> &mut Encoder<W> {
        &mut self.encoder
    }

    pub fn serialize_unit_as_null(&mut self, enable: bool) -> &mut Self {
        self.unit_as_null = enable;
        self
    }

    pub fn into_encoder(self) -> Encoder<W> {
        self.encoder
    }
}

impl<W: Write> From<Encoder<W>> for Serializer<W> {
    fn from(e: Encoder<W>) -> Self {
        Self {
            encoder: e,
            unit_as_null: false
        }
    }
}

impl<'a, W: Write> ser::Serializer for &'a mut Serializer<W>
where
    <W as Write>::Error: core::error::Error + 'static
{
    type Ok = ();
    type Error = EncodeError<W::Error>;

    type SerializeSeq = SeqSerializer<'a, W>;
    type SerializeTuple = SeqSerializer<'a, W>;
    type SerializeTupleStruct = SeqSerializer<'a, W>;
    type SerializeTupleVariant = SeqSerializer<'a, W>;
    type SerializeMap = SeqSerializer<'a, W>;
    type SerializeStruct = SeqSerializer<'a, W>;
    type SerializeStructVariant = SeqSerializer<'a, W>;

    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        self.encoder.bool(v)?;
        Ok(())
    }

    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        self.encoder.i8(v)?;
        Ok(())
    }

    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        self.encoder.i16(v)?;
        Ok(())
    }

    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        self.encoder.i32(v)?;
        Ok(())
    }

    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        self.encoder.i64(v)?;
        Ok(())
    }

    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        self.encoder.u8(v)?;
        Ok(())
    }

    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        self.encoder.u16(v)?;
        Ok(())
    }

    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        self.encoder.u32(v)?;
        Ok(())
    }

    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        self.encoder.u64(v)?;
        Ok(())
    }

    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
        self.encoder.i128(v)?;
        Ok(())
    }

    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
        self.encoder.u128(v)?;
        Ok(())
    }

    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
        self.encoder.f32(v)?;
        Ok(())
    }

    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
        self.encoder.f64(v)?;
        Ok(())
    }

    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
        self.encoder.char(v)?;
        Ok(())
    }

    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
        self.encoder.str(v)?;
        Ok(())
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
        self.encoder.bytes(v)?;
        Ok(())
    }

    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        self.encoder.null()?;
        Ok(())
    }

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

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        if self.unit_as_null {
            self.encoder.null()?;
        } else {
            self.encoder.encode(())?;
        }
        Ok(())
    }

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

    fn serialize_unit_variant
        ( self
        , _name: &'static str
        , _index: u32
        , variant: &'static str
        ) -> Result<Self::Ok, Self::Error>
    {
        variant.serialize(self)
    }

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

    fn serialize_newtype_variant<T>
        ( self
        , name: &'static str
        , _index: u32
        , variant: &'static str
        , value: &T
        ) -> Result<Self::Ok, Self::Error>
    where
        T: Serialize + ?Sized
    {
        if name == TAG_CONTAINER_IDENTIFIER && variant == NO_TAG_IDENTIFIER {
            return value.serialize(self);
        }

        self.encoder.map(1)?.str(variant)?;
        value.serialize(self)
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        if let Some(n) = len {
            self.encoder.array(n as u64)?;
        } else {
            self.encoder.begin_array()?;
        }
        Ok(SeqSerializer { serializer: self, indefinite: len.is_none(), tagged: false })
    }

    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        self.encoder.array(len as u64)?;
        Ok(SeqSerializer { serializer: self, indefinite: false, tagged: false })
    }

    fn serialize_tuple_struct
        ( self
        , _name: &'static str
        , len: usize
        ) -> Result<Self::SerializeTupleStruct, Self::Error>
    {
        self.serialize_tuple(len)
    }

    fn serialize_tuple_variant
        ( self
        , name: &'static str
        , _index: u32
        , variant: &'static str
        , len: usize
        ) -> Result<Self::SerializeTupleVariant, Self::Error>
    {
        if name == TAG_CONTAINER_IDENTIFIER && variant == TAG_IDENTIFIER {
            return Ok(SeqSerializer { serializer: self, indefinite: false, tagged: true });
        }
        self.encoder.map(1)?.str(variant)?;
        self.serialize_tuple(len)
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        if let Some(n) = len {
            self.encoder.map(n as u64)?;
        } else {
            self.encoder.begin_map()?;
        }
        Ok(SeqSerializer { serializer: self, indefinite: len.is_none(), tagged: false })
    }

    fn serialize_struct
        ( self
        , _name: &'static str
        , len: usize
        ) -> Result<Self::SerializeStruct, Self::Error>
    {
        self.encoder.map(len as u64)?;
        Ok(SeqSerializer { serializer: self, indefinite: false, tagged: false })
    }

    fn serialize_struct_variant
        ( self
        , name: &'static str
        , _index: u32
        , variant: &'static str
        , len: usize
        ) -> Result<Self::SerializeStructVariant, Self::Error>
    {
        self.encoder.map(1)?.str(variant)?;
        self.serialize_struct(name, len)
    }

    #[cfg(not(feature = "alloc"))]
    fn collect_str<T: core::fmt::Display + ?Sized>(self, _val: &T) -> Result<Self::Ok, Self::Error> {
        Err(minicbor::encode::Error::message("collect_str requires features `alloc` or `std`").into())
    }

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

pub struct SeqSerializer<'a, W: 'a> {
    serializer: &'a mut Serializer<W>,
    indefinite: bool,
    tagged: bool,
}

impl<'a, W: Write> SerializeSeq for SeqSerializer<'a, W>
where
    <W as Write>::Error: core::error::Error + 'static
{
    type Ok = ();
    type Error = EncodeError<W::Error>;

    fn serialize_element<T: Serialize + ?Sized>(&mut self, x: &T) -> Result<(), Self::Error> {
        x.serialize(&mut *self.serializer)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        if self.indefinite {
            self.serializer.encoder.end()?;
        }
        Ok(())
    }
}

impl<'a, W: Write> SerializeTuple for SeqSerializer<'a, W>
where
    <W as Write>::Error: core::error::Error + 'static
{
    type Ok = ();
    type Error = EncodeError<W::Error>;

    fn serialize_element<T: Serialize + ?Sized>(&mut self, x: &T) -> Result<(), Self::Error> {
        x.serialize(&mut *self.serializer)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, W: Write> SerializeTupleStruct for SeqSerializer<'a, W>
where
    <W as Write>::Error: core::error::Error + 'static
{
    type Ok = ();
    type Error = EncodeError<W::Error>;

    fn serialize_field<T: Serialize + ?Sized>(&mut self, x: &T) -> Result<(), Self::Error> {
        x.serialize(&mut *self.serializer)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, W: Write> SerializeTupleVariant for SeqSerializer<'a, W>
where
    <W as Write>::Error: core::error::Error + 'static
{
    type Ok = ();
    type Error = EncodeError<W::Error>;

    fn serialize_field<T: Serialize + ?Sized>(&mut self, x: &T) -> Result<(), Self::Error> {
        if self.tagged {
            self.tagged = false;

            let tag = x.serialize(TagExtractor::<W>::new())?;
            self.serializer.encoder.tag(minicbor::data::Tag::new(tag))?;

            Ok(())
        } else {
            x.serialize(&mut *self.serializer)
        }
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, W: Write> SerializeMap for SeqSerializer<'a, W>
where
    <W as Write>::Error: core::error::Error + 'static
{
    type Ok = ();
    type Error = EncodeError<W::Error>;

    fn serialize_key<T: Serialize + ?Sized>(&mut self, k: &T) -> Result<(), Self::Error> {
        k.serialize(&mut *self.serializer)
    }

    fn serialize_value<T: Serialize + ?Sized>(&mut self, v: &T) -> Result<(), Self::Error> {
        v.serialize(&mut *self.serializer)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        if self.indefinite {
            self.serializer.encoder.end()?;
        }
        Ok(())
    }
}

impl<'a, W: Write> SerializeStruct for SeqSerializer<'a, W>
where
    <W as Write>::Error: core::error::Error + 'static
{
    type Ok = ();
    type Error = EncodeError<W::Error>;

    fn serialize_field<T>(&mut self, key: &'static str, val: &T) -> Result<(), Self::Error>
    where
        T: Serialize + ?Sized
    {
        key.serialize(&mut *self.serializer)?;
        val.serialize(&mut *self.serializer)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, W: Write> SerializeStructVariant for SeqSerializer<'a, W>
where
    <W as Write>::Error: core::error::Error + 'static
{
    type Ok = ();
    type Error = EncodeError<W::Error>;

    fn serialize_field<T>(&mut self, key: &'static str, val: &T) -> Result<(), Self::Error>
    where
        T: Serialize + ?Sized
    {
        key.serialize(&mut *self.serializer)?;
        val.serialize(&mut *self.serializer)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

/// Captures a tag from [`Serializer`] and passes it to [`Encoder::tag`]
struct TagExtractor<W: Write>(core::marker::PhantomData<W>);

impl<W: Write> TagExtractor<W>
where
    <W as Write>::Error: core::error::Error + 'static  {
    fn new() -> Self {
        TagExtractor(core::marker::PhantomData)
    }
}

impl<W: Write> ser::Serializer for TagExtractor<W>
where
    <W as Write>::Error: core::error::Error + 'static {

    type Ok = u64;
    type Error = EncodeError<W::Error>;

    type SerializeSeq = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeTuple = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeTupleStruct = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeTupleVariant = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeMap = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeStruct = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeStructVariant = ser::Impossible<Self::Ok, Self::Error>;

    fn serialize_u64(self, v: u64) -> Result<u64, Self::Error> {
        Ok(v)
    }

    fn serialize_u8(self, v: u8) -> Result<u64, Self::Error> {
        Ok(v.into())
    }

    fn serialize_u16(self, v: u16) -> Result<u64, Self::Error> {
        Ok(v.into())
    }

    fn serialize_u32(self, v: u32) -> Result<u64, Self::Error> {
        Ok(v.into())
    }

    fn serialize_bool(self, _: bool) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_i8(self, _: i8) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_i16(self, _: i16) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_i32(self, _: i32) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_i64(self, _: i64) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_f32(self, _: f32) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_f64(self, _: f64) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_char(self, _: char) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_str(self, _: &str) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_bytes(self, _: &[u8]) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_none(self) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_some<T: Serialize + ?Sized>(self, _: &T) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_unit(self) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_unit_struct(self, _: &'static str) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_newtype_struct<T: Serialize + ?Sized>(self, _: &'static str, _: &T) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_newtype_variant<T: Serialize + ?Sized>(self, _: &'static str, _: u32, _: &'static str, _: &T) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_tuple_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_tuple_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeStruct, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

    fn serialize_struct_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }

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

    #[cfg(not(feature = "alloc"))]
    fn collect_str<T: core::fmt::Display + ?Sized>(self, _: &T) -> Result<u64, Self::Error> {
        Err(EncodeError::from(encode::Error::message("expected u64")))
    }
}