Final fix to DFS iter (#54)

* finally fix dfs

* bump ver

Author: matth2k

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "safety-net"
-version = "0.2.9"
+version = "0.2.10"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 

src/netlist.rs

@@ -1781,12 +1781,13 @@ pub mod iter {
     }
 
     /// A stack that can check contains in roughly O(1) time.
-    struct Stack<T: std::hash::Hash + PartialEq + Eq + Clone> {
+    #[derive(Clone)]
+    struct Walk<T: std::hash::Hash + PartialEq + Eq + Clone> {
         stack: Vec<T>,
         counter: HashMap<T, usize>,
     }
 
-    impl<T> Stack<T>
+    impl<T> Walk<T>
     where
         T: std::hash::Hash + PartialEq + Eq + Clone,
     {
@@ -1804,24 +1805,14 @@ pub mod iter {
             *self.counter.entry(item).or_insert(0) += 1;
         }
 
-        /// Pops the top element from the stack
-        fn pop(&mut self) -> Option<T> {
-            if let Some(item) = self.stack.pop() {
-                if let Some(count) = self.counter.get_mut(&item) {
-                    *count -= 1;
-                    if *count == 0 {
-                        self.counter.remove(&item);
-                    }
-                }
-                Some(item)
-            } else {
-                None
-            }
+        /// Returns true if the stack shows a cycle
+        fn contains_cycle(&self) -> bool {
+            self.counter.values().any(|&count| count > 1)
         }
 
-        /// Checks if the stack contains the given element
-        fn contains(&self, item: &T) -> bool {
-            self.counter.contains_key(item)
+        /// Returns a reference to the last element in the stack
+        fn last(&self) -> Option<&T> {
+            self.stack.last()
         }
     }
 
@@ -1845,7 +1836,7 @@ pub mod iter {
     /// ```
     pub struct DFSIterator<'a, I: Instantiable> {
         netlist: &'a Netlist<I>,
-        stack: Stack<NetRef<I>>,
+        stacks: Vec<Walk<NetRef<I>>>,
         visited: HashSet<usize>,
         cycles: bool,
     }
@@ -1856,11 +1847,11 @@ pub mod iter {
     {
         /// Create a new DFS iterator for the netlist starting at `from`.
         pub fn new(netlist: &'a Netlist<I>, from: NetRef<I>) -> Self {
-            let mut s = Stack::new();
+            let mut s = Walk::new();
             s.push(from);
             Self {
                 netlist,
-                stack: s,
+                stacks: vec![s],
                 visited: HashSet::new(),
                 cycles: false,
             }
@@ -1899,25 +1890,25 @@ pub mod iter {
         type Item = NetRef<I>;
 
         fn next(&mut self) -> Option<Self::Item> {
-            if let Some(item) = self.stack.pop() {
-                let uw = item.clone().unwrap();
+            if let Some(walk) = self.stacks.pop() {
+                let item = walk.last().cloned();
+                let uw = item.clone().unwrap().unwrap();
                 let index = uw.borrow().get_index();
                 if self.visited.insert(index) {
                     let operands = &uw.borrow().operands;
                     for operand in operands.iter().flatten() {
-                        self.stack
-                            .push(NetRef::wrap(self.netlist.index_weak(&operand.root())));
+                        let mut new_walk = walk.clone();
+                        new_walk.push(NetRef::wrap(self.netlist.index_weak(&operand.root())));
+                        if !new_walk.contains_cycle() {
+                            self.stacks.push(new_walk);
+                        } else {
+                            self.cycles = true;
+                        }
                     }
-                } else {
-                    self.cycles = true;
+                    return item;
                 }
 
-                return if self.stack.contains(&item) {
-                    self.cycles = true;
-                    self.next()
-                } else {
-                    Some(item)
-                };
+                return self.next();
             }
 
             None