Iterators take cell-stacks

src/hex_tree_map.rs

@@ -2,6 +2,7 @@
 
 pub use crate::entry::{Entry, OccupiedEntry, VacantEntry};
 use crate::{
+    cell::CellStack,
     compaction::{Compactor, NullCompactor},
     digits::Digits,
     node::Node,
@@ -231,13 +232,13 @@ impl<V, C> HexTreeMap<V, C> {
 
     /// An iterator visiting all cell-value pairs in arbitrary order.
     pub fn iter(&self) -> impl Iterator<Item = (Cell, &V)> {
-        crate::iteration::Iter::new(&self.nodes)
+        crate::iteration::Iter::new(&self.nodes, CellStack::new())
     }
 
     /// An iterator visiting all cell-value pairs in arbitrary order
     /// with mutable references to the values.
     pub fn iter_mut(&mut self) -> impl Iterator<Item = (Cell, &mut V)> {
-        crate::iteration::IterMut::new(&mut self.nodes)
+        crate::iteration::IterMut::new(&mut self.nodes, CellStack::new())
     }
 }
 

src/iteration.rs

@@ -29,12 +29,11 @@ pub(crate) struct Iter<'a, V> {
 }
 
 impl<'a, V> Iter<'a, V> {
-    pub(crate) fn new(base: &'a [Option<Box<Node<V>>>]) -> Self {
+    pub(crate) fn new(base: &'a [Option<Box<Node<V>>>], mut cell_stack: CellStack) -> Self {
         let mut iter = make_node_stack_iter(base);
         let curr = iter.next();
         let mut stack = Vec::with_capacity(16);
         stack.push(iter);
-        let mut cell_stack = CellStack::new();
         if let Some((digit, _)) = curr {
             cell_stack.push(digit as u8)
         }
@@ -119,12 +118,11 @@ pub(crate) struct IterMut<'a, V> {
 }
 
 impl<'a, V> IterMut<'a, V> {
-    pub(crate) fn new(base: &'a mut [Option<Box<Node<V>>>]) -> Self {
+    pub(crate) fn new(base: &'a mut [Option<Box<Node<V>>>], mut cell_stack: CellStack) -> Self {
         let mut iter = make_node_stack_iter_mut(base);
         let curr = iter.next();
         let mut stack = Vec::with_capacity(16);
         stack.push(iter);
-        let mut cell_stack = CellStack::new();
         if let Some((digit, _)) = curr {
             cell_stack.push(digit as u8)
         }