depends 0.11.0

Ergonomic, performant, incremental computation between arbitrary types
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

use std::hash::BuildHasher;

use hashbrown::HashSet;

use super::Visitor;
use crate::execution::Identifiable;

pub type HashBrownVisitor = HashSet<usize>;

impl Visitor for HashBrownVisitor {
    type Hasher = ahash::AHasher;

    fn visit<N>(&mut self, node: &N) -> bool
    where
        N: Identifiable,
    {
        self.insert(node.id())
    }

    fn clear(&mut self) {
        self.clear()
    }

    fn hasher(&self) -> Self::Hasher {
        self.hasher().build_hasher()
    }
}

#[cfg(test)]
mod tests {
    use serial_test::serial;

    use super::*;
    use crate::{
        execution::{
            identifiable::reset_node_id, internal_test_utils::TestData,
            visitor::hash_one_ext::hash_one,
        },
        InputNode,
    };

    #[test]
    #[serial]
    fn test_hashbrown_visitor() {
        reset_node_id();
        let node_1 = InputNode::new(TestData::new(5));
        let _ = InputNode::new(TestData::new(0));
        let node_2 = InputNode::new(TestData::new(6));
        let mut visitor = HashBrownVisitor::new();
        visitor.visit(&node_1);
        visitor.visit(&node_2);
        assert_eq!(visitor.len(), 2);
        assert!(visitor.contains(&0));
        assert!(visitor.contains(&2));
        visitor.clear();
        assert_eq!(visitor.len(), 0);
        let hasher_b = visitor.hasher();
        let hasher_a = visitor.hasher();
        assert_eq!(hash_one(hasher_a, 654), hash_one(hasher_b, 654));
    }
}