Struct ComWrapper 

pub struct ComWrapper<C>
where
    C: Class,
{ /* private fields */ }

A wrapper for constructing a reference-counted COM object from a Rust value.

ComWrapper represents an owning reference to the COM object, i.e. it will decrement the object’s reference count when it goes out of scope.

Implementations

impl<C> ComWrapper<C>

where C: Class,

pub fn new(data: C) -> ComWrapper<C>

where C: 'static, <C as Class>::Interfaces: MakeHeader<C, ComWrapper<C>>,

Allocates memory for an object and its header and places data into it.

Examples found in repository

examples/gain.rs (line 529)

    unsafe fn createInstance(
        &self,
        cid: FIDString,
        iid: FIDString,
        obj: *mut *mut c_void,
    ) -> tresult {
        let instance = match *(cid as *const TUID) {
            GainProcessor::CID => Some(
                ComWrapper::new(GainProcessor::new())
                    .to_com_ptr::<FUnknown>()
                    .unwrap(),
            ),
            GainController::CID => Some(
                ComWrapper::new(GainController::new())
                    .to_com_ptr::<FUnknown>()
                    .unwrap(),
            ),
            _ => None,
        };

        if let Some(instance) = instance {
            let ptr = instance.as_ptr();
            ((*(*ptr).vtbl).queryInterface)(ptr, iid as *mut TUID, obj)
        } else {
            kInvalidArgument
        }
    }
}

#[cfg(target_os = "windows")]
#[no_mangle]
extern "system" fn InitDll() -> bool {
    true
}

#[cfg(target_os = "windows")]
#[no_mangle]
extern "system" fn ExitDll() -> bool {
    true
}

#[cfg(target_os = "macos")]
#[no_mangle]
extern "system" fn BundleEntry(_bundle_ref: *mut c_void) -> bool {
    true
}

#[cfg(target_os = "macos")]
#[no_mangle]
extern "system" fn BundleExit() -> bool {
    true
}

#[cfg(target_os = "linux")]
#[no_mangle]
extern "system" fn ModuleEntry(_library_handle: *mut c_void) -> bool {
    true
}

#[cfg(target_os = "linux")]
#[no_mangle]
extern "system" fn ModuleExit() -> bool {
    true
}

#[no_mangle]
extern "system" fn GetPluginFactory() -> *mut IPluginFactory {
    ComWrapper::new(Factory {})
        .to_com_ptr::<IPluginFactory>()
        .unwrap()
        .into_raw()
}

pub fn as_com_ref<'a, I>(&'a self) -> Option<ComRef<'a, I>>

where I: Interface,

If I is in C’s interface list, returns a ComRef<I> pointing to the object.

Does not perform any reference counting operations.

pub fn to_com_ptr<I>(&self) -> Option<ComPtr<I>>

where I: Interface,

If I is in C’s interface list, returns a ComPtr<I> pointing to the object.

If a ComPtr is returned, the object’s reference count will be incremented.

Examples found in repository

examples/gain.rs (line 530)

    unsafe fn createInstance(
        &self,
        cid: FIDString,
        iid: FIDString,
        obj: *mut *mut c_void,
    ) -> tresult {
        let instance = match *(cid as *const TUID) {
            GainProcessor::CID => Some(
                ComWrapper::new(GainProcessor::new())
                    .to_com_ptr::<FUnknown>()
                    .unwrap(),
            ),
            GainController::CID => Some(
                ComWrapper::new(GainController::new())
                    .to_com_ptr::<FUnknown>()
                    .unwrap(),
            ),
            _ => None,
        };

        if let Some(instance) = instance {
            let ptr = instance.as_ptr();
            ((*(*ptr).vtbl).queryInterface)(ptr, iid as *mut TUID, obj)
        } else {
            kInvalidArgument
        }
    }
}

#[cfg(target_os = "windows")]
#[no_mangle]
extern "system" fn InitDll() -> bool {
    true
}

#[cfg(target_os = "windows")]
#[no_mangle]
extern "system" fn ExitDll() -> bool {
    true
}

#[cfg(target_os = "macos")]
#[no_mangle]
extern "system" fn BundleEntry(_bundle_ref: *mut c_void) -> bool {
    true
}

#[cfg(target_os = "macos")]
#[no_mangle]
extern "system" fn BundleExit() -> bool {
    true
}

#[cfg(target_os = "linux")]
#[no_mangle]
extern "system" fn ModuleEntry(_library_handle: *mut c_void) -> bool {
    true
}

#[cfg(target_os = "linux")]
#[no_mangle]
extern "system" fn ModuleExit() -> bool {
    true
}

#[no_mangle]
extern "system" fn GetPluginFactory() -> *mut IPluginFactory {
    ComWrapper::new(Factory {})
        .to_com_ptr::<IPluginFactory>()
        .unwrap()
        .into_raw()
}

Trait Implementations

impl<C> Clone for ComWrapper<C>

where C: Class,

fn clone(&self) -> ComWrapper<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C> Deref for ComWrapper<C>

where C: Class,

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &<ComWrapper<C> as Deref>::Target

Dereferences the value.

impl<C> Wrapper<C> for ComWrapper<C>

where C: Class,

unsafe fn data_from_header( ptr: *mut <<C as Class>::Interfaces as InterfaceList>::Header, ) -> *mut C

Given a pointer to an object’s header, returns a pointer to the object itself.

unsafe fn header_from_data( ptr: *mut C, ) -> *mut <<C as Class>::Interfaces as InterfaceList>::Header

Given a pointer to an object, returns a pointer to the object’s header.

unsafe fn add_ref(ptr: *mut C) -> usize

Increments the reference count of an object and returns the resulting count.

unsafe fn release(ptr: *mut C) -> usize

Decrements the reference count of an object and returns the resulting count.

impl<C> Send for ComWrapper<C>

where C: Class + Send + Sync,

impl<C> Sync for ComWrapper<C>

where C: Class + Send + Sync,