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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
use super::*;
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
pub enum TypeInclude {
Full,
Minimal,
None,
}
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
pub struct TypeEntry {
pub def: TypeRow,
pub include: TypeInclude,
}
impl TypeEntry {
pub fn gen(&self, gen: &Gen) -> TokenStream {
if self.include == TypeInclude::None {
return TokenStream::new();
}
match &self.def {
TypeRow::TypeDef(def) => def.clone().with_generics().gen(gen, self.include),
TypeRow::MethodDef(def) => def.gen(gen),
TypeRow::Field(def) => def.gen(gen),
}
}
}
pub struct TypeTree {
pub namespace: &'static str,
pub types: BTreeMap<&'static str, TypeEntry>,
pub namespaces: BTreeMap<&'static str, TypeTree>,
pub include: bool,
}
impl TypeTree {
pub fn from_namespace(namespace: &'static str) -> Self {
Self {
namespace,
types: BTreeMap::new(),
namespaces: BTreeMap::new(),
include: false,
}
}
pub fn insert_namespace(&mut self, namespace: &'static str, pos: usize) -> &mut Self {
if let Some(next) = namespace[pos..].find('.') {
let next = pos + next;
self.namespaces
.entry(&namespace[pos..next])
.or_insert_with(|| Self::from_namespace(&namespace[..next]))
.insert_namespace(namespace, next + 1)
} else {
self.namespaces
.entry(&namespace[pos..])
.or_insert_with(|| Self::from_namespace(namespace))
}
}
pub fn insert_type(&mut self, name: &'static str, def: TypeRow) {
self.types.entry(name).or_insert_with(|| TypeEntry {
def,
include: TypeInclude::None,
});
}
pub fn namespaces(&self) -> Vec<&'static str> {
let mut namespaces = Vec::new();
for tree in self.namespaces.values() {
if !tree.types.is_empty() {
namespaces.push(tree.namespace)
}
namespaces.append(&mut tree.namespaces());
}
namespaces
}
pub fn get_type(&self, name: &str) -> Option<&TypeEntry> {
self.types.get(name)
}
pub fn get_type_mut(&mut self, name: &str) -> Option<&mut TypeEntry> {
self.types.get_mut(name)
}
pub fn get_namespace(&self, namespace: &str) -> Option<&Self> {
self.get_namespace_pos(namespace, 0)
}
fn get_namespace_pos(&self, namespace: &str, pos: usize) -> Option<&Self> {
if let Some(next) = namespace[pos..].find('.') {
let next = pos + next;
self.namespaces
.get(&namespace[pos..next])
.and_then(|child| child.get_namespace_pos(namespace, next + 1))
} else {
self.namespaces.get(&namespace[pos..])
}
}
pub fn get_namespace_mut(&mut self, namespace: &str) -> Option<&mut Self> {
self.get_namespace_mut_pos(namespace, 0)
}
fn get_namespace_mut_pos(&mut self, namespace: &str, pos: usize) -> Option<&mut Self> {
self.include = true;
if let Some(next) = namespace[pos..].find('.') {
let next = pos + next;
self.namespaces
.get_mut(&namespace[pos..next])
.and_then(|child| child.get_namespace_mut_pos(namespace, next + 1))
} else {
self.namespaces.get_mut(&namespace[pos..]).and_then(|ns| {
ns.include = true;
Some(ns)
})
}
}
pub fn gen<'a>(&'a self) -> impl Iterator<Item = TokenStream> + 'a {
let gen = Gen::Relative(self.namespace);
self.types
.iter()
.map(move |t| t.1.gen(&gen))
.chain(gen_namespaces(&self.namespaces))
}
}
fn gen_namespaces<'a>(
namespaces: &'a BTreeMap<&'static str, TypeTree>,
) -> impl Iterator<Item = TokenStream> + 'a {
namespaces.iter().map(move |(name, tree)| {
if tree.include {
let name = to_ident(name);
let tokens = tree.gen();
quote! {
#[allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
pub mod #name {
#(#tokens)*
}
}
} else {
TokenStream::new()
}
})
}