Struct vtable::VRc

#[repr(transparent)]
pub struct VRc<VTable: VTableMetaDropInPlace + 'static, X = Dyn> { /* private fields */ }

A reference counted pointer to an object matching the virtual table T

Similar to alloc::rc::Rc where the VTable type parameter is a VTable struct annotated with #[vtable], and the X type parameter is the actual instance. When X is the Dyn type marker, this means that the X is not known and the only thing that can be done is to get a VRef<VTable> through the Self::borrow() function.

Other differences with the alloc::rc::Rc types are:

• It does not allow to access mutable reference. (No get_mut or make_mut), meaning it is safe to get a Pin reference with borrow_pin.
• It is safe to pass it across ffi boundaries.

Implementations

impl<VTable: VTableMetaDropInPlace, X: HasStaticVTable<VTable>> VRc<VTable, X>

pub fn new(data: X) -> Self

Create a new VRc from an instance of a type that can be associated with a VTable.

Will move the instance on the heap.

(the HasStaticVTable is implemented by the “MyTrait”VTable_static! macro generated by the #vtable macro)

pub fn into_dyn(this: Self) -> VRc<VTable, Dyn> where
    Self: 'static, 

Convert a VRc of a real instance to a VRc of a Dyn instance

impl<VTable: VTableMetaDropInPlace + 'static, X: HasStaticVTable<VTable> + 'static> VRc<VTable, X>

pub fn map<MappedType: ?Sized>(
    this: Self,
    map_fn: impl for<'r> FnOnce(Pin<&'r X>) -> Pin<&'r MappedType>
) -> VRcMapped<VTable, MappedType>

This function allows safely holding a reference to a field inside the VRc. In order to accomplish that, you need to provide a mapping function map_fn in which you need to provide and return a pinned reference to the object you would like to map. The returned VRcMapped allows obtaining that pinned reference again using VRcMapped::as_pin_ref.

impl<VTable: VTableMetaDropInPlace, X> VRc<VTable, X>

pub fn as_pin_ref(&self) -> Pin<&X>

Create a Pinned reference to the inner.

This is safe because we don’t allow mutable reference to the inner

pub fn borrow(this: &Self) -> VRef<'_, VTable>

Gets a VRef pointing to this instance

pub fn borrow_pin(this: &Self) -> Pin<VRef<'_, VTable>>

Gets a Pin pointing to this instance

This is safe because there is no way to access a mutable reference to the pointee. (There is no get_mut or make_mut),

pub fn downgrade(this: &Self) -> VWeak<VTable, X>

Construct a VWeak pointing to this instance.

pub fn strong_count(this: &Self) -> usize

Gets the number of strong (VRc) pointers to this allocation.

pub fn ptr_eq(this: &Self, other: &Self) -> bool

Returns true if the two VRc’s point to the same allocation

Trait Implementations

impl<VTable: VTableMetaDropInPlace + 'static, X> Clone for VRc<VTable, X>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<VTable: VTableMetaDropInPlace + 'static, X> Debug for VRc<VTable, X>

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

Formats the value using the given formatter.

impl<VTable: VTableMetaDropInPlace, X> Deref for VRc<VTable, X>

type Target = X

The resulting type after dereferencing.

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

Dereferences the value.

impl<VTable: VTableMetaDropInPlace + 'static, X> Drop for VRc<VTable, X>

fn drop(&mut self)

Executes the destructor for this type.

impl<VTable: VTableMetaDropInPlace + 'static, X> CloneStableDeref for VRc<VTable, X>

Safety: The data VRc manages is held by VRcInner, and a clone of a VRc merely clones the pointer to the VRcInner.

impl<VTable: VTableMetaDropInPlace + 'static, X: Send + Sync> Send for VRc<VTable, X>

impl<VTable: VTableMetaDropInPlace + 'static, X> StableDeref for VRc<VTable, X>

Safety: The data VRc manages is held by VRcInner, which maintains its address when the VRc is moved.

impl<VTable: VTableMetaDropInPlace + 'static, X: Send + Sync> Sync for VRc<VTable, X>