winmd 0.6.0

Winmd parser
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

use super::*;
use crate::{TableIndex, TypeReader};

#[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Debug)]
pub struct MethodDef(pub Row);

impl MethodDef {
    pub fn flags(self, reader: &TypeReader) -> MethodFlags {
        MethodFlags(reader.u32(self.0, 2))
    }

    pub fn parent(self, reader: &TypeReader) -> TypeDef {
        TypeDef(reader.upper_bound(self.0.file_index, TableIndex::TypeDef, 6, self.0.index))
    }

    pub fn params(self, reader: &TypeReader) -> impl Iterator<Item = Param> {
        reader.list(self.0, TableIndex::Param, 5).map(Param)
    }

    pub fn name(self, reader: &TypeReader) -> &str {
        reader.str(self.0, 3)
    }

    pub fn sig(self, reader: &TypeReader) -> Blob {
        reader.blob(self.0, 4)
    }

    pub fn category(self, reader: &TypeReader) -> MethodCategory {
        if self.flags(reader).special() {
            let name = self.name(reader);

            if name.starts_with("get") {
                MethodCategory::Get
            } else if name.starts_with("put") {
                MethodCategory::Set
            } else if name.starts_with("add") {
                MethodCategory::Add
            } else if name.starts_with("remove") {
                MethodCategory::Remove
            } else {
                // A delegate's 'Invoke' method is "special" but lacks a preamble.
                MethodCategory::Normal
            }
        } else {
            MethodCategory::Normal
        }
    }

    pub fn attributes(self, reader: &TypeReader) -> impl Iterator<Item = Attribute> {
        reader
            .equal_range(
                self.0.file_index,
                TableIndex::CustomAttribute,
                0,
                HasAttribute::MethodDef(self).encode(),
            )
            .map(Attribute)
    }

    pub fn find_attribute(self, reader: &TypeReader, name: (&str, &str)) -> Option<Attribute> {
        self.attributes(reader)
            .find(|attribute| attribute.name(reader) == name)
    }
}