Struct com::production::ClassAllocation

#[repr(transparent)]
pub struct ClassAllocation<T: Class> { /* fields omitted */ }

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<&<P as Deref>::Target>

Gets a pinned shared reference from this pinned pointer.

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.

Trait Implementations

impl<T: Class> Clone for ClassAllocation<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: 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.