Struct WeakPointer 

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

Weak variant of Pointer. WeakPointers are used to avoid deadlocking when dropping structures with cycled references to each other. In the following example Storage will stand in memory even after going out of scope, because there is cyclic referencing between Nodes

struct Node {
    next: Option<Pointer<Node>>,
}
let ptr1 = storage.create(Node { next: None });
let ptr2 = storage.create(Node { next: Some(ptr1.clone()) });
storage[&ptr1].next = Some(ptr2.clone());

To avoid such situations, just replace Option<Pointer<Node>> with Option<WeakPointer<Node>>

Example

let pointer = storage.create(1i32);
// create WeakPointer to this component
let weak = pointer.downgrade();

You will need to upgrade WeakPointer to access component in storage

let pointer = weak.upgrade()?;
storage[&pointer] = 20;

Implementations

impl<T> WeakPointer<T>

pub fn upgrade(&self) -> Result<Pointer<T>, DeadComponentError>

Upgrades the WeakPointer to a Pointer, if possible.

Errors

Returns DeadComponentError if the related component in storage was destroyed.

Examples found in repository

examples/weak.rs (line 31)

fn main() {
    let mut storage = Storage::new();
    let node1 = storage.create(Node {
        value: "Node 1".to_string(),
        next: None,
    });
    let node2 = storage.create(Node {
        value: "Node 2".to_string(),
        next: None,
    });

    storage[&node1].next = Some(node2.downgrade());
    storage[&node2].next = Some(node1.downgrade());

    for node in &storage {
        let value = node.next.as_ref().map_or("None".into(), |next| {
            let ptr = next.upgrade().unwrap();
            storage[&ptr].value.clone()
        });
        println!("{} has `next` field with value {}", node.value, value);
    }
}

Trait Implementations

impl<T> Clone for WeakPointer<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for WeakPointer<T>

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

Formats the value using the given formatter.

impl<T> Eq for WeakPointer<T>

impl<T> PartialEq for WeakPointer<T>

fn eq(&self, other: &WeakPointer<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.