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

//! The class factory is an infrastructure type used by the COM clients to
//! create instances of the `#[com_class(..)]`es provided by the intercom
//! library.
//!
//! Intercom implements the class factory infrastructure automatically when the
//! user specifies the `#[com_library(..)]` -attribute.

use super::*;
use crate::attributes;
use crate::raw::RawComPtr;

#[com_interface(
    com_iid = "00000001-0000-0000-C000-000000000046",
    raw_iid = "11111112-0000-0000-C000-000000000046"
)]
pub trait IClassFactory
{
    /// # Safety
    ///
    /// The REFIID must be a valid IID pointer.
    unsafe fn create_instance(&self, outer: RawComPtr, riid: REFIID) -> ComResult<RawComPtr>;

    fn lock_server(&self, lock: bool) -> ComResult<()>;
}

#[doc(hidden)]
#[com_class(IClassFactory)]
pub struct ClassFactory<T: Default + intercom::attributes::ComClass>
{
    phantom: std::marker::PhantomData<T>,
}

impl<T: Default + attributes::ComClass> IClassFactory for ClassFactory<T>
{
    unsafe fn create_instance(&self, _outer: RawComPtr, riid: REFIID) -> ComResult<RawComPtr>
    {
        let instance = ComBox::new(T::default());
        let mut out = std::ptr::null_mut();
        let hr = ComBoxData::query_interface(instance.as_ref(), riid, &mut out);
        if hr == raw::S_OK {
            Ok(out)
        } else {
            Err(ComError::from(hr))
        }
    }

    fn lock_server(&self, lock: bool) -> ComResult<()>
    {
        unsafe {
            if lock {
                ComBoxData::add_ref(ComBoxData::of(self));
            } else {
                ComBoxData::release(
                    ComBoxData::of(self) as *const ComBoxData<Self> as *mut ComBoxData<Self>
                );
            }
        }
        Ok(())
    }
}

impl<T: Default + attributes::ComClass> ClassFactory<T>
{
    /// # Safety
    ///
    /// The `out` pointer must be valid for receiving the requested interface.
    pub unsafe fn create(riid: intercom::REFIID, out: *mut RawComPtr)
        -> crate::error::raw::HRESULT
    {
        let factory = Self {
            phantom: std::marker::PhantomData,
        };

        intercom::ComBoxData::query_interface(intercom::ComBox::new(factory).as_mut(), riid, out)
    }
}