Struct StrongRc

pub struct StrongRc<T> { /* private fields */ }

A strongly-held reference.

Similar to an alloc::sync::Arc but holding a Strong acts as a witness to the live-ness of the underlying data. That is, holding a Strong implies that the underlying data has not yet been destroyed.

Note that Strong’s implementation of Hash and PartialEq operate on the pointer itself and not the underlying data.

Implementations

impl<T> Strong<T>

pub fn downgrade(_: &Strong<T>) -> Weak<T>

Returns a weak reference pointing to the same underlying data.

pub fn debug_id(&self) -> impl Debug

Returns Debug implementation that is stable and unique for the data held behind this Strong.

pub fn resource_token(&self) -> ResourceToken<'_>

Returns a ResourceToken that corresponds to this object.

pub fn marked_for_destruction(_: &Strong<T>) -> bool

Returns true if the inner value has since been marked for destruction.

pub fn weak_ptr_eq(_: &Strong<T>, _: &Weak<T>) -> bool

Returns true if the two pointers point to the same allocation.

pub fn ptr_eq(_: &Strong<T>, _: &Strong<T>) -> bool

Returns true if the two pointers point to the same allocation.

pub fn ptr_cmp(_: &Strong<T>, _: &Strong<T>) -> Ordering

Compares the two pointers.

pub fn debug_references(this: &Strong<T>) -> DebugReferences<T>

Creates a DebugReferences instance.

Trait Implementations

impl<T> AsRef<T> for Strong<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Clone for Strong<T>

fn clone(&self) -> Strong<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Strong<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Strong<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> Drop for Strong<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Hash for Strong<T>

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for Strong<T>

fn eq(&self, other: &Strong<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> Eq for Strong<T>