Macro impl_serialize::impl_serialize

macro_rules! impl_serialize {
    ($get_result:expr, [$($type:ident),+]) => { ... };
    ($get_result:expr, bool) => { ... };
    ($get_result:expr, i8) => { ... };
    ($get_result:expr, i16) => { ... };
    ($get_result:expr, i32) => { ... };
    ($get_result:expr, i64) => { ... };
    ($get_result:expr, u8) => { ... };
    ($get_result:expr, u16) => { ... };
    ($get_result:expr, u32) => { ... };
    ($get_result:expr, u64) => { ... };
    ($get_result:expr, f32) => { ... };
    ($get_result:expr, f64) => { ... };
    ($get_result:expr, char) => { ... };
    ($get_result:expr, str) => { ... };
    ($get_result:expr, bytes) => { ... };
    ($get_result:expr, none) => { ... };
    ($get_result:expr, unit) => { ... };
    ($get_result:expr, some) => { ... };
    ($get_result:expr, unit_struct) => { ... };
    ($get_result:expr, unit_variant) => { ... };
    ($get_result:expr, newtype_struct) => { ... };
    ($get_result:expr, newtype_variant) => { ... };
    ($get_result:expr, seq) => { ... };
    ($get_result:expr, tuple) => { ... };
    ($get_result:expr, tuple_struct) => { ... };
    ($get_result:expr, tuple_variant) => { ... };
    ($get_result:expr, map) => { ... };
    ($get_result:expr, struct) => { ... };
    ($get_result:expr, struct_variant) => { ... };
}

Macro for fast and easy implementing serialize methods in serde::Serializer trait.

Example

use impl_serialize::impl_serialize;
use serde::ser;
use thiserror::Error;

#[derive(Debug, Error)]
enum SerializationError {
    #[error("Other error")]
    OtherError,
    #[error("Cannot serialize value from {0}")]
    CannotSerializeFrom(String),
    #[error("Custom({0})")]
    Custom(String)
}

impl serde::ser::Error for SerializationError {
    fn custom<T>(msg:T) -> Self
    where T: std::fmt::Display
    {
        SerializationError::Custom(msg.to_string())
    }
}

struct MySerializer;

impl ser::Serializer for MySerializer {
    type Ok = ();
    type Error = SerializationError;

    type SerializeMap = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeSeq = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeStruct = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeStructVariant = 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>;

    //value_type is metavariable (&str) what represents any serializing value type.
    //for example, value_type will be "i8" when seializing i8 or "bytes" when &[u8] (bytes);

    //with value_type
    impl_serialize!(
        Err(SerializationError::CannotSerializeFrom(value_type.to_string())),
        bool
    );
    
    //without value_type
    impl_serialize!(
        Err(SerializationError::OtherError),
        char
    );

    //for many types
    impl_serialize!(
        Err(SerializationError::CannotSerializeFrom(value_type.to_string())),
        [
            bytes,
            i8, i16, i32, i64,
            u8, u16, u32, u64,
            f32, f64,
            str,
            none, some, unit,
            unit_struct, unit_variant,
            newtype_struct, newtype_variant,
            seq, map,
            tuple, tuple_struct, tuple_variant,
            struct, struct_variant
        ]
    );
}