hao 0.0.3

.net binary reader
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

pub mod coded_tokens;
pub mod metadata;
mod reader;
mod streams_offsets;
mod tables;
pub mod values;

use self::{
    coded_tokens::CodedTokenSizes,
    metadata::{TableExistsFlags, TableLocations, TableRowCount, TableRows},
};
use super::Version;
use crate::{
    dotnet::md::MDStreamFlags,
    error::Result,
    io::{DataReader, ReadData, Readable},
};
pub use reader::*;
pub use streams_offsets::*;
pub use tables::*;

#[derive(Debug, Clone, Copy)]
pub struct TableLocation {
    pub start_offset: usize,
    pub rows: TableRowCount,
    pub row_size: usize,
}

#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum ValueSize {
    Small,
    Big,
}

impl ValueSize {
    #[inline(always)]
    pub fn byte_size(&self) -> usize {
        match self {
            ValueSize::Big => std::mem::size_of::<u32>(),
            ValueSize::Small => std::mem::size_of::<u16>(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct TablesStreamsHeader {
    pub valid_tables: TableExistsFlags,
    pub table_locations: TableLocations,
    pub flags: MDStreamFlags,
    pub version: Version,
    pub sorted_tables: TableExistsFlags,
    pub coded_token_sizes: CodedTokenSizes,
}

impl Readable for TablesStreamsHeader {
    fn from_reader(reader: &mut DataReader) -> Result<Self> {
        let _reserved1: u32 = reader.read()?;
        let major_version: u8 = reader.read()?;
        let minor_version: u8 = reader.read()?;
        let flags = MDStreamFlags::from_bits_retain(reader.read()?);
        let _log_2_rid: u8 = reader.read()?;
        let valid_tables = TableExistsFlags::from_bits_retain(reader.read()?);
        let sorted_tables = TableExistsFlags::from_bits_retain(reader.read()?);

        if flags.contains(MDStreamFlags::ExtraData) {
            let _extra: u32 = reader.read()?;
        }
        let version = Version(major_version, minor_version);
        let table_rows = TableRows::from_reader(reader, valid_tables)?;
        let coded_token_sizes = CodedTokenSizes::from_header(&table_rows);

        let table_lcoations =
            TableLocations::from_metadata(&table_rows, &coded_token_sizes, flags, version);

        Ok(Self {
            valid_tables,
            coded_token_sizes,
            table_locations: table_lcoations,
            flags,
            version,
            sorted_tables,
        })
    }
}

#[derive(Debug, Clone)]
pub struct TablesStreams<'a> {
    pub header: TablesStreamsHeader,
    //pub values: TablesValues,
    heap_data: &'a [u8],
}

impl<'a> TablesStreams<'a> {
    pub fn from_reader(mut reader: DataReader<'a>) -> Result<Self> {
        let header = reader.read()?;

        let heap_data = reader.remaning_slice();

        Ok(Self { header, heap_data })
    }

    pub(crate) fn row_iter<T>(&'a self, location: TableLocation) -> Result<TableRowsIterator<'a, T>>
    where
        TablesStreamReader<'a>: ReadData<T>,
    {
        TableRowsIterator::new(self.heap_data, &self.header, location)
    }

    pub fn modules(&'a self) -> Result<impl Iterator<Item = Result<ModulesTableRow>> + 'a> {
        self.row_iter(self.header.table_locations.module)
    }
}