parsely-impl 0.5.0

Macro-based struct serialization/deserialization
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use ::anyhow::anyhow;
use proc_macro2::TokenStream;
use quote::{quote, ToTokens};

use crate::{anyhow, get_crate_name, syn_helpers::MemberExts, ParselyReadReceiver, TypedFnArgList};

use super::{
    helpers::wrap_read_with_padding_handling, parsely_read_field_data::ParselyReadFieldData,
    parsely_read_variant_data::ParselyReadVariantData,
};

/// A struct which represents all information needed for generating a `ParselyRead` implementation
/// for a given struct.
#[derive(Debug)]
pub(crate) struct ParselyReadEnumData {
    pub(crate) ident: syn::Ident,
    pub(crate) required_context: TypedFnArgList,
    pub(crate) alignment: Option<usize>,
    pub(crate) key_type: syn::Type,
    pub(crate) variants: Vec<ParselyReadVariantData>,
}

impl TryFrom<ParselyReadReceiver> for ParselyReadEnumData {
    type Error = anyhow::Error;

    fn try_from(value: ParselyReadReceiver) -> Result<Self, Self::Error> {
        let key_type = value
            .key_type
            .ok_or(anyhow!("'key_type' attribute is required on enums"))?;
        let variants = value
            .data
            .take_enum()
            .ok_or(anyhow!("Not an enum"))?
            .into_iter()
            .map(|v| {
                let data_fields = v
                    .fields
                    .into_iter()
                    .enumerate()
                    .map(|(field_index, field)| {
                        let ident = syn::Member::from_ident_or_index(
                            field.ident.as_ref(),
                            field_index as u32,
                        );
                        ParselyReadFieldData::from_receiver(ident, field)
                    })
                    .collect::<Vec<_>>();
                ParselyReadVariantData {
                    enum_name: value.ident.clone(),
                    ident: v.ident,
                    id: v.id,
                    discriminant: v.discriminant,
                    fields: data_fields,
                }
            })
            .collect::<Vec<_>>();

        Ok(ParselyReadEnumData {
            ident: value.ident,
            key_type,
            required_context: value.required_context,
            alignment: value.alignment,
            variants,
        })
    }
}

impl ToTokens for ParselyReadEnumData {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let crate_name = get_crate_name();
        let enum_name = &self.ident;
        let enum_name_string = enum_name.to_string();
        let (context_variables, context_types) =
            (self.required_context.names(), self.required_context.types());

        let match_type = &self.key_type;

        let match_arms = &self.variants;
        let body = quote! {
            let match_value = <#match_type as ::#crate_name::ParselyRead<_>>::read::<T>(buf, ()).with_context(|| format!("Tag for enum '{}'", #enum_name_string))?;
            match match_value {
                #(#match_arms)*
                _ => ParselyResult::<_>::Err(anyhow!("No arms matched value")),
            }
        };

        let body = if let Some(alignment) = self.alignment {
            wrap_read_with_padding_handling(
                &syn::Member::Named(self.ident.clone()),
                alignment,
                body,
            )
        } else {
            body
        };

        // TODO: should the enum id be able to be read from the buffer?  we could have it support
        // being an expr that returns a result or not, like other things.  so it could be
        // "buf.get_u8()"
        tokens.extend(quote! {
            impl<B: BitBuf> ::#crate_name::ParselyRead<B> for #enum_name {
                type Ctx = (#(#context_types,)*);
                fn read<T: ::#crate_name::ByteOrder>(buf: &mut B, (#(#context_variables,)*): (#(#context_types,)*)) -> ::#crate_name::ParselyResult<Self> {
                    #body
                }
            }
        });
    }
}