Struct WeakList 

pub struct WeakList<T>
where
    T: ?Sized,
{ /* private fields */ }

A list holding weak references to its elements.

The list does not hold strong references to its elements and the elements do not hold strong references to the list. You must use some other mechanism to keep all parties alive.

This list supports concurrent iteration and modification.

Examples

use {
    weak_lists::{WeakList, WeakListElement},
    std::{
        array,
        rc::{Rc, Weak},
    },
};

pub struct Service {
    callbacks: WeakList<dyn Callback>,
}

pub trait Callback {
    fn run(&self);
}

impl Service {
    pub fn register_callback(&self, callback: &WeakListElement<dyn Callback>) {
        callback.attach(&self.callbacks);
    }

    pub fn run_callbacks(&self) {
        for callback in &self.callbacks {
            callback.run();
        }
    }
}

struct Client {
    id: usize,
    entry: WeakListElement<dyn Callback>,
}

impl Callback for Client {
    fn run(&self) {
        eprintln!("Callback {} invoked", self.id);
        if self.id == 1 {
            self.entry.detach();
        }
    }
}

let service = Service {
    callbacks: Default::default(),
};
let clients = array::from_fn::<_, 3, _>(|id| {
    Rc::<Client>::new_cyclic(|slf| Client {
        id,
        entry: WeakListElement::new(slf.clone()),
    })
});
for client in &clients {
    service.register_callback(&client.entry);
}
service.run_callbacks();
// Callback 0 invoked
// Callback 1 invoked
// Callback 2 invoked
service.run_callbacks();
// Callback 0 invoked
// Callback 2 invoked

Implementations

impl<T> WeakList<T>

where T: ?Sized,

pub fn clear(&self)

Removes all elements from the list.

Examples

use std::rc::{Rc, Weak};
use weak_lists::{WeakList, WeakListElement};

let list = WeakList::default();
let entry = Rc::new(1);
let entry = WeakListElement::new(Rc::downgrade(&entry));
entry.attach(&list);
assert!(list.iter().next().is_some());
list.clear();
assert!(list.iter().next().is_none());

pub fn iter(&self) -> Iter<'_, T>

Creates an iterator over the entries of the list.

The list can be mutated during the iteration. It is guaranteed that, if an element was part of the list when this iterator was created, and if the element was not removed during the iteration, then the element will be returned exactly once by this iterator.

Trait Implementations

impl<T> Debug for WeakList<T>

where T: ?Sized,

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

Formats the value using the given formatter.

impl<T> Default for WeakList<T>

where T: ?Sized,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> IntoIterator for &'a WeakList<T>

where T: ?Sized,

type Item = Rc<T>

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.