hyphae 3.1.0

Reactive cells and runtime primitives for rship
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::hash::Hash;

use rustc_hash::FxHashSet;

/// Reusable insertion-ordered set for deterministic incremental work lists.
pub(super) struct OrderedSet<T> {
    seen: FxHashSet<T>,
    values: Vec<T>,
}

impl<T> Default for OrderedSet<T> {
    fn default() -> Self {
        Self {
            seen: FxHashSet::default(),
            values: Vec::new(),
        }
    }
}

impl<T> OrderedSet<T>
where
    T: Hash + Eq + Clone,
{
    pub(super) fn insert(&mut self, value: T) -> bool {
        if self.seen.insert(value.clone()) {
            self.values.push(value);
            true
        } else {
            false
        }
    }

    pub(super) fn extend(&mut self, values: impl IntoIterator<Item = T>) {
        for value in values {
            self.insert(value);
        }
    }

    pub(super) fn drain(&mut self) -> std::vec::IntoIter<T> {
        self.seen.clear();
        std::mem::take(&mut self.values).into_iter()
    }

    /// Move the ordered values into a reusable sibling buffer.
    ///
    /// Swapping rather than collecting preserves both vectors' allocations
    /// across callbacks, which matters for the one-row incremental fast path.
    pub(super) fn move_into(&mut self, buffer: &mut Vec<T>) {
        self.seen.clear();
        buffer.clear();
        std::mem::swap(&mut self.values, buffer);
    }

    pub(super) fn clear(&mut self) {
        self.seen.clear();
        self.values.clear();
    }

    pub(super) fn contains(&self, value: &T) -> bool {
        self.seen.contains(value)
    }

    pub(super) fn iter(&self) -> std::slice::Iter<'_, T> {
        self.values.iter()
    }

    pub(super) fn remove(&mut self, value: &T) -> bool {
        if !self.seen.remove(value) {
            return false;
        }
        self.values.retain(|candidate| candidate != value);
        true
    }

    pub(super) const fn is_empty(&self) -> bool {
        self.values.is_empty()
    }

    pub(super) fn retain(&mut self, mut keep: impl FnMut(&T) -> bool) {
        let seen = &mut self.seen;
        self.values.retain(|value| {
            let retained = keep(value);
            if !retained {
                seen.remove(value);
            }
            retained
        });
    }
}