Add traverse functions for NodeMut

Author: remimimimimi

src/lib.rs

@@ -369,6 +369,11 @@ impl<'a, T: 'a> NodeMut<'a, T> {
         &mut self.node().value
     }
 
+    /// Downcast `NodeMut` to `NodeRef`.
+    pub fn as_ref(&mut self) -> NodeRef<'_, T> {
+        unsafe { self.tree.get_unchecked(self.id) }
+    }
+
     fn axis<F>(&mut self, f: F) -> Option<NodeMut<T>>
     where
         F: FnOnce(&mut Node<T>) -> Option<NodeId>,
@@ -463,6 +468,122 @@ impl<'a, T: 'a> NodeMut<'a, T> {
         unsafe { self.tree.get_unchecked(self.id).has_children() }
     }
 
+    /// Apply function for each ancestor mutable node reference.
+    pub fn for_each_ancestor<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&mut NodeMut<T>),
+    {
+        if let Some(mut parent_node) = self.parent() {
+            f(&mut parent_node);
+            while let Ok(mut n) = parent_node.into_parent() {
+                f(&mut n);
+                parent_node = n;
+            }
+        }
+    }
+
+    /// Apply function for each next sibling mutable node reference.
+    pub fn for_each_next_sibling<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&mut NodeMut<T>),
+    {
+        if let Some(mut next_sibling_node) = self.next_sibling() {
+            f(&mut next_sibling_node);
+            while let Ok(mut n) = next_sibling_node.into_next_sibling() {
+                f(&mut n);
+                next_sibling_node = n;
+            }
+        }
+    }
+
+    /// Apply function for each previout sibling mutable node reference.
+    pub fn for_each_prev_sibling<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&mut NodeMut<T>),
+    {
+        if let Some(mut prev_sibling_node) = self.prev_sibling() {
+            f(&mut prev_sibling_node);
+            while let Ok(mut n) = prev_sibling_node.into_prev_sibling() {
+                f(&mut n);
+                prev_sibling_node = n;
+            }
+        }
+    }
+
+    /// Apply function for this node and each sibling mutable node reference.
+    pub fn for_each_sibling<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&mut NodeMut<T>),
+    {
+        f(self);
+        self.for_each_prev_sibling(&mut f);
+        self.for_each_next_sibling(&mut f);
+    }
+
+    /// Apply function for each children mutable node reference.
+    pub fn for_each_child<F>(&mut self, f: F)
+    where
+        F: FnMut(&mut NodeMut<T>),
+    {
+        if let Some(mut first_child) = self.first_child() {
+            first_child.for_each_sibling(f);
+        }
+    }
+
+    /// Apply function for this node and each descendant mutable node reference.
+    pub fn for_each_descendant<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&mut NodeMut<T>),
+    {
+        let id = self.id();
+
+        f(self);
+
+        // Start at our first child, if any.
+        if let Some(mut node) = self.first_child() {
+            loop {
+                f(&mut node);
+
+                // Try to go deeper into its first child.
+                match node.into_first_child() {
+                    Ok(child) => {
+                        node = child;
+                        continue;
+                    }
+                    Err(n) => {
+                        node = n;
+                    }
+                }
+
+                // No deeper child, so climb until we find a next sibling or hit self.
+                loop {
+                    match node.into_next_sibling() {
+                        Ok(sib) => {
+                            node = sib;
+                            break;
+                        }
+                        Err(n) => {
+                            node = n;
+                        }
+                    }
+
+                    // No sibling, so climb up.
+                    match node.into_parent() {
+                        Ok(parent) => {
+                            if parent.id() == id {
+                                return;
+                            }
+                            node = parent;
+                        }
+                        Err(_) => {
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     /// Appends a new child to this node.
     pub fn append(&mut self, value: T) -> NodeMut<T> {
         let id = self.tree.orphan(value).id;

tests/node_mut.rs

@@ -74,6 +74,77 @@ fn has_children() {
     assert!(!tree.root_mut().first_child().unwrap().has_children());
 }
 
+#[test]
+fn for_each_next_sibling() {
+    let mut tree = tree!(1 => { 2, 3, 4, 5, 6 });
+    let mut root = tree.root_mut();
+    let mut c = root.first_child().unwrap();
+
+    c.for_each_next_sibling(|n| {
+        *n.value() += 1;
+    });
+
+    let res = tree!(1 => { 2, 4, 5, 6, 7 });
+
+    assert_eq!(tree, res);
+}
+
+#[test]
+fn for_each_prev_sibling() {
+    let mut tree = tree!(1 => { 2, 3, 4, 5, 6 });
+    let mut root = tree.root_mut();
+    let mut c = root.last_child().unwrap();
+
+    c.for_each_prev_sibling(|n| {
+        *n.value() += 1;
+    });
+
+    let res = tree!(1 => { 3, 4, 5, 6, 6 });
+
+    assert_eq!(tree, res);
+}
+
+#[test]
+fn for_each_sibling() {
+    let rt = 2;
+    let mut tree = tree!(rt => { 2, 3, 4, 5, 6 });
+    let mut root = tree.root_mut();
+    let mut c = root.last_child().unwrap();
+
+    c.for_each_sibling(|n| {
+        let v = n.parent().map(|mut p| *p.value()).unwrap();
+        *n.value() += v;
+    });
+
+    let res = tree!(rt => { 4, 5, 6, 7, 8 });
+
+    assert_eq!(tree, res);
+}
+
+#[test]
+fn for_each_child() {
+    let mut tree = tree!(1 => { 2, 3, 4, 5, 6 });
+    let mut root = tree.root_mut();
+    root.for_each_child(|n| *n.value() += 1);
+
+    assert_eq!(*root.value(), 1);
+
+    let res = tree!(1 => { 3, 4, 5, 6, 7 });
+
+    assert_eq!(tree, res);
+}
+
+#[test]
+fn for_each_descendant() {
+    let mut tree = tree!(1 => { 2 => {3, 4, 5, 6}, 3, 4 => {0, 1}, 5, 6 => {1, 2} });
+    let mut root = tree.root_mut();
+    root.for_each_descendant(|n| *n.value() += 1);
+
+    let tree2 = tree!(2 => { 3 => {4, 5, 6, 7}, 4, 5 => {1, 2}, 6, 7 => {2, 3} });
+
+    assert_eq!(tree, tree2);
+}
+
 #[test]
 fn append_1() {
     let mut tree = tree!('a');