1 use super::*;
2 
3 pub trait Decode {
decode(file: &'static File, code: u32) -> Self4     fn decode(file: &'static File, code: u32) -> Self;
5 }
6 
7 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
8 pub enum TypeDefOrRef {
9     TypeDef(tables::TypeDef),
10     TypeRef(tables::TypeRef),
11     TypeSpec(tables::TypeSpec),
12 }
13 
14 impl Decode for TypeDefOrRef {
decode(file: &'static File, code: u32) -> Self15     fn decode(file: &'static File, code: u32) -> Self {
16         let code = (code & ((1 << 2) - 1), (code >> 2) - 1);
17         match code.0 {
18             0 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
19             1 => Self::TypeRef(tables::TypeRef(Row::new(code.1, TableIndex::TypeRef, file))),
20             2 => Self::TypeSpec(tables::TypeSpec(Row::new(
21                 code.1,
22                 TableIndex::TypeSpec,
23                 file,
24             ))),
25             _ => panic!("type_code"),
26         }
27     }
28 }
29 
30 impl TypeDefOrRef {
encode(&self) -> u3231     pub fn encode(&self) -> u32 {
32         match self {
33             Self::TypeDef(value) => ((value.0.row + 1) << 2) | 0,
34             Self::TypeRef(value) => ((value.0.row + 1) << 2) | 1,
35             Self::TypeSpec(value) => ((value.0.row + 1) << 2) | 2,
36         }
37     }
38 }
39 
40 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
41 pub enum TypeOrMethodDef {
42     TypeDef(tables::TypeDef),
43     MethodDef(tables::MethodDef),
44 }
45 
46 impl Decode for TypeOrMethodDef {
decode(file: &'static File, code: u32) -> Self47     fn decode(file: &'static File, code: u32) -> Self {
48         let code = (code & ((1 << 1) - 1), (code >> 1) - 1);
49         match code.0 {
50             0 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
51             1 => Self::MethodDef(tables::MethodDef(Row::new(
52                 code.1,
53                 TableIndex::MethodDef,
54                 file,
55             ))),
56             _ => panic!("type_code"),
57         }
58     }
59 }
60 
61 impl TypeOrMethodDef {
encode(&self) -> u3262     pub fn encode(&self) -> u32 {
63         match self {
64             Self::TypeDef(value) => ((value.0.row + 1) << 1) | 0,
65             Self::MethodDef(value) => ((value.0.row + 1) << 1) | 1,
66         }
67     }
68 }
69 
70 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
71 pub enum HasAttribute {
72     MethodDef(tables::MethodDef),
73     Field(tables::Field),
74     TypeRef(tables::TypeRef),
75     TypeDef(tables::TypeDef),
76     Param(tables::Param),
77     InterfaceImpl(tables::InterfaceImpl),
78     MemberRef(tables::MemberRef),
79     TypeSpec(tables::TypeSpec),
80     GenericParam(tables::GenericParam),
81 }
82 
83 impl Decode for HasAttribute {
decode(file: &'static File, code: u32) -> Self84     fn decode(file: &'static File, code: u32) -> Self {
85         let code = (code & ((1 << 5) - 1), (code >> 5) - 1);
86         match code.0 {
87             0 => Self::MethodDef(tables::MethodDef(Row::new(
88                 code.1,
89                 TableIndex::MethodDef,
90                 file,
91             ))),
92             1 => Self::Field(tables::Field(Row::new(code.1, TableIndex::Field, file))),
93             2 => Self::TypeRef(tables::TypeRef(Row::new(code.1, TableIndex::TypeRef, file))),
94             3 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
95             4 => Self::Param(tables::Param(Row::new(code.1, TableIndex::Param, file))),
96             5 => Self::InterfaceImpl(tables::InterfaceImpl(Row::new(
97                 code.1,
98                 TableIndex::InterfaceImpl,
99                 file,
100             ))),
101             6 => Self::MemberRef(tables::MemberRef(Row::new(
102                 code.1,
103                 TableIndex::MemberRef,
104                 file,
105             ))),
106             13 => Self::TypeSpec(tables::TypeSpec(Row::new(
107                 code.1,
108                 TableIndex::TypeSpec,
109                 file,
110             ))),
111             19 => Self::GenericParam(tables::GenericParam(Row::new(
112                 code.1,
113                 TableIndex::GenericParam,
114                 file,
115             ))),
116             _ => panic!("type_code"),
117         }
118     }
119 }
120 
121 impl HasAttribute {
encode(&self) -> u32122     pub fn encode(&self) -> u32 {
123         match self {
124             Self::MethodDef(value) => ((value.0.row + 1) << 5) | 0,
125             Self::Field(value) => ((value.0.row + 1) << 5) | 1,
126             Self::TypeRef(value) => ((value.0.row + 1) << 5) | 2,
127             Self::TypeDef(value) => ((value.0.row + 1) << 5) | 3,
128             Self::Param(value) => ((value.0.row + 1) << 5) | 4,
129             Self::InterfaceImpl(value) => ((value.0.row + 1) << 5) | 5,
130             Self::MemberRef(value) => ((value.0.row + 1) << 5) | 6,
131             Self::TypeSpec(value) => ((value.0.row + 1) << 5) | 13,
132             Self::GenericParam(value) => ((value.0.row + 1) << 5) | 19,
133         }
134     }
135 }
136 
137 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
138 pub enum MemberRefParent {
139     TypeDef(tables::TypeDef),
140     TypeRef(tables::TypeRef),
141     MethodDef(tables::MethodDef),
142     TypeSpec(tables::TypeSpec),
143 }
144 
145 impl Decode for MemberRefParent {
decode(file: &'static File, code: u32) -> Self146     fn decode(file: &'static File, code: u32) -> Self {
147         let code = (code & ((1 << 3) - 1), (code >> 3) - 1);
148         match code.0 {
149             0 => Self::TypeDef(tables::TypeDef(Row::new(code.1, TableIndex::TypeDef, file))),
150             1 => Self::TypeRef(tables::TypeRef(Row::new(code.1, TableIndex::TypeRef, file))),
151             3 => Self::MethodDef(tables::MethodDef(Row::new(
152                 code.1,
153                 TableIndex::MethodDef,
154                 file,
155             ))),
156             4 => Self::TypeSpec(tables::TypeSpec(Row::new(
157                 code.1,
158                 TableIndex::TypeSpec,
159                 file,
160             ))),
161             _ => panic!("type_code"),
162         }
163     }
164 }
165 
166 impl MemberRefParent {
encode(&self) -> u32167     pub fn encode(&self) -> u32 {
168         match self {
169             Self::TypeDef(value) => ((value.0.row + 1) << 3) | 0,
170             Self::TypeRef(value) => ((value.0.row + 1) << 3) | 1,
171             Self::MethodDef(value) => ((value.0.row + 1) << 3) | 3,
172             Self::TypeSpec(value) => ((value.0.row + 1) << 3) | 4,
173         }
174     }
175 }
176 
177 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
178 pub enum HasConstant {
179     Field(tables::Field),
180     Param(tables::Param),
181 }
182 
183 impl Decode for HasConstant {
decode(file: &'static File, code: u32) -> Self184     fn decode(file: &'static File, code: u32) -> Self {
185         let code = (code & ((1 << 2) - 1), (code >> 2) - 1);
186         match code.0 {
187             0 => Self::Field(tables::Field(Row::new(code.1, TableIndex::Field, file))),
188             1 => Self::Param(tables::Param(Row::new(code.1, TableIndex::Param, file))),
189             _ => panic!("type_code"),
190         }
191     }
192 }
193 
194 impl HasConstant {
encode(&self) -> u32195     pub fn encode(&self) -> u32 {
196         match self {
197             Self::Field(value) => ((value.0.row + 1) << 2) | 0,
198             Self::Param(value) => ((value.0.row + 1) << 2) | 1,
199         }
200     }
201 }
202 
203 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
204 pub enum AttributeType {
205     MethodDef(tables::MethodDef),
206     MemberRef(tables::MemberRef),
207 }
208 
209 impl Decode for AttributeType {
decode(file: &'static File, code: u32) -> Self210     fn decode(file: &'static File, code: u32) -> Self {
211         let code = (code & ((1 << 3) - 1), (code >> 3) - 1);
212         match code.0 {
213             2 => Self::MethodDef(tables::MethodDef(Row::new(
214                 code.1,
215                 TableIndex::MethodDef,
216                 file,
217             ))),
218             3 => Self::MemberRef(tables::MemberRef(Row::new(
219                 code.1,
220                 TableIndex::MemberRef,
221                 file,
222             ))),
223             _ => panic!("type_code"),
224         }
225     }
226 }
227 
228 impl AttributeType {
encode(&self) -> u32229     pub fn encode(&self) -> u32 {
230         match self {
231             Self::MethodDef(value) => ((value.0.row + 1) << 3) | 2,
232             Self::MemberRef(value) => ((value.0.row + 1) << 3) | 3,
233         }
234     }
235 }
236 
237 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
238 pub enum MemberForwarded {
239     Field(tables::Field),
240     MethodDef(tables::MethodDef),
241 }
242 
243 impl Decode for MemberForwarded {
decode(file: &'static File, code: u32) -> Self244     fn decode(file: &'static File, code: u32) -> Self {
245         let code = (code & ((1 << 1) - 1), (code >> 1) - 1);
246         match code.0 {
247             0 => Self::Field(tables::Field(Row::new(code.1, TableIndex::Field, file))),
248             1 => Self::MethodDef(tables::MethodDef(Row::new(
249                 code.1,
250                 TableIndex::MethodDef,
251                 file,
252             ))),
253             _ => panic!("type_code"),
254         }
255     }
256 }
257 
258 impl MemberForwarded {
encode(&self) -> u32259     pub fn encode(&self) -> u32 {
260         match self {
261             Self::Field(value) => ((value.0.row + 1) << 1) | 0,
262             Self::MethodDef(value) => ((value.0.row + 1) << 1) | 1,
263         }
264     }
265 }
266 
267 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
268 pub enum ResolutionScope {
269     Module(tables::Module),
270     ModuleRef(tables::ModuleRef),
271     AssemblyRef(tables::AssemblyRef),
272     TypeRef(tables::TypeRef),
273 }
274 
275 impl Decode for ResolutionScope {
decode(file: &'static File, code: u32) -> Self276     fn decode(file: &'static File, code: u32) -> Self {
277         let code = (code & ((1 << 2) - 1), (code >> 2) - 1);
278         match code.0 {
279             0 => Self::Module(tables::Module(Row::new(code.1, TableIndex::Module, file))),
280             1 => Self::ModuleRef(tables::ModuleRef(Row::new(
281                 code.1,
282                 TableIndex::ModuleRef,
283                 file,
284             ))),
285             2 => Self::AssemblyRef(tables::AssemblyRef(Row::new(
286                 code.1,
287                 TableIndex::AssemblyRef,
288                 file,
289             ))),
290             3 => Self::TypeRef(tables::TypeRef(Row::new(code.1, TableIndex::TypeRef, file))),
291             _ => panic!("type_code"),
292         }
293     }
294 }
295 
296 impl ResolutionScope {
encode(&self) -> u32297     pub fn encode(&self) -> u32 {
298         match self {
299             Self::Module(value) => ((value.0.row + 1) << 2) | 0,
300             Self::ModuleRef(value) => ((value.0.row + 1) << 2) | 1,
301             Self::AssemblyRef(value) => ((value.0.row + 1) << 2) | 2,
302             Self::TypeRef(value) => ((value.0.row + 1) << 2) | 3,
303         }
304     }
305 }
306 
307 impl TypeDefOrRef {
namespace(&self) -> &'static str308     pub fn namespace(&self) -> &'static str {
309         match self {
310             Self::TypeDef(value) => value.namespace(),
311             Self::TypeRef(value) => value.namespace(),
312             _ => unexpected!(),
313         }
314     }
315 
name(&self) -> &'static str316     pub fn name(&self) -> &'static str {
317         match self {
318             Self::TypeDef(value) => value.name(),
319             Self::TypeRef(value) => value.name(),
320             _ => unexpected!(),
321         }
322     }
323 
full_name(&self) -> (&'static str, &'static str)324     pub fn full_name(&self) -> (&'static str, &'static str) {
325         match self {
326             Self::TypeDef(value) => value.full_name(),
327             Self::TypeRef(value) => value.full_name(),
328             _ => unexpected!(),
329         }
330     }
331 
resolve(&self) -> tables::TypeDef332     pub fn resolve(&self) -> tables::TypeDef {
333         match self {
334             Self::TypeDef(value) => *value,
335             Self::TypeRef(value) => value.resolve(),
336             _ => unexpected!(),
337         }
338     }
339 }
340 
341 impl MemberRefParent {
name(&self) -> &'static str342     pub fn name(&self) -> &'static str {
343         match self {
344             Self::TypeDef(value) => value.name(),
345             Self::TypeRef(value) => value.name(),
346             _ => unexpected!(),
347         }
348     }
349 
full_name(&self) -> (&'static str, &'static str)350     pub fn full_name(&self) -> (&'static str, &'static str) {
351         match self {
352             Self::TypeDef(value) => value.full_name(),
353             Self::TypeRef(value) => value.full_name(),
354             _ => unexpected!(),
355         }
356     }
357 }
358