ade_graph/implementations/
node.rs

1use ade_traits::NodeTrait;
2use std::collections::HashSet;
3
4#[derive(Debug, Clone)]
5pub struct Node {
6    key: u32,
7    predecessors: HashSet<u32>,
8    successors: HashSet<u32>,
9}
10
11impl Node {
12    pub fn new(key: u32) -> Self {
13        Node {
14            key,
15            predecessors: HashSet::new(),
16            successors: HashSet::new(),
17        }
18    }
19}
20
21impl NodeTrait for Node {
22    fn new(key: u32) -> Self {
23        Node::new(key)
24    }
25
26    fn key(&self) -> u32 {
27        self.key
28    }
29
30    fn fresh_copy(&self) -> Self {
31        Node {
32            key: self.key,
33            predecessors: HashSet::new(),
34            successors: HashSet::new(),
35        }
36    }
37
38    fn predecessors(&self) -> &HashSet<u32> {
39        &self.predecessors
40    }
41
42    fn successors(&self) -> &HashSet<u32> {
43        &self.successors
44    }
45
46    fn add_predecessor(&mut self, key: u32) {
47        self.predecessors.insert(key);
48    }
49
50    fn add_successor(&mut self, key: u32) {
51        self.successors.insert(key);
52    }
53
54    fn remove_predecessor(&mut self, key: u32) {
55        self.predecessors.remove(&key);
56    }
57
58    fn remove_successor(&mut self, key: u32) {
59        self.successors.remove(&key);
60    }
61}
62
63#[cfg(test)]
64mod tests {
65    use super::*;
66
67    #[test]
68    fn test_node_creation() {
69        let node = Node::new(1);
70        assert_eq!(node.key(), 1);
71        assert!(node.predecessors().is_empty());
72        assert!(node.successors().is_empty());
73    }
74
75    #[test]
76    fn test_fresh_copy() {
77        let mut node = Node::new(42);
78        node.add_predecessor(1);
79        node.add_successor(2);
80
81        let fresh_node = node.fresh_copy();
82
83        assert_eq!(fresh_node.key(), 42);
84        assert!(fresh_node.predecessors().is_empty());
85        assert!(fresh_node.successors().is_empty());
86    }
87
88    #[test]
89    fn test_add_predecessor() {
90        let mut node = Node::new(1);
91        node.add_predecessor(2);
92        assert!(node.predecessors().contains(&2));
93    }
94
95    #[test]
96    fn test_add_successor() {
97        let mut node = Node::new(1);
98        node.add_successor(2);
99        assert!(node.successors().contains(&2));
100    }
101
102    #[test]
103    fn test_remove_predecessor() {
104        let mut node = Node::new(1);
105        node.add_predecessor(2);
106        node.remove_predecessor(2);
107        assert!(!node.predecessors().contains(&2));
108    }
109
110    #[test]
111    fn test_remove_successor() {
112        let mut node = Node::new(1);
113        node.add_successor(2);
114        node.remove_successor(2);
115        assert!(!node.successors().contains(&2));
116    }
117
118    #[test]
119    fn test_multiple_connections() {
120        let mut node = Node::new(1);
121
122        // Add multiple predecessors and successors
123        node.add_predecessor(2);
124        node.add_predecessor(3);
125        node.add_successor(4);
126        node.add_successor(5);
127
128        assert_eq!(node.predecessors().len(), 2);
129        assert_eq!(node.successors().len(), 2);
130        assert!(node.predecessors().contains(&2));
131        assert!(node.predecessors().contains(&3));
132        assert!(node.successors().contains(&4));
133        assert!(node.successors().contains(&5));
134
135        // Remove some connections
136        node.remove_predecessor(2);
137        node.remove_successor(4);
138
139        assert_eq!(node.predecessors().len(), 1);
140        assert_eq!(node.successors().len(), 1);
141        assert!(!node.predecessors().contains(&2));
142        assert!(node.predecessors().contains(&3));
143        assert!(!node.successors().contains(&4));
144        assert!(node.successors().contains(&5));
145    }
146
147    #[test]
148    fn test_duplicate_connections() {
149        let mut node = Node::new(1);
150
151        // Adding the same predecessor twice should not duplicate
152        node.add_predecessor(2);
153        node.add_predecessor(2);
154        assert_eq!(node.predecessors().len(), 1);
155
156        // Adding the same successor twice should not duplicate
157        node.add_successor(3);
158        node.add_successor(3);
159        assert_eq!(node.successors().len(), 1);
160    }
161}
ade_graph/implementations/node.rs

ade_graph/implementations/
node.rs
