hao/dotnet/md/streams/tables_stream/
streams_offsets.rs

1use super::{TableRows, TablesStreamReader, ValueSize};
2use crate::{dotnet::md::MDStreamFlags, error::Result, io::ReadData};
3
4pub trait TableOffsetSize {
5    fn table_offset_size(rows: &TableRows) -> ValueSize;
6}
7
8pub trait StreamsOffsetSize {
9    fn streams_offset_size(rows: MDStreamFlags) -> ValueSize;
10}
11
12#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13#[repr(transparent)]
14pub struct StringsStreamOffset(pub u32);
15
16impl StreamsOffsetSize for StringsStreamOffset {
17    fn streams_offset_size(flags: MDStreamFlags) -> ValueSize {
18        if flags.contains(MDStreamFlags::BigStrings) {
19            ValueSize::Big
20        } else {
21            ValueSize::Small
22        }
23    }
24}
25
26impl<'a> ReadData<StringsStreamOffset> for TablesStreamReader<'a> {
27    fn read(&mut self) -> Result<StringsStreamOffset> {
28        if StringsStreamOffset::streams_offset_size(self.header.flags) == ValueSize::Big {
29            Ok(StringsStreamOffset(self.read()?))
30        } else {
31            let small_str: u16 = self.read()?;
32            Ok(StringsStreamOffset(small_str as u32))
33        }
34    }
35}
36
37#[derive(Debug, Clone, Copy, PartialEq, Eq)]
38#[repr(transparent)]
39pub struct BlobStreamOffset(pub u32);
40
41impl StreamsOffsetSize for BlobStreamOffset {
42    fn streams_offset_size(flags: MDStreamFlags) -> ValueSize {
43        if flags.contains(MDStreamFlags::BigBlob) {
44            ValueSize::Big
45        } else {
46            ValueSize::Small
47        }
48    }
49}
50
51impl<'a> ReadData<BlobStreamOffset> for TablesStreamReader<'a> {
52    fn read(&mut self) -> Result<BlobStreamOffset> {
53        if BlobStreamOffset::streams_offset_size(self.header.flags) == ValueSize::Big {
54            Ok(BlobStreamOffset(self.read()?))
55        } else {
56            let small_str: u16 = self.read()?;
57            Ok(BlobStreamOffset(small_str as u32))
58        }
59    }
60}
61
62#[derive(Debug, Clone, Copy, PartialEq, Eq)]
63#[repr(transparent)]
64pub struct BlobStreamOffsetTypeSpec(pub u32);
65
66impl StreamsOffsetSize for BlobStreamOffsetTypeSpec {
67    fn streams_offset_size(flags: MDStreamFlags) -> ValueSize {
68        if flags.contains(MDStreamFlags::BigBlob) {
69            ValueSize::Big
70        } else {
71            ValueSize::Small
72        }
73    }
74}
75
76impl<'a> ReadData<BlobStreamOffsetTypeSpec> for TablesStreamReader<'a> {
77    fn read(&mut self) -> Result<BlobStreamOffsetTypeSpec> {
78        if BlobStreamOffsetTypeSpec::streams_offset_size(self.header.flags) == ValueSize::Big {
79            Ok(BlobStreamOffsetTypeSpec(self.read()?))
80        } else {
81            let small_str: u16 = self.read()?;
82            Ok(BlobStreamOffsetTypeSpec(small_str as u32))
83        }
84    }
85}
86
87#[derive(Debug, Clone, Copy, PartialEq, Eq)]
88#[repr(transparent)]
89pub struct GuidStreamOffset(pub u32);
90
91impl StreamsOffsetSize for GuidStreamOffset {
92    fn streams_offset_size(flags: MDStreamFlags) -> ValueSize {
93        if flags.contains(MDStreamFlags::BigGUID) {
94            ValueSize::Big
95        } else {
96            ValueSize::Small
97        }
98    }
99}
100
101impl<'a> ReadData<GuidStreamOffset> for TablesStreamReader<'a> {
102    fn read(&mut self) -> Result<GuidStreamOffset> {
103        if GuidStreamOffset::streams_offset_size(self.header.flags) == ValueSize::Big {
104            Ok(GuidStreamOffset(self.read()?))
105        } else {
106            let small_str: u16 = self.read()?;
107            Ok(GuidStreamOffset(small_str as u32))
108        }
109    }
110}
111
112#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
113#[repr(transparent)]
114pub struct ModuleTableOffset(pub u32);
115
116impl<'a> ReadData<ModuleTableOffset> for TablesStreamReader<'a> {
117    fn read(&mut self) -> Result<ModuleTableOffset> {
118        self.read_table_offset(self.header.table_locations.module)
119            .map(ModuleTableOffset)
120    }
121}
122
123impl TableOffsetSize for ModuleTableOffset {
124    fn table_offset_size(rows: &TableRows) -> ValueSize {
125        rows.module.row_size()
126    }
127}
128
129#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
130#[repr(transparent)]
131pub struct TypeRefTableOffset(pub u32);
132
133impl<'a> ReadData<TypeRefTableOffset> for TablesStreamReader<'a> {
134    fn read(&mut self) -> Result<TypeRefTableOffset> {
135        self.read_table_offset(self.header.table_locations.type_ref)
136            .map(TypeRefTableOffset)
137    }
138}
139
140impl TableOffsetSize for TypeRefTableOffset {
141    fn table_offset_size(rows: &TableRows) -> ValueSize {
142        rows.type_ref.row_size()
143    }
144}
145
146#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
147#[repr(transparent)]
148pub struct TypeDefTableOffset(pub u32);
149
150impl<'a> ReadData<TypeDefTableOffset> for TablesStreamReader<'a> {
151    fn read(&mut self) -> Result<TypeDefTableOffset> {
152        self.read_table_offset(self.header.table_locations.type_def)
153            .map(TypeDefTableOffset)
154    }
155}
156
157impl TableOffsetSize for TypeDefTableOffset {
158    fn table_offset_size(rows: &TableRows) -> ValueSize {
159        rows.type_def.row_size()
160    }
161}
162
163#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
164#[repr(transparent)]
165pub struct FieldPtrTableOffset(pub u32);
166
167impl<'a> ReadData<FieldPtrTableOffset> for TablesStreamReader<'a> {
168    fn read(&mut self) -> Result<FieldPtrTableOffset> {
169        self.read_table_offset(self.header.table_locations.field_ptr)
170            .map(FieldPtrTableOffset)
171    }
172}
173
174impl TableOffsetSize for FieldPtrTableOffset {
175    fn table_offset_size(rows: &TableRows) -> ValueSize {
176        rows.field_ptr.row_size()
177    }
178}
179
180#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
181#[repr(transparent)]
182pub struct FieldTableOffset(pub u32);
183
184impl<'a> ReadData<FieldTableOffset> for TablesStreamReader<'a> {
185    fn read(&mut self) -> Result<FieldTableOffset> {
186        self.read_table_offset(self.header.table_locations.field)
187            .map(FieldTableOffset)
188    }
189}
190
191impl TableOffsetSize for FieldTableOffset {
192    fn table_offset_size(rows: &TableRows) -> ValueSize {
193        rows.field.row_size()
194    }
195}
196
197#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
198#[repr(transparent)]
199pub struct MethodPtrTableOffset(pub u32);
200
201impl<'a> ReadData<MethodPtrTableOffset> for TablesStreamReader<'a> {
202    fn read(&mut self) -> Result<MethodPtrTableOffset> {
203        self.read_table_offset(self.header.table_locations.method_ptr)
204            .map(MethodPtrTableOffset)
205    }
206}
207
208impl TableOffsetSize for MethodPtrTableOffset {
209    fn table_offset_size(rows: &TableRows) -> ValueSize {
210        rows.method_ptr.row_size()
211    }
212}
213
214#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
215#[repr(transparent)]
216pub struct MethodTableOffset(pub u32);
217
218impl<'a> ReadData<MethodTableOffset> for TablesStreamReader<'a> {
219    fn read(&mut self) -> Result<MethodTableOffset> {
220        self.read_table_offset(self.header.table_locations.method)
221            .map(MethodTableOffset)
222    }
223}
224
225impl TableOffsetSize for MethodTableOffset {
226    fn table_offset_size(rows: &TableRows) -> ValueSize {
227        rows.method.row_size()
228    }
229}
230
231#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
232#[repr(transparent)]
233pub struct ParamPtrTableOffset(pub u32);
234
235impl<'a> ReadData<ParamPtrTableOffset> for TablesStreamReader<'a> {
236    fn read(&mut self) -> Result<ParamPtrTableOffset> {
237        self.read_table_offset(self.header.table_locations.param_ptr)
238            .map(ParamPtrTableOffset)
239    }
240}
241
242impl TableOffsetSize for ParamPtrTableOffset {
243    fn table_offset_size(rows: &TableRows) -> ValueSize {
244        rows.param_ptr.row_size()
245    }
246}
247
248#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
249#[repr(transparent)]
250pub struct ParamTableOffset(pub u32);
251
252impl<'a> ReadData<ParamTableOffset> for TablesStreamReader<'a> {
253    fn read(&mut self) -> Result<ParamTableOffset> {
254        self.read_table_offset(self.header.table_locations.param)
255            .map(ParamTableOffset)
256    }
257}
258
259impl TableOffsetSize for ParamTableOffset {
260    fn table_offset_size(rows: &TableRows) -> ValueSize {
261        rows.param.row_size()
262    }
263}
264
265#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
266#[repr(transparent)]
267pub struct InterfaceImplTableOffset(pub u32);
268
269impl<'a> ReadData<InterfaceImplTableOffset> for TablesStreamReader<'a> {
270    fn read(&mut self) -> Result<InterfaceImplTableOffset> {
271        self.read_table_offset(self.header.table_locations.interface_impl)
272            .map(InterfaceImplTableOffset)
273    }
274}
275
276impl TableOffsetSize for InterfaceImplTableOffset {
277    fn table_offset_size(rows: &TableRows) -> ValueSize {
278        rows.interface_impl.row_size()
279    }
280}
281
282#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
283#[repr(transparent)]
284pub struct MemberRefTableOffset(pub u32);
285
286impl<'a> ReadData<MemberRefTableOffset> for TablesStreamReader<'a> {
287    fn read(&mut self) -> Result<MemberRefTableOffset> {
288        self.read_table_offset(self.header.table_locations.member_ref)
289            .map(MemberRefTableOffset)
290    }
291}
292
293impl TableOffsetSize for MemberRefTableOffset {
294    fn table_offset_size(rows: &TableRows) -> ValueSize {
295        rows.member_ref.row_size()
296    }
297}
298
299#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
300#[repr(transparent)]
301pub struct ConstantTableOffset(pub u32);
302
303impl<'a> ReadData<ConstantTableOffset> for TablesStreamReader<'a> {
304    fn read(&mut self) -> Result<ConstantTableOffset> {
305        self.read_table_offset(self.header.table_locations.constant)
306            .map(ConstantTableOffset)
307    }
308}
309
310impl TableOffsetSize for ConstantTableOffset {
311    fn table_offset_size(rows: &TableRows) -> ValueSize {
312        rows.constant.row_size()
313    }
314}
315
316#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
317#[repr(transparent)]
318pub struct CustomAttributeTableOffset(pub u32);
319
320impl<'a> ReadData<CustomAttributeTableOffset> for TablesStreamReader<'a> {
321    fn read(&mut self) -> Result<CustomAttributeTableOffset> {
322        self.read_table_offset(self.header.table_locations.custom_attribute)
323            .map(CustomAttributeTableOffset)
324    }
325}
326
327impl TableOffsetSize for CustomAttributeTableOffset {
328    fn table_offset_size(rows: &TableRows) -> ValueSize {
329        rows.custom_attribute.row_size()
330    }
331}
332
333#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
334#[repr(transparent)]
335pub struct FieldMarshalTableOffset(pub u32);
336
337impl<'a> ReadData<FieldMarshalTableOffset> for TablesStreamReader<'a> {
338    fn read(&mut self) -> Result<FieldMarshalTableOffset> {
339        self.read_table_offset(self.header.table_locations.field_marshal)
340            .map(FieldMarshalTableOffset)
341    }
342}
343
344impl TableOffsetSize for FieldMarshalTableOffset {
345    fn table_offset_size(rows: &TableRows) -> ValueSize {
346        rows.field_marshal.row_size()
347    }
348}
349
350#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
351#[repr(transparent)]
352pub struct DeclSecurityTableOffset(pub u32);
353
354impl<'a> ReadData<DeclSecurityTableOffset> for TablesStreamReader<'a> {
355    fn read(&mut self) -> Result<DeclSecurityTableOffset> {
356        self.read_table_offset(self.header.table_locations.decl_security)
357            .map(DeclSecurityTableOffset)
358    }
359}
360
361impl TableOffsetSize for DeclSecurityTableOffset {
362    fn table_offset_size(rows: &TableRows) -> ValueSize {
363        rows.decl_security.row_size()
364    }
365}
366
367#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
368#[repr(transparent)]
369pub struct ClassLayoutTableOffset(pub u32);
370
371impl<'a> ReadData<ClassLayoutTableOffset> for TablesStreamReader<'a> {
372    fn read(&mut self) -> Result<ClassLayoutTableOffset> {
373        self.read_table_offset(self.header.table_locations.class_layout)
374            .map(ClassLayoutTableOffset)
375    }
376}
377
378impl TableOffsetSize for ClassLayoutTableOffset {
379    fn table_offset_size(rows: &TableRows) -> ValueSize {
380        rows.class_layout.row_size()
381    }
382}
383
384#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
385#[repr(transparent)]
386pub struct FieldLayoutTableOffset(pub u32);
387
388impl<'a> ReadData<FieldLayoutTableOffset> for TablesStreamReader<'a> {
389    fn read(&mut self) -> Result<FieldLayoutTableOffset> {
390        self.read_table_offset(self.header.table_locations.field_layout)
391            .map(FieldLayoutTableOffset)
392    }
393}
394
395impl TableOffsetSize for FieldLayoutTableOffset {
396    fn table_offset_size(rows: &TableRows) -> ValueSize {
397        rows.field_layout.row_size()
398    }
399}
400
401#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
402#[repr(transparent)]
403pub struct StandAloneSigTableOffset(pub u32);
404
405impl<'a> ReadData<StandAloneSigTableOffset> for TablesStreamReader<'a> {
406    fn read(&mut self) -> Result<StandAloneSigTableOffset> {
407        self.read_table_offset(self.header.table_locations.stand_alone_sig)
408            .map(StandAloneSigTableOffset)
409    }
410}
411
412impl TableOffsetSize for StandAloneSigTableOffset {
413    fn table_offset_size(rows: &TableRows) -> ValueSize {
414        rows.stand_alone_sig.row_size()
415    }
416}
417
418#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
419#[repr(transparent)]
420pub struct EventMapTableOffset(pub u32);
421
422impl<'a> ReadData<EventMapTableOffset> for TablesStreamReader<'a> {
423    fn read(&mut self) -> Result<EventMapTableOffset> {
424        self.read_table_offset(self.header.table_locations.event_map)
425            .map(EventMapTableOffset)
426    }
427}
428
429impl TableOffsetSize for EventMapTableOffset {
430    fn table_offset_size(rows: &TableRows) -> ValueSize {
431        rows.event_map.row_size()
432    }
433}
434
435#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
436#[repr(transparent)]
437pub struct EventPtrTableOffset(pub u32);
438
439impl<'a> ReadData<EventPtrTableOffset> for TablesStreamReader<'a> {
440    fn read(&mut self) -> Result<EventPtrTableOffset> {
441        self.read_table_offset(self.header.table_locations.event_ptr)
442            .map(EventPtrTableOffset)
443    }
444}
445
446impl TableOffsetSize for EventPtrTableOffset {
447    fn table_offset_size(rows: &TableRows) -> ValueSize {
448        rows.event_ptr.row_size()
449    }
450}
451
452#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
453#[repr(transparent)]
454pub struct EventTableOffset(pub u32);
455
456impl<'a> ReadData<EventTableOffset> for TablesStreamReader<'a> {
457    fn read(&mut self) -> Result<EventTableOffset> {
458        self.read_table_offset(self.header.table_locations.event)
459            .map(EventTableOffset)
460    }
461}
462
463impl TableOffsetSize for EventTableOffset {
464    fn table_offset_size(rows: &TableRows) -> ValueSize {
465        rows.event.row_size()
466    }
467}
468
469#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
470#[repr(transparent)]
471pub struct PropertyMapTableOffset(pub u32);
472
473impl<'a> ReadData<PropertyMapTableOffset> for TablesStreamReader<'a> {
474    fn read(&mut self) -> Result<PropertyMapTableOffset> {
475        self.read_table_offset(self.header.table_locations.property_map)
476            .map(PropertyMapTableOffset)
477    }
478}
479
480impl TableOffsetSize for PropertyMapTableOffset {
481    fn table_offset_size(rows: &TableRows) -> ValueSize {
482        rows.property_map.row_size()
483    }
484}
485
486#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
487#[repr(transparent)]
488pub struct PropertyPtrTableOffset(pub u32);
489
490impl<'a> ReadData<PropertyPtrTableOffset> for TablesStreamReader<'a> {
491    fn read(&mut self) -> Result<PropertyPtrTableOffset> {
492        self.read_table_offset(self.header.table_locations.property_ptr)
493            .map(PropertyPtrTableOffset)
494    }
495}
496
497impl TableOffsetSize for PropertyPtrTableOffset {
498    fn table_offset_size(rows: &TableRows) -> ValueSize {
499        rows.property_ptr.row_size()
500    }
501}
502
503#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
504#[repr(transparent)]
505pub struct PropertyTableOffset(pub u32);
506
507impl<'a> ReadData<PropertyTableOffset> for TablesStreamReader<'a> {
508    fn read(&mut self) -> Result<PropertyTableOffset> {
509        self.read_table_offset(self.header.table_locations.property)
510            .map(PropertyTableOffset)
511    }
512}
513
514impl TableOffsetSize for PropertyTableOffset {
515    fn table_offset_size(rows: &TableRows) -> ValueSize {
516        rows.property.row_size()
517    }
518}
519
520#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
521#[repr(transparent)]
522pub struct MethodSemanticsTableOffset(pub u32);
523
524impl<'a> ReadData<MethodSemanticsTableOffset> for TablesStreamReader<'a> {
525    fn read(&mut self) -> Result<MethodSemanticsTableOffset> {
526        self.read_table_offset(self.header.table_locations.method_semantics)
527            .map(MethodSemanticsTableOffset)
528    }
529}
530
531impl TableOffsetSize for MethodSemanticsTableOffset {
532    fn table_offset_size(rows: &TableRows) -> ValueSize {
533        rows.method_semantics.row_size()
534    }
535}
536
537#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
538#[repr(transparent)]
539pub struct MethodImplTableOffset(pub u32);
540
541impl<'a> ReadData<MethodImplTableOffset> for TablesStreamReader<'a> {
542    fn read(&mut self) -> Result<MethodImplTableOffset> {
543        self.read_table_offset(self.header.table_locations.method_impl)
544            .map(MethodImplTableOffset)
545    }
546}
547
548impl TableOffsetSize for MethodImplTableOffset {
549    fn table_offset_size(rows: &TableRows) -> ValueSize {
550        rows.method_impl.row_size()
551    }
552}
553
554#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
555#[repr(transparent)]
556pub struct ModuleRefTableOffset(pub u32);
557
558impl<'a> ReadData<ModuleRefTableOffset> for TablesStreamReader<'a> {
559    fn read(&mut self) -> Result<ModuleRefTableOffset> {
560        self.read_table_offset(self.header.table_locations.module_ref)
561            .map(ModuleRefTableOffset)
562    }
563}
564
565impl TableOffsetSize for ModuleRefTableOffset {
566    fn table_offset_size(rows: &TableRows) -> ValueSize {
567        rows.module_ref.row_size()
568    }
569}
570
571#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
572#[repr(transparent)]
573pub struct TypeSpecTableOffset(pub u32);
574
575impl<'a> ReadData<TypeSpecTableOffset> for TablesStreamReader<'a> {
576    fn read(&mut self) -> Result<TypeSpecTableOffset> {
577        self.read_table_offset(self.header.table_locations.type_spec)
578            .map(TypeSpecTableOffset)
579    }
580}
581
582impl TableOffsetSize for TypeSpecTableOffset {
583    fn table_offset_size(rows: &TableRows) -> ValueSize {
584        rows.type_spec.row_size()
585    }
586}
587
588#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
589#[repr(transparent)]
590pub struct ImplMapTableOffset(pub u32);
591
592impl<'a> ReadData<ImplMapTableOffset> for TablesStreamReader<'a> {
593    fn read(&mut self) -> Result<ImplMapTableOffset> {
594        self.read_table_offset(self.header.table_locations.impl_map)
595            .map(ImplMapTableOffset)
596    }
597}
598
599impl TableOffsetSize for ImplMapTableOffset {
600    fn table_offset_size(rows: &TableRows) -> ValueSize {
601        rows.impl_map.row_size()
602    }
603}
604
605#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
606#[repr(transparent)]
607pub struct FieldRVATableOffset(pub u32);
608
609impl<'a> ReadData<FieldRVATableOffset> for TablesStreamReader<'a> {
610    fn read(&mut self) -> Result<FieldRVATableOffset> {
611        self.read_table_offset(self.header.table_locations.field_rva)
612            .map(FieldRVATableOffset)
613    }
614}
615
616impl TableOffsetSize for FieldRVATableOffset {
617    fn table_offset_size(rows: &TableRows) -> ValueSize {
618        rows.field_rva.row_size()
619    }
620}
621
622#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
623#[repr(transparent)]
624pub struct ENCLogTableOffset(pub u32);
625
626impl<'a> ReadData<ENCLogTableOffset> for TablesStreamReader<'a> {
627    fn read(&mut self) -> Result<ENCLogTableOffset> {
628        self.read_table_offset(self.header.table_locations.enc_log)
629            .map(ENCLogTableOffset)
630    }
631}
632
633impl TableOffsetSize for ENCLogTableOffset {
634    fn table_offset_size(rows: &TableRows) -> ValueSize {
635        rows.enc_log.row_size()
636    }
637}
638
639#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
640#[repr(transparent)]
641pub struct ENCMapTableOffset(pub u32);
642
643impl<'a> ReadData<ENCMapTableOffset> for TablesStreamReader<'a> {
644    fn read(&mut self) -> Result<ENCMapTableOffset> {
645        self.read_table_offset(self.header.table_locations.enc_map)
646            .map(ENCMapTableOffset)
647    }
648}
649
650impl TableOffsetSize for ENCMapTableOffset {
651    fn table_offset_size(rows: &TableRows) -> ValueSize {
652        rows.enc_map.row_size()
653    }
654}
655
656#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
657#[repr(transparent)]
658pub struct AssemblyTableOffset(pub u32);
659
660impl<'a> ReadData<AssemblyTableOffset> for TablesStreamReader<'a> {
661    fn read(&mut self) -> Result<AssemblyTableOffset> {
662        self.read_table_offset(self.header.table_locations.assembly)
663            .map(AssemblyTableOffset)
664    }
665}
666
667impl TableOffsetSize for AssemblyTableOffset {
668    fn table_offset_size(rows: &TableRows) -> ValueSize {
669        rows.assembly.row_size()
670    }
671}
672
673#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
674#[repr(transparent)]
675pub struct AssemblyProcessorTableOffset(pub u32);
676
677impl<'a> ReadData<AssemblyProcessorTableOffset> for TablesStreamReader<'a> {
678    fn read(&mut self) -> Result<AssemblyProcessorTableOffset> {
679        self.read_table_offset(self.header.table_locations.assembly_processor)
680            .map(AssemblyProcessorTableOffset)
681    }
682}
683
684impl TableOffsetSize for AssemblyProcessorTableOffset {
685    fn table_offset_size(rows: &TableRows) -> ValueSize {
686        rows.assembly_processor.row_size()
687    }
688}
689
690#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
691#[repr(transparent)]
692pub struct AssemblyOSTableOffset(pub u32);
693
694impl<'a> ReadData<AssemblyOSTableOffset> for TablesStreamReader<'a> {
695    fn read(&mut self) -> Result<AssemblyOSTableOffset> {
696        self.read_table_offset(self.header.table_locations.assembly_os)
697            .map(AssemblyOSTableOffset)
698    }
699}
700
701impl TableOffsetSize for AssemblyOSTableOffset {
702    fn table_offset_size(rows: &TableRows) -> ValueSize {
703        rows.assembly_os.row_size()
704    }
705}
706
707#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
708#[repr(transparent)]
709pub struct AssemblyRefTableOffset(pub u32);
710
711impl<'a> ReadData<AssemblyRefTableOffset> for TablesStreamReader<'a> {
712    fn read(&mut self) -> Result<AssemblyRefTableOffset> {
713        self.read_table_offset(self.header.table_locations.assembly_ref)
714            .map(AssemblyRefTableOffset)
715    }
716}
717
718impl TableOffsetSize for AssemblyRefTableOffset {
719    fn table_offset_size(rows: &TableRows) -> ValueSize {
720        rows.assembly_ref.row_size()
721    }
722}
723
724#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
725#[repr(transparent)]
726pub struct AssemblyRefProcessorTableOffset(pub u32);
727
728impl<'a> ReadData<AssemblyRefProcessorTableOffset> for TablesStreamReader<'a> {
729    fn read(&mut self) -> Result<AssemblyRefProcessorTableOffset> {
730        self.read_table_offset(self.header.table_locations.assembly_ref_processor)
731            .map(AssemblyRefProcessorTableOffset)
732    }
733}
734
735impl TableOffsetSize for AssemblyRefProcessorTableOffset {
736    fn table_offset_size(rows: &TableRows) -> ValueSize {
737        rows.assembly_ref_processor.row_size()
738    }
739}
740
741#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
742#[repr(transparent)]
743pub struct AssemblyRefOSTableOffset(pub u32);
744
745impl<'a> ReadData<AssemblyRefOSTableOffset> for TablesStreamReader<'a> {
746    fn read(&mut self) -> Result<AssemblyRefOSTableOffset> {
747        self.read_table_offset(self.header.table_locations.assembly_ref_os)
748            .map(AssemblyRefOSTableOffset)
749    }
750}
751
752impl TableOffsetSize for AssemblyRefOSTableOffset {
753    fn table_offset_size(rows: &TableRows) -> ValueSize {
754        rows.assembly_ref_os.row_size()
755    }
756}
757
758#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
759#[repr(transparent)]
760pub struct FileTableOffset(pub u32);
761
762impl<'a> ReadData<FileTableOffset> for TablesStreamReader<'a> {
763    fn read(&mut self) -> Result<FileTableOffset> {
764        self.read_table_offset(self.header.table_locations.file)
765            .map(FileTableOffset)
766    }
767}
768
769impl TableOffsetSize for FileTableOffset {
770    fn table_offset_size(rows: &TableRows) -> ValueSize {
771        rows.file.row_size()
772    }
773}
774
775#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
776#[repr(transparent)]
777pub struct ExportedTypeTableOffset(pub u32);
778
779impl<'a> ReadData<ExportedTypeTableOffset> for TablesStreamReader<'a> {
780    fn read(&mut self) -> Result<ExportedTypeTableOffset> {
781        self.read_table_offset(self.header.table_locations.exported_type)
782            .map(ExportedTypeTableOffset)
783    }
784}
785
786impl TableOffsetSize for ExportedTypeTableOffset {
787    fn table_offset_size(rows: &TableRows) -> ValueSize {
788        rows.exported_type.row_size()
789    }
790}
791
792#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
793#[repr(transparent)]
794pub struct ManifestResourceTableOffset(pub u32);
795
796impl<'a> ReadData<ManifestResourceTableOffset> for TablesStreamReader<'a> {
797    fn read(&mut self) -> Result<ManifestResourceTableOffset> {
798        self.read_table_offset(self.header.table_locations.manifest_resource)
799            .map(ManifestResourceTableOffset)
800    }
801}
802
803impl TableOffsetSize for ManifestResourceTableOffset {
804    fn table_offset_size(rows: &TableRows) -> ValueSize {
805        rows.manifest_resource.row_size()
806    }
807}
808
809#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
810#[repr(transparent)]
811pub struct NestedClassTableOffset(pub u32);
812
813impl<'a> ReadData<NestedClassTableOffset> for TablesStreamReader<'a> {
814    fn read(&mut self) -> Result<NestedClassTableOffset> {
815        self.read_table_offset(self.header.table_locations.nested_class)
816            .map(NestedClassTableOffset)
817    }
818}
819
820impl TableOffsetSize for NestedClassTableOffset {
821    fn table_offset_size(rows: &TableRows) -> ValueSize {
822        rows.nested_class.row_size()
823    }
824}
825
826#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
827#[repr(transparent)]
828pub struct GenericParamTableOffset(pub u32);
829
830impl<'a> ReadData<GenericParamTableOffset> for TablesStreamReader<'a> {
831    fn read(&mut self) -> Result<GenericParamTableOffset> {
832        self.read_table_offset(self.header.table_locations.generic_param)
833            .map(GenericParamTableOffset)
834    }
835}
836
837impl TableOffsetSize for GenericParamTableOffset {
838    fn table_offset_size(rows: &TableRows) -> ValueSize {
839        rows.generic_param.row_size()
840    }
841}
842
843#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
844#[repr(transparent)]
845pub struct MethodSpecTableOffset(pub u32);
846
847impl<'a> ReadData<MethodSpecTableOffset> for TablesStreamReader<'a> {
848    fn read(&mut self) -> Result<MethodSpecTableOffset> {
849        self.read_table_offset(self.header.table_locations.method_spec)
850            .map(MethodSpecTableOffset)
851    }
852}
853
854impl TableOffsetSize for MethodSpecTableOffset {
855    fn table_offset_size(rows: &TableRows) -> ValueSize {
856        rows.method_spec.row_size()
857    }
858}
859
860#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
861#[repr(transparent)]
862pub struct GenericParamConstraintTableOffset(pub u32);
863
864impl<'a> ReadData<GenericParamConstraintTableOffset> for TablesStreamReader<'a> {
865    fn read(&mut self) -> Result<GenericParamConstraintTableOffset> {
866        self.read_table_offset(self.header.table_locations.generic_param_constraint)
867            .map(GenericParamConstraintTableOffset)
868    }
869}
870
871impl TableOffsetSize for GenericParamConstraintTableOffset {
872    fn table_offset_size(rows: &TableRows) -> ValueSize {
873        rows.generic_param_constraint.row_size()
874    }
875}
876
877#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
878#[repr(transparent)]
879pub struct DocumentTableRowOffset(pub u32);
880
881impl<'a> ReadData<DocumentTableRowOffset> for TablesStreamReader<'a> {
882    fn read(&mut self) -> Result<DocumentTableRowOffset> {
883        self.read_table_offset(self.header.table_locations.generic_param)
884            .map(DocumentTableRowOffset)
885    }
886}
887
888impl TableOffsetSize for DocumentTableRowOffset {
889    fn table_offset_size(rows: &TableRows) -> ValueSize {
890        rows.document.row_size()
891    }
892}
893
894#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
895#[repr(transparent)]
896pub struct MethodDebugInformationTableOffset(pub u32);
897
898impl<'a> ReadData<MethodDebugInformationTableOffset> for TablesStreamReader<'a> {
899    fn read(&mut self) -> Result<MethodDebugInformationTableOffset> {
900        self.read_table_offset(self.header.table_locations.method_debug_information)
901            .map(MethodDebugInformationTableOffset)
902    }
903}
904
905impl TableOffsetSize for MethodDebugInformationTableOffset {
906    fn table_offset_size(rows: &TableRows) -> ValueSize {
907        rows.method_debug_information.row_size()
908    }
909}
910
911#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
912#[repr(transparent)]
913pub struct LocalScopeTableOffset(pub u32);
914
915impl<'a> ReadData<LocalScopeTableOffset> for TablesStreamReader<'a> {
916    fn read(&mut self) -> Result<LocalScopeTableOffset> {
917        self.read_table_offset(self.header.table_locations.local_scope)
918            .map(LocalScopeTableOffset)
919    }
920}
921
922impl TableOffsetSize for LocalScopeTableOffset {
923    fn table_offset_size(rows: &TableRows) -> ValueSize {
924        rows.local_scope.row_size()
925    }
926}
927
928#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
929#[repr(transparent)]
930pub struct LocalVariableTableOffset(pub u32);
931
932impl<'a> ReadData<LocalVariableTableOffset> for TablesStreamReader<'a> {
933    fn read(&mut self) -> Result<LocalVariableTableOffset> {
934        self.read_table_offset(self.header.table_locations.local_variable)
935            .map(LocalVariableTableOffset)
936    }
937}
938
939impl TableOffsetSize for LocalVariableTableOffset {
940    fn table_offset_size(rows: &TableRows) -> ValueSize {
941        rows.local_variable.row_size()
942    }
943}
944
945#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
946#[repr(transparent)]
947pub struct LocalConstantTableOffset(pub u32);
948
949impl<'a> ReadData<LocalConstantTableOffset> for TablesStreamReader<'a> {
950    fn read(&mut self) -> Result<LocalConstantTableOffset> {
951        self.read_table_offset(self.header.table_locations.local_constant)
952            .map(LocalConstantTableOffset)
953    }
954}
955
956impl TableOffsetSize for LocalConstantTableOffset {
957    fn table_offset_size(rows: &TableRows) -> ValueSize {
958        rows.local_constant.row_size()
959    }
960}
961
962#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
963#[repr(transparent)]
964pub struct ImportScopeTableOffset(pub u32);
965
966impl<'a> ReadData<ImportScopeTableOffset> for TablesStreamReader<'a> {
967    fn read(&mut self) -> Result<ImportScopeTableOffset> {
968        self.read_table_offset(self.header.table_locations.import_scope)
969            .map(ImportScopeTableOffset)
970    }
971}
972
973impl TableOffsetSize for ImportScopeTableOffset {
974    fn table_offset_size(rows: &TableRows) -> ValueSize {
975        rows.import_scope.row_size()
976    }
977}
978
979#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
980#[repr(transparent)]
981pub struct StateMachineMethodTableOffset(pub u32);
982
983impl<'a> ReadData<StateMachineMethodTableOffset> for TablesStreamReader<'a> {
984    fn read(&mut self) -> Result<StateMachineMethodTableOffset> {
985        self.read_table_offset(self.header.table_locations.state_machine_method)
986            .map(StateMachineMethodTableOffset)
987    }
988}
989
990impl TableOffsetSize for StateMachineMethodTableOffset {
991    fn table_offset_size(rows: &TableRows) -> ValueSize {
992        rows.state_machine_method.row_size()
993    }
994}
995
996#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
997#[repr(transparent)]
998pub struct CustomDebugInformationTableOffset(pub u32);
999
1000impl<'a> ReadData<CustomDebugInformationTableOffset> for TablesStreamReader<'a> {
1001    fn read(&mut self) -> Result<CustomDebugInformationTableOffset> {
1002        self.read_table_offset(self.header.table_locations.custom_debug_information)
1003            .map(CustomDebugInformationTableOffset)
1004    }
1005}
1006
1007impl TableOffsetSize for CustomDebugInformationTableOffset {
1008    fn table_offset_size(rows: &TableRows) -> ValueSize {
1009        rows.custom_debug_information.row_size()
1010    }
1011}
hao/dotnet/md/streams/tables_stream/streams_offsets.rs

hao/dotnet/md/streams/tables_stream/
streams_offsets.rs
