Struct RefPtr 

pub struct RefPtr<T>
where
    T: HasRefCount + Recyclable,
{ /* private fields */ }

RefPtr<T> holds a reference to an intrusively-refcounted object of type T that deletes the object when the refcount drops to 0.

T should be a struct that contains a fbl::RefCounted field and implements HasRefCount and Destroy traits.

Implementations

impl<T: HasRefCount + Recyclable> RefPtr<T>

pub unsafe fn from_raw(ptr: *const T) -> Self

Constructs a RefPtr from a raw pointer that has already been adopted.

Safety

• The caller must ensure that ptr is valid and has a ref count already acquired.
• ptr must have been allocated in such a way that calling T::recycle(ptr) is a correct way to deallocate the pointer.

pub unsafe fn try_new(value: T) -> Result<RefPtr<T>, AllocError>

Helper function that allocates a new instance of T using T::allocate and returns a RefPtr wrapping it.

This is an internal helper function that should not be used directly. Use the make_ref_counted!(...) macro instead of this function to properly initialize the ref count.

Safety

The caller must ensure that T has a RefCounted field that is not already adopted.

pub fn as_ptr(this: &Self) -> *const T

Returns the raw pointer to the object.

pub fn ptr_eq(a: &Self, b: &Self) -> bool

Returns true if the two RefPtrs point to the same object.

pub fn into_raw(this: Self) -> *const T

Consume the RefPtr and return the raw pointer without modifying the ref count.

The caller is responsible for maintaining the reference count.

pub fn try_pin_init<E>(init: impl PinInit<T, E>) -> Result<Self, E>

where T: UninitRecyclable, E: From<AllocError>,

Use the given pin-initializer to pin-initialize a T inside of a new RefPtr.

pub fn try_init<E>(init: impl Init<T, E>) -> Result<Self, E>

where T: UninitRecyclable, E: From<AllocError>,

Use the given initializer to in-place initialize a T inside of a new RefPtr.

pub fn pin_init(init: impl PinInit<T, Infallible>) -> Result<Self, AllocError>

where T: UninitRecyclable,

Use the given pin-initializer to pin-initialize a T inside of a new RefPtr.

pub fn init(init: impl Init<T, Infallible>) -> Result<Self, AllocError>

where T: UninitRecyclable,

Use the given initializer to in-place initialize a T inside of a new RefPtr.

Trait Implementations

impl<T: HasRefCount + Recyclable> Clone for RefPtr<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: HasRefCount + Recyclable> Deref for RefPtr<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: HasRefCount + Recyclable> Drop for RefPtr<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T: HasRefCount + Recyclable> PartialEq for RefPtr<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: HasRefCount + Recyclable> PtrTraits for RefPtr<T>

const IS_MANAGED: bool = true

Whether the pointer type is managed (e.g., UniquePtr or RefPtr).

type Target = T

The type pointed to by this pointer.

fn into_raw(self) -> *mut T

Consumes the pointer and returns a raw pointer to the target.

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

Creates an instance of Self from a raw pointer.

fn get_ref(&self) -> &T

Returns a reference to the target.

impl<T: HasRefCount + Recyclable> Eq for RefPtr<T>

impl<T: HasRefCount + Recyclable> ManagedPtr for RefPtr<T>

impl<T: HasRefCount + Recyclable + Send + Sync> Send for RefPtr<T>

impl<T: HasRefCount + Recyclable + Send + Sync> Sync for RefPtr<T>