Struct ClassAllocation 

pub struct ClassAllocation<T: Class> { /* private fields */ }

An allocated COM class

The class must be heap allocated and not be moved in memory. This wrapper decrements the inner class ref count when dropped and frees the heap allocation as well as the class itself when that ref count is 0.

Implementations

impl<T: Class> ClassAllocation<T>

pub fn new(inner: Pin<Box<T>>) -> Self

Create a new class allocation

This is not normally used by users of the COM crate but by the code generator

pub unsafe fn from_raw(raw: *mut T) -> Self

Create an allocated class from a raw pointer

Safety

Must be a valid, owned pointer to an allocated COM class. This returns an owned ClassAllocation which will drop the wrapped COM class when it is dropped.

Methods from Deref<Target = Pin<Box<T>>>

pub fn as_ref(&self) -> Pin<&<Ptr as Deref>::Target>

Gets a shared reference to the pinned value this Pin points to.

This is a generic method to go from &Pin<Pointer<T>> to Pin<&T>. It is safe because, as part of the contract of Pin::new_unchecked, the pointee cannot move after Pin<Pointer<T>> got created. “Malicious” implementations of Pointer::Deref are likewise ruled out by the contract of Pin::new_unchecked.

pub fn as_deref_mut( self: Pin<&mut Pin<Ptr>>, ) -> Pin<&mut <Ptr as Deref>::Target>

Gets Pin<&mut T> to the underlying pinned value from this nested Pin-pointer.

This is a generic method to go from Pin<&mut Pin<Pointer<T>>> to Pin<&mut T>. It is safe because the existence of a Pin<Pointer<T>> ensures that the pointee, T, cannot move in the future, and this method does not enable the pointee to move. “Malicious” implementations of Ptr::DerefMut are likewise ruled out by the contract of Pin::new_unchecked.

Trait Implementations

impl<T: Class> Clone for ClassAllocation<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Class + Debug> Debug for ClassAllocation<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Class> Deref for ClassAllocation<T>

type Target = Pin<Box<T>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Class> Drop for ClassAllocation<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Class> Send for ClassAllocation<T>

ClassAllocation<T> is Send because it represents an owned reference to a heap allocation, and the changes to that reference count are atomic.

impl<T: Class> Sync for ClassAllocation<T>

ClassAllocation<T> is Sync because it represents an aliased (shared) reference to a heap-allocated object, and the only way you can gain access to that heap object is to acquire a &self (shared) reference.