molecule-codegen 0.9.2

Code generator for molecule.
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
110
111
112
113
114
115
116
117
118
119
120
121

use proc_macro2 as m4;
use quote::quote;

use super::super::utilities::{builder_name, entity_name, field_name, func_name, reader_name};
use crate::ast::{self as ast, HasName};

pub(in super::super) trait ImplEntity: HasName {
    fn impl_entity_internal(&self) -> m4::TokenStream;

    fn impl_entity(&self) -> m4::TokenStream {
        let entity = entity_name(self.name());
        let entity_string = entity.to_string();
        let reader = reader_name(self.name());
        let builder = builder_name(self.name());
        let internal = self.impl_entity_internal();
        quote!(
            impl molecule::prelude::Entity for #entity {
                type Builder = #builder;
                const NAME: &'static str = #entity_string;
                fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
                    #entity(data)
                }
                fn as_bytes(&self) -> molecule::bytes::Bytes {
                    self.0.clone()
                }
                fn as_slice(&self) -> &[u8] {
                    &self.0[..]
                }
                fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
                    #reader::from_slice(slice).map(|reader| reader.to_entity())
                }
                fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
                    #reader::from_compatible_slice(slice).map(|reader| reader.to_entity())
                }
                fn new_builder() -> Self::Builder {
                    ::core::default::Default::default()
                }
                #internal
            }
        )
    }
}

impl ImplEntity for ast::Option_ {
    fn impl_entity_internal(&self) -> m4::TokenStream {
        quote!(
            fn as_builder(self) -> Self::Builder {
                Self::new_builder().set(self.to_opt())
            }
        )
    }
}

impl ImplEntity for ast::Union {
    fn impl_entity_internal(&self) -> m4::TokenStream {
        quote!(
            fn as_builder(self) -> Self::Builder {
                Self::new_builder().set(self.to_enum())
            }
        )
    }
}

impl ImplEntity for ast::Array {
    fn impl_entity_internal(&self) -> m4::TokenStream {
        let items = (0..self.item_count())
            .map(|idx| func_name(&format!("nth{}", idx)))
            .map(|func| quote!(self.#func()));
        quote!(
            fn as_builder(self) -> Self::Builder {
                Self::new_builder().set([ #( #items, )* ])
            }
        )
    }
}

impl ImplEntity for ast::Struct {
    fn impl_entity_internal(&self) -> m4::TokenStream {
        let fields = self.fields().iter().map(|f| field_name(f.name()));
        let fields_func = fields.clone();
        quote!(
            fn as_builder(self) -> Self::Builder {
                Self::new_builder()
                    #( .#fields(self.#fields_func()) )*
            }
        )
    }
}

impl ImplEntity for ast::FixVec {
    fn impl_entity_internal(&self) -> m4::TokenStream {
        quote!(
            fn as_builder(self) -> Self::Builder {
                Self::new_builder().extend(self.into_iter())
            }
        )
    }
}

impl ImplEntity for ast::DynVec {
    fn impl_entity_internal(&self) -> m4::TokenStream {
        quote!(
            fn as_builder(self) -> Self::Builder {
                Self::new_builder().extend(self.into_iter())
            }
        )
    }
}

impl ImplEntity for ast::Table {
    fn impl_entity_internal(&self) -> m4::TokenStream {
        let fields = self.fields().iter().map(|f| field_name(f.name()));
        let fields_func = fields.clone();
        quote!(
            fn as_builder(self) -> Self::Builder {
                Self::new_builder()
                    #( .#fields(self.#fields_func()) )*
            }
        )
    }
}