intercom 0.4.0

Utilities for writing COM visible Rust components.
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
113
114
115
116
117
118
119
120
121
122

use super::*;

impl TypeLib
{
    pub fn from_comrc(lib: &ComRc<dyn IIntercomTypeLib>) -> Result<TypeLib, TypeLibError>
    {
        let mut types = vec![];
        for t in 0..lib.get_type_count()? {
            let ty = lib.get_type(t)?;

            types.push(match ty.get_kind()? {
                TypeInfoKind::CoClass => {
                    let cls = CoClass::from_comrc(&ComItf::query_interface(&ty)?)?;
                    TypeInfo::Class(ComBox::new(cls))
                }
                TypeInfoKind::Interface => {
                    let itf = Interface::from_comrc(&ComItf::query_interface(&ty)?)?;
                    TypeInfo::Interface(ComBox::new(itf))
                }
            });
        }

        let (name, libid, version) = lib.get_info()?;
        Ok(TypeLib {
            name: name.into(),
            libid,
            version: version.into(),
            types,
        })
    }
}

impl CoClass
{
    pub fn from_comrc(ti: &ComRc<dyn IIntercomCoClass>) -> Result<CoClass, TypeLibError>
    {
        let mut interfaces = vec![];
        for i in 0..ti.get_interface_count()? {
            let (name, iid_automation) = ti.get_interface_ref(i, TypeSystemName::Automation)?;
            let (_, iid_raw) = ti.get_interface_ref(i, TypeSystemName::Raw)?;

            interfaces.push(InterfaceRef {
                name: name.into(),
                iid_automation,
                iid_raw,
            });
        }

        Ok(CoClass {
            name: ti.get_name()?.into(),
            clsid: ti.get_clsid()?,
            interfaces,
        })
    }
}

impl Interface
{
    pub fn from_comrc(ti: &ComRc<dyn IIntercomInterface>) -> Result<Interface, TypeLibError>
    {
        let mut variants = vec![];
        for v in 0..ti.get_variant_count()? {
            variants.push(ComBox::new(InterfaceVariant::from_comrc(
                &ti.get_variant(v)?,
            )?));
        }

        Ok(Interface {
            name: ti.get_name()?.into(),
            options: ti.get_options()?,
            variants,
        })
    }
}

impl InterfaceVariant
{
    pub fn from_comrc(
        ti: &ComRc<dyn IIntercomInterfaceVariant>,
    ) -> Result<InterfaceVariant, TypeLibError>
    {
        let mut methods = vec![];
        for m in 0..ti.get_method_count()? {
            methods.push(ComBox::new(Method::from_comrc(&ti.get_method(m)?)?));
        }

        Ok(InterfaceVariant {
            ts: ti.get_type_system()?,
            iid: ti.get_iid()?,
            methods,
        })
    }
}

impl Method
{
    pub fn from_comrc(ti: &ComRc<dyn IIntercomMethod>) -> Result<Method, TypeLibError>
    {
        let mut parameters = vec![];
        for p in 0..ti.get_parameter_count()? {
            let (name, ty, indirection_level, direction) = ti.get_parameter(p)?;
            parameters.push(Arg {
                name: name.into(),
                ty: ty.into(),
                indirection_level,
                direction,
            });
        }

        let (return_ty, return_indirection_level) = ti.get_return_type()?;
        Ok(Method {
            name: ti.get_name()?.into(),
            return_type: Arg {
                name: "".into(),
                ty: return_ty.into(),
                indirection_level: return_indirection_level,
                direction: Direction::Return,
            },
            parameters,
        })
    }
}