taikai 0.1.0

kaitai-like serialization and deserialization
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 heck::CamelCase;

pub struct Enum {
    pub id: String,
    pub scope: Vec<TokenStream>,
    pub pairs: Vec<(String, String)>
}

impl Enum {
    pub fn name(&self) -> TokenStream {
        syn::parse_str(&self.id.to_camel_case()).unwrap()
    }

    pub fn absolute_final_path(&self) -> TokenStream {
        let path = self.scope.iter();
        let name = self.name();

        quote! {
            #(#path::)* #name
        }
    }

    pub fn variant_name(&self, variant: &str) -> TokenStream {
        let variant = variant.to_camel_case();
        let variant: TokenStream = syn::parse_str(&variant).unwrap();
        let typ = self.name();
        quote!( #typ::#variant )
    }

    pub fn match_from_primitive(&self, read: TokenStream) -> TokenStream
    {
        let pairs: (Vec<TokenStream>, Vec<syn::Expr>);
        pairs = self.pairs.iter().map(|(key, value)| {
            let key = self.variant_name(key);
            let value: syn::Expr = syn::parse_str(&value).unwrap();

            (key, value)
        }).unzip();
        let (key, value) = pairs;

        quote!(
            {
                let _v = match #read {
                    #(#value => Ok(#key), )*
                    _ => Err(std::io::Error::new(std::io::ErrorKind::InvalidData,
                             "Invalid value for enum")),
                }?;

                Ok((_input, _v))
            }
        )
    }

    pub fn match_to_primitive(&self, variant: TokenStream) -> TokenStream
    {
        let pairs: (Vec<TokenStream>, Vec<syn::Expr>);
        pairs = self.pairs.iter().map(|(key, value)| {
            let key = self.variant_name(key);
            let value: syn::Expr = syn::parse_str(&value).unwrap();

            (key, value)
        }).unzip();
        let (key, value) = pairs;

        quote!(
            match #variant {
                #(#key => #value, )*
            }
        )
    }
}

impl std::hash::Hash for Enum {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        let scope = format!("{:?}", self.scope);

        self.id.hash(state);
        scope.hash(state);
    }
}

impl PartialEq for Enum {
    fn eq(&self, other: &Self) -> bool {
        let self_scope = format!("{:?}", self.scope);
        let other_scope = format!("{:?}", other.scope);

        self.id == other.id && self_scope == other_scope
    } 
}

impl Eq for Enum {}