desse-derive 0.2.1

Ultra fast binary serialization and deserialization for types with size known at compile time.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

use proc_macro2::TokenStream;
use quote::quote;
use syn::Data::*;
use syn::DeriveInput;

use crate::expr::{DeserializeExpr, SerializeExpr};

/// Returns `Desse` trait implementation
pub fn get_desse_impl(input: DeriveInput) -> TokenStream {
    let name = input.ident;

    let (serialize, deserialize) = match &input.data {
        Struct(ref struct_data) => (
            SerializeExpr::for_struct(&name, &struct_data),
            DeserializeExpr::for_struct(&name, &struct_data),
        ),
        Enum(ref enum_data) => (
            SerializeExpr::for_enum(&name, &enum_data),
            DeserializeExpr::for_enum(&name, &enum_data),
        ),
        Union(_) => panic!("This macro cannot be used on unions!"),
    };

    quote! {
        #[automatically_derived]
        #[allow(unused_qualifications)]
        #[allow(unused)]
        impl Desse for #name {
            type Output = [u8; Self::SIZE];

            #[inline]
            fn serialize(&self) -> Self::Output {
                let mut bytes: Self::Output = [0; Self::SIZE];
                self.serialize_into(&mut bytes);
                bytes
            }

            #[inline]
            fn serialize_into(&self, bytes: &mut Self::Output) {
                #serialize
            }

            #[inline]
            fn deserialize_from(bytes: &Self::Output) -> Self {
                #deserialize
            }
        }
    }
}