Struct wobbly::sync::Wobbly

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

A thread-safe atomically reference-counting pointer, similar to Weak, which provides wobbly-shared ownership of a value of type T, allocated on the heap.

See the module-level documentation for more details.

A Wobbly<T> pointer is Send and Sync iff T is Send and Sync, just like Weak:

fn check_send_sync<T: Send + Sync>() {}

check_send_sync::<Wobbly<()>>()

fn check_send_sync<T: Send + Sync>() {}

// `Cell<()>` cannot be shared between threads safely
check_send_sync::<Wobbly<std::cell::Cell<()>>>()

fn check_send_sync<T: Send + Sync>() {}

// `MutexGuard<()>` cannot be sent between threads safely
check_send_sync::<Wobbly<std::sync::MutexGuard<()>>>()

Implementations

impl<T: ?Sized> Wobbly<T>

pub fn new(strong: Arc<T>) -> Self

Creates a new Wobbly<T> from an owning (strong) Arc pointer.

Wobbly::new creates a new group of Wobbly pointers, which keeps the inner value alive as long as none of the Wobblys is dropped. To extend an existing group, clone one of its Wobbly pointers.

pub fn downgrade(&self) -> Weak<T>

Creates a new Weak pointer to this allocation.

pub fn upgrade(&self) -> Option<Arc<T>>

Attempts to upgrade the Wobbly pointer to an Arc, delaying dropping of the inner value if successful.

Returns None if the inner value has since been dropped.

pub fn weak_count(&self) -> usize

Gets the number of weak pointers pointing to this allocation.

Note that this Wobbly counts as one weak pointer.

pub fn strong_count(&self) -> usize

Gets the number of strong pointers pointing to this allocation.

Note that one group of Wobblys that was created only by clone-ing counts as one strong pointer as long as none of the group members has been dropped.

Trait Implementations

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

fn clone(&self) -> Self

Makes a clone of the Wobbly pointer that points to the same allocation.

Cloning a Wobbly pointer also extends its group of Wobblys that share the same one owning pointer. If this owning pointer has not yet been released, the newly cloned Wobbly will release it if it is the first Wobbly pointer of the group to be dropped.

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

Performs copy-assignment from source.

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

fn drop(&mut self)

Drops the Wobbly pointer, which releases one non-owning (weak) pointer to the value. If this Wobbly is the first of its group, created only by clone-ing, that is dropped, an owning (strong) pointer is released as well, and the value may be dropped iff this was the last remaining owning (strong) pointer.