Struct com::ComPtr

#[repr(transparent)]pub struct ComPtr<T: ComInterface + ?Sized> { /* fields omitted */ }

A transparent ptr to a COM interface.

This is normally not the correct way to interact with an interface. Normally you'll want to to interact with an interface through a ComRc which automatically calls AddRef and Release at the right time .

Methods

impl<T: ComInterface + ?Sized> ComPtr<T>

pub unsafe fn new(ptr: *mut *mut <T as ComInterface>::VTable) -> ComPtr<T>

Creates a new ComPtr that comforms to the interface T

Safety

ptr must be a valid interface pointer for interface T. An interface pointer as the name suggests points to an interface struct. A valid interface is itself trivial castable to a *mut T::VTable. In other words, ptr should also be equal to *mut *mut T::VTable

ptr must live for at least as long as the ComPtr. The underlying COM interface is assumed to correctly implement AddRef and Release such that the interface will be valid as long as AddRef has been called more times than Release.

AddRef must have been called on the underlying COM interface that ptr is pointing to such that the reference count must be at least 1. It is expected that Release will eventually be called on this pointer either manually or by passing it into ComRc::new which will cause Release to be called on drop of the rc.

When this struct is dropped, release will be called on the underlying interface.

Panics

Panics if ptr is null

pub fn upgrade(self) -> ComRc<T>

Upgrade the ComPtr to an ComRc

pub fn as_raw(&self) -> *mut *mut <T as ComInterface>::VTable

Gets the underlying interface ptr. This ptr is only guarnteed to live for as long as the current ComPtr is alive.

pub fn get_interface<I: ComInterface + ?Sized>(&self) -> Option<ComPtr<I>>

A safe version of QueryInterface. If the backing CoClass implements the interface I then a Some containing an ComRc pointing to that interface will be returned otherwise None will be returned.

Trait Implementations

impl<T: ComInterface + ?Sized> Clone for ComPtr<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: ComInterface + ?Sized> From<ComRc<T>> for ComPtr<T>

fn from(rc: ComRc<T>) -> Self

Convert from an ComRc to an ComPtr

Note that this does not call the release on the underlying interface which gurantees that the ComPtr will still point to a valid interface. If Release is never called on this pointer, than memory may be leaked.

impl<T: IClassFactory + ComInterface + ?Sized> IClassFactory for ComPtr<T>

unsafe fn create_instance(
    &self,
    aggr: *mut IUnknownVPtr,
    riid: *const GUID,
    ppv: *mut *mut c_void
) -> HRESULT

the CreateInstance COM method

unsafe fn lock_server(&self, increment: BOOL) -> HRESULT

the LockServer COM method

impl<T: IUnknown + ComInterface + ?Sized> IUnknown for ComPtr<T>

unsafe fn query_interface(
    &self,
    riid: *const GUID,
    ppv: *mut *mut c_void
) -> HRESULT

The COM [QueryInterface Method]

unsafe fn add_ref(&self) -> u32

The COM [AddRef Method]

unsafe fn release(&self) -> u32

The COM [Release Method]