Struct Ref

pub struct Ref<T: ?Sized> { /* private fields */ }

A weak reference-counted reference to a RefBox.

See the module documentation for more information.

Implementations

impl<T: ?Sized> Ref<T>

pub fn try_borrow_mut<'rc>(&'rc self) -> Result<Borrow<'rc, T>, BorrowError>

Tries to borrow the data mutably.

Returns

• Ok(Borrow) if the borrow was successful
• Err(BorrowError::Borrowed) if the data was already borrowed
• Err(BorrowError::Dropped) if the owning RefBox was dropped

pub fn try_borrow_mut_or_else<'rc, E>( &'rc self, err_borrowed: impl FnOnce() -> E, err_dropped: impl FnOnce() -> E, ) -> Result<Borrow<'rc, T>, E>

Tries to borrow the data mutably and returns a custom error if borrowing fails.

pub fn try_access_mut<R, F: FnOnce(&mut T) -> R>( &self, op: F, ) -> Result<R, BorrowError>

Provides access to the data through a closure.

If the data is already borrowed or the owning RefBox is dropped, the closure is not executed and an error is returned. Otherwise, the closure is executed and the output of the closure is returned.

Returns

• Ok(R) if the access was successful
• Err(BorrowError::Borrowed) if the data was already borrowed
• Err(BorrowError::Dropped) if the owning RefBox was dropped

pub fn try_clone(&self) -> Option<Ref<T>>

Tries to clone the weak reference to the data.

Returns

• Some(Ref) if it was succesful.
• None if the number of weaks overflowed u32::MAX.

pub fn refcount(&self) -> u32

Returns the number of Refs that point to the same data as this Ref.

pub fn is_alive(&self) -> bool

Returns true if the owner of the data is alive.

pub fn is_borrowed(&self) -> bool

Returns true if the data is currently mutably borrowed.

pub fn is(&self, owner: &RefBox<T>) -> bool

Returns true if this Ref and the supplied RefBox point to the same instance.

pub unsafe fn get_unchecked(&self) -> &T

Returns an immutable reference to the data without checking if the data is already mutably borrowed or dropped.

Safety

1. Ensure there are no mutable references to T.
2. Ensure T is fully initialized (don’t use this in RefBox::new_cyclic).
3. Ensure the owning RefBox is alive for the entire lifetime of the returned reference.

pub unsafe fn get_mut_unchecked(&mut self) -> &mut T

Returns a mutable reference to the data without checking if the data is already mutably borrowed or dropped.

Safety

1. Ensure there are no other references to T.
2. Ensure T is fully initialized (don’t use this in RefBox::new_cyclic).
3. Ensure the owning RefBox is alive for the entire lifetime of the returned reference.

pub fn as_ptr(&self) -> *const T

Returns a raw pointer to T.

pub fn into_raw(self) -> *mut RefBoxHeap<T>

Turns the Ref into a raw pointer.

pub unsafe fn from_raw(ptr: *mut RefBoxHeap<T>) -> Self

Creates a Ref from a raw pointer.

pub unsafe fn cast<U>(self) -> Ref<U>

Casts a Ref<T> to a Ref<U>.

Trait Implementations

impl<T: ?Sized> Clone for Ref<T>

fn clone(&self) -> Self

Copies the reference and increases the reference counter.

Panics

Panics if the number of Refs overflows u32::MAX.

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

Performs copy-assignment from source.

impl<T: ?Sized> Debug for Ref<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Drop for Ref<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ?Sized> PartialEq<Ref<T>> for RefBox<T>

fn eq(&self, other: &Ref<T>) -> 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: ?Sized> PartialEq<RefBox<T>> for Ref<T>

fn eq(&self, other: &RefBox<T>) -> 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: ?Sized> PartialEq for Ref<T>

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

Returns true if both Refs point to the same instance.

This compares the pointers, not the actual object itself, which means it is very fast.

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: ?Sized> Eq for Ref<T>