Struct netstack3_core::sync::PrimaryRc

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

A primary reference.

Note that only one Primary may be associated with data. This is enforced by not implementing Clone.

For now, this reference is no different than a Strong but later changes will enable blocking the destruction of a primary reference until all strongly held references are dropped.

Implementations

impl<T> Primary<T>

pub fn new(data: T) -> Primary<T>

Returns a new strongly-held reference.

pub fn new_cyclic(data_fn: impl FnOnce(Weak<T>) -> T) -> Primary<T>

Constructs a new Primary<T> while giving you a Weak to the allocation, to allow you to construct a T which holds a weak pointer to itself.

Like for [Arc::new_cyclic], the Weak reference provided to data_fn cannot be upgraded until the Primary is constructed.

pub fn clone_strong(_: &Primary<T>) -> Strong<T>

Clones a strongly-held reference.

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

Returns a weak reference pointing to the same underlying data.

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

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

pub fn debug_id(&self) -> impl Debug

Returns core::fmt::Debug implementation that is stable and unique for the data held behind this Primary.

pub fn unwrap(this: Primary<T>) -> T

Returns the inner value if no Strong references are held.

Panics

Panics if Strong references are held when this function is called.

pub fn unwrap_with_notifier<N>(this: Primary<T>, notifier: N)

where N: Notifier<T> + 'static,

Marks this Primary for destruction and uses notifier as a signaler for when destruction of all strong references is terminated. After calling unwrap_with_notifier Weak references can no longer be upgraded.

pub fn unwrap_or_notify_with<N, O, F>( this: Primary<T>, new_notifier: F, ) -> Result<T, O>

where N: Notifier<T> + 'static, F: FnOnce() -> (N, O),

Marks this Primary for destruction and returns Ok if this was the last strong reference standing for it. Otherwise new_notifier is called to create a new notifier to observe deferred destruction.

Like Primary::unwrap_with_notifier, Weak references can no longer be upgraded after calling unwrap_or_notify_with.

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

Creates a DebugReferences instance.

Trait Implementations

impl<T> AsRef<T> for Primary<T>

fn as_ref(&self) -> &T

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

impl<T> Debug for Primary<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Primary<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> Drop for Primary<T>

fn drop(&mut self)

Executes the destructor for this type.