85 lines
1.6 KiB
Rust
85 lines
1.6 KiB
Rust
use crate::nodes::Node;
|
|
use parking_lot::Mutex;
|
|
use rustc_hash::FxHashMap;
|
|
use std::{
|
|
borrow::Borrow,
|
|
hash::Hash,
|
|
sync::{Arc, Weak},
|
|
};
|
|
|
|
#[derive(Default)]
|
|
pub struct LifeLinkedNodeList {
|
|
nodes: Mutex<Vec<Weak<Node>>>,
|
|
}
|
|
impl LifeLinkedNodeList {
|
|
pub fn add(&self, node: Weak<Node>) {
|
|
self.nodes.lock().push(node);
|
|
}
|
|
|
|
pub fn clear(&self) {
|
|
self.nodes
|
|
.lock()
|
|
.iter()
|
|
.filter_map(|node| node.upgrade())
|
|
.for_each(|node| {
|
|
node.destroy();
|
|
});
|
|
self.nodes.lock().clear();
|
|
}
|
|
}
|
|
impl Drop for LifeLinkedNodeList {
|
|
fn drop(&mut self) {
|
|
self.clear();
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct LifeLinkedNodeMap<K: Hash + Eq> {
|
|
nodes: Mutex<FxHashMap<K, Weak<Node>>>,
|
|
}
|
|
#[allow(dead_code)]
|
|
impl<K: Hash + Eq> LifeLinkedNodeMap<K> {
|
|
pub fn add(&self, key: K, node: &Arc<Node>) {
|
|
self.nodes.lock().insert(key, Arc::downgrade(node));
|
|
}
|
|
pub fn get<Q>(&self, key: &Q) -> Option<Arc<Node>>
|
|
where
|
|
Q: ?Sized,
|
|
K: Borrow<Q>,
|
|
Q: Hash + Eq,
|
|
{
|
|
self.nodes.lock().get(key).and_then(|n| n.upgrade())
|
|
}
|
|
pub fn nodes(&self) -> Vec<Arc<Node>> {
|
|
self.nodes
|
|
.lock()
|
|
.values()
|
|
.filter_map(|v| v.upgrade())
|
|
.collect()
|
|
}
|
|
pub fn remove<Q>(&self, key: &Q) -> Option<Arc<Node>>
|
|
where
|
|
Q: ?Sized,
|
|
K: Borrow<Q>,
|
|
Q: Hash + Eq,
|
|
{
|
|
self.nodes.lock().remove(key).and_then(|n| n.upgrade())
|
|
}
|
|
|
|
pub fn clear(&self) {
|
|
let mut nodes = self.nodes.lock();
|
|
nodes
|
|
.values()
|
|
.filter_map(|node| node.upgrade())
|
|
.for_each(|node| {
|
|
node.destroy();
|
|
});
|
|
nodes.clear();
|
|
}
|
|
}
|
|
impl<K: Hash + Eq> Drop for LifeLinkedNodeMap<K> {
|
|
fn drop(&mut self) {
|
|
self.clear();
|
|
}
|
|
}
|