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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use proc_macro2::TokenStream;
use quote::quote;
use syn::punctuated::Punctuated;
use syn::{DataEnum, DataStruct, Field, Fields, Type, Variant};

/// Helper struct for computing size expression for different types
pub struct SizeExpr;

impl SizeExpr {
    /// Calculates size expression for punctuated fields
    fn get_size_expr_for_punctuated_field<T>(fields: &Punctuated<Field, T>) -> TokenStream {
        if fields.is_empty() {
            return quote! { 0 };
        } else {
            let types = fields.iter().map(|field| &field.ty).collect::<Vec<&Type>>();
            quote! { #(<#types>::SIZE)+* }
        }
    }

    /// Calculates size expression for fields
    fn get_size_expr_for_fields(fields: &Fields) -> TokenStream {
        match fields {
            Fields::Unit => quote! { 0 },
            Fields::Named(named_fields) => {
                Self::get_size_expr_for_punctuated_field(&named_fields.named)
            }
            Fields::Unnamed(unnamed_fields) => {
                Self::get_size_expr_for_punctuated_field(&unnamed_fields.unnamed)
            }
        }
    }

    /// Calculates size expression for punctuated variants
    fn get_size_expr_for_punctuated_variant<T>(variants: &Punctuated<Variant, T>) -> TokenStream {
        if variants.is_empty() {
            return quote! { 0 };
        } else {
            let count_size_expr = Self::get_variant_count_size_expr(variants.len());
            let max_size_expr = Self::get_variant_max_size_expr(variants);

            quote! { #count_size_expr + #max_size_expr }
        }
    }

    /// Calculates size expression for variant
    #[allow(unused)]
    fn get_size_expr_for_variant(variant: &Variant) -> TokenStream {
        Self::get_size_expr_for_fields(&variant.fields)
    }

    /// Calculates size expression for number of variants (used for enums)
    fn get_variant_count_size_expr(len: usize) -> TokenStream {
        let size_type = Self::get_variant_count_size_type(len);
        quote! { <#size_type>::SIZE }
    }

    /// Calculates size expression for maximum sized variant
    fn get_variant_max_size_expr<T>(variants: &Punctuated<Variant, T>) -> TokenStream {
        let mut max_size_expr = quote! { 0 };

        for variant in variants {
            let variant_size_expr = Self::get_size_expr_for_variant(variant);
            max_size_expr = quote! { desse::max(#max_size_expr, #variant_size_expr) };
        }

        max_size_expr
    }

    /// Calculates size type for number of variants (used for enums)
    pub fn get_variant_count_size_type(len: usize) -> TokenStream {
        if len <= <u8>::max_value() as usize {
            quote! { u8 }
        } else if len <= <u16>::max_value() as usize {
            quote! { u16 }
        } else if len <= <u32>::max_value() as usize {
            quote! { u32 }
        } else if len <= <u64>::max_value() as usize {
            quote! { u64 }
        } else {
            quote! { u128 }
        }
    }

    /// Calculates size expression for [`DataStruct`](syn::DataStruct)
    pub fn for_struct(struct_data: &DataStruct) -> TokenStream {
        Self::get_size_expr_for_fields(&struct_data.fields)
    }

    /// Calculates size expression for [`DataEnum`](syn::DataEnum)
    pub fn for_enum(enum_data: &DataEnum) -> TokenStream {
        Self::get_size_expr_for_punctuated_variant(&enum_data.variants)
    }
}