Struct Weak 

pub struct Weak<T, A = Global>
where
    T: ?Sized,
    A: Allocator,
{ /* private fields */ }

Weak is a version of Arc that holds a non-owning reference to the managed allocation.

The allocation is accessed by calling upgrade on the Weak pointer, which returns an Option<Arc<T>>.

Since a Weak reference does not count towards ownership, it will not prevent the value stored in the allocation from being dropped, and Weak itself makes no guarantees about the value still being present. Thus it may return None when upgraded. Note however that a Weak reference does prevent the allocation itself (the backing store) from being deallocated.

A Weak pointer is useful for keeping a temporary reference to the allocation managed by Arc without preventing its inner value from being dropped. It is also used to prevent circular references between Arc pointers, since mutual owning references would never allow either Arc to be dropped. For example, a tree could have strong Arc pointers from parent nodes to children, and Weak pointers from children back to their parents.

The typical way to obtain a Weak pointer is to call Arc::downgrade.

Implementations

impl<T, A> Weak<T, A>

where T: ?Sized, A: Allocator,

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

where A: Clone,

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

Returns None if the inner value has since been dropped.

Examples

use rune::sync::Arc;

let five = Arc::try_new(5)?;

let weak_five = Arc::downgrade(&five);

let strong_five: Option<Arc<_>> = weak_five.upgrade();
assert!(strong_five.is_some());

// Destroy all strong pointers.
drop(strong_five);
drop(five);

assert!(weak_five.upgrade().is_none());

pub fn strong_count(&self) -> usize

Gets the number of strong (Arc) pointers pointing to this allocation.

pub fn weak_count(&self) -> usize

Gets an approximation of the number of Weak pointers pointing to this allocation.

Accuracy

Due to implementation details, the returned value can be off by 1 in either direction when other threads are manipulating any Arcs or Weaks pointing to the same allocation.

Trait Implementations

impl<T, A> Clone for Weak<T, A>

where T: ?Sized, A: Allocator + Clone,

fn clone(&self) -> Weak<T, A>

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

Examples

use rune::alloc::sync::{Arc, Weak};

let weak_five = Arc::downgrade(&Arc::try_new(5)?);

let _ = Weak::clone(&weak_five);

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

Performs copy-assignment from source.

impl<T, A> Debug for Weak<T, A>

where T: ?Sized, A: Allocator,

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

Formats the value using the given formatter.

impl<T, A> Drop for Weak<T, A>

where T: ?Sized, A: Allocator,

fn drop(&mut self)

Drops the Weak pointer.

Examples

use rune::alloc::sync::{Arc, Weak};

struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {
        println!("dropped!");
    }
}

let foo = Arc::try_new(Foo)?;
let weak_foo = Arc::downgrade(&foo);
let other_weak_foo = Weak::clone(&weak_foo);

drop(weak_foo);   // Doesn't print anything
drop(foo);        // Prints "dropped!"

assert!(other_weak_foo.upgrade().is_none());

impl<T, A> Send for Weak<T, A>

where T: ?Sized + Sync + Send, A: Allocator + Send,

impl<T, A> Sync for Weak<T, A>

where T: ?Sized + Sync + Send, A: Allocator + Sync,