Skip to main content

tonneau_build/codegen/
config.rs

1use std::collections::BTreeMap;
2
3use crate::types::ProtoPath;
4
5#[derive(Default)]
6pub(crate) struct AttributeConfig {
7    enum_configs: BTreeMap<ProtoPath, EnumConfig>,
8    message_configs: BTreeMap<ProtoPath, MessageConfig>,
9}
10
11impl AttributeConfig {
12    pub(crate) fn enum_configs(&self) -> impl Iterator<Item = (&ProtoPath, &EnumConfig)> {
13        self.enum_configs.iter()
14    }
15
16    pub(crate) fn message_configs(&self) -> impl Iterator<Item = (&ProtoPath, &MessageConfig)> {
17        self.message_configs.iter()
18    }
19
20    pub(crate) fn enum_config(&mut self, name: &ProtoPath) -> &mut EnumConfig {
21        self.enum_configs.entry(name.clone()).or_default()
22    }
23
24    pub(crate) fn message_config(&mut self, name: &ProtoPath) -> &mut MessageConfig {
25        self.message_configs.entry(name.clone()).or_default()
26    }
27}
28
29#[derive(Default)]
30pub(crate) struct EnumConfig {
31    container_attributes: Vec<syn::Attribute>,
32    variant_attributes: BTreeMap<String, Vec<syn::Attribute>>,
33}
34
35impl EnumConfig {
36    pub(crate) fn attributes(&self) -> impl Iterator<Item = &syn::Attribute> {
37        self.container_attributes.iter()
38    }
39
40    pub(crate) fn variant_attributes(
41        &self,
42        variant: &str,
43    ) -> impl Iterator<Item = &syn::Attribute> {
44        self.variant_attributes.get(variant).into_iter().flatten()
45    }
46
47    pub(crate) fn variants(&self) -> impl Iterator<Item = &str> {
48        self.variant_attributes.keys().map(String::as_str)
49    }
50
51    pub(crate) fn attribute(&mut self, attr: syn::Attribute) {
52        self.container_attributes.push(attr);
53    }
54
55    pub(crate) fn variant_attribute(&mut self, variant: &str, attr: syn::Attribute) {
56        self.variant_attributes
57            .entry(variant.to_owned())
58            .or_default()
59            .push(attr);
60    }
61}
62
63#[derive(Default)]
64pub(crate) struct MessageConfig {
65    pub container_attributes: Vec<syn::Attribute>,
66    pub field_attributes: BTreeMap<String, Vec<syn::Attribute>>,
67    pub oneof_attributes: BTreeMap<String, OneofConfig>,
68}
69
70impl MessageConfig {
71    pub(crate) fn attributes(&self) -> impl Iterator<Item = &syn::Attribute> {
72        self.container_attributes.iter()
73    }
74
75    pub(crate) fn field_attributes(&self, field: &str) -> impl Iterator<Item = &syn::Attribute> {
76        self.field_attributes.get(field).into_iter().flatten()
77    }
78
79    pub(crate) fn fields(&self) -> impl Iterator<Item = &str> {
80        self.field_attributes.keys().map(String::as_str)
81    }
82
83    pub(crate) fn oneof_configs(&self) -> impl Iterator<Item = (&str, &OneofConfig)> {
84        self.oneof_attributes
85            .iter()
86            .map(|(name, config)| (name.as_str(), config))
87    }
88
89    pub(crate) fn attribute(&mut self, attr: syn::Attribute) {
90        self.container_attributes.push(attr);
91    }
92
93    pub(crate) fn field_attribute(&mut self, field: &str, attr: syn::Attribute) {
94        self.field_attributes
95            .entry(field.to_owned())
96            .or_default()
97            .push(attr);
98    }
99
100    pub(crate) fn oneof_config(&mut self, oneof: &str) -> &mut OneofConfig {
101        self.oneof_attributes.entry(oneof.to_owned()).or_default()
102    }
103}
104
105#[derive(Default)]
106pub(crate) struct OneofConfig {
107    pub container_attributes: Vec<syn::Attribute>,
108    pub field_attributes: BTreeMap<String, Vec<syn::Attribute>>,
109}
110
111impl OneofConfig {
112    pub(crate) fn attributes(&self) -> impl Iterator<Item = &syn::Attribute> {
113        self.container_attributes.iter()
114    }
115
116    pub(crate) fn field_attributes(&self, field: &str) -> impl Iterator<Item = &syn::Attribute> {
117        self.field_attributes.get(field).into_iter().flatten()
118    }
119
120    pub(crate) fn fields(&self) -> impl Iterator<Item = &str> {
121        self.field_attributes.keys().map(String::as_str)
122    }
123
124    pub(crate) fn attribute(&mut self, attr: syn::Attribute) {
125        self.container_attributes.push(attr);
126    }
127
128    pub(crate) fn field_attribute(&mut self, field: &str, attr: syn::Attribute) {
129        self.field_attributes
130            .entry(field.to_owned())
131            .or_default()
132            .push(attr);
133    }
134}