brec_macros 0.3.0

Code generator for brec. Implements the block and payload macros.
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

mod attr;

pub(crate) use attr::*;

use crate::*;
use brec_common::*;
use crc32fast::Hasher;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::{Ident, LitInt};

#[derive(Debug, Clone)]
pub struct Block {
    pub name: String,
    pub fields: Vec<Field>,
    pub attrs: BlockAttrs,
    pub derives: Derives,
    pub vis: Vis,
}

impl Block {
    pub fn new(
        name: String,
        fields: Vec<Field>,
        attrs: BlockAttrs,
        derives: Derives,
        vis: Vis,
    ) -> Self {
        Self {
            name,
            fields,
            attrs,
            derives,
            vis,
        }
    }
    pub fn sig(&self) -> TokenStream {
        // TODO: might be a conflict if do not consider a path
        let mut hasher = Hasher::new();
        let snap = format!(
            "{};{}",
            self.name,
            self.fields
                .iter()
                .map(|f| format!("{}:{}", f.name, f.ty))
                .collect::<Vec<String>>()
                .join(";")
        );
        hasher.update(snap.as_bytes());
        let sig = hasher.finalize().to_le_bytes();
        quote! { [#(#sig),*] }
    }
    pub fn sig_len(&self) -> TokenStream {
        let len_lit = LitInt::new(&BLOCK_SIG_LEN.to_string(), proc_macro2::Span::call_site());
        quote! { #len_lit }
    }
    pub fn size(&self) -> usize {
        let size = self
            .fields
            .iter()
            .map(|f| f.size())
            .collect::<Vec<usize>>()
            .iter()
            .sum::<usize>();
        if cfg!(feature = "resilient") {
            size + BLOCK_SIZE_FIELD_LEN
        } else {
            size
        }
    }
    pub fn const_sig_name(&self) -> Ident {
        format_ident!("{}", self.name.to_ascii_uppercase())
    }
    pub fn name(&self) -> Ident {
        format_ident!("{}", self.name)
    }
    pub fn referred_name(&self) -> Ident {
        format_ident!("{}Referred", self.name())
    }
    pub fn fullname(&self) -> Result<Ident, E> {
        self.attrs.fullname(self.name())
    }
    pub fn fullpath(&self) -> Result<TokenStream, E> {
        self.attrs.fullpath(self.name())
    }
    pub fn vis_token(&self) -> Result<TokenStream, E> {
        self.vis.as_token()
    }
}