Merge pull request #32 from adamreichold/fuse-traverse

Implement FusedIterator trait for the various iterators provided by this crate

Author: cfvescovo

src/iter.rs

@@ -1,3 +1,4 @@
+use std::iter::FusedIterator;
 use std::ops::Range;
 use std::{slice, vec};
 
@@ -7,6 +8,7 @@ use crate::{Node, NodeId, NodeRef, Tree};
 #[derive(Debug)]
 pub struct IntoIter<T>(vec::IntoIter<Node<T>>);
 impl<T> ExactSizeIterator for IntoIter<T> {}
+impl<T> FusedIterator for IntoIter<T> {}
 impl<T> Iterator for IntoIter<T> {
     type Item = T;
     fn next(&mut self) -> Option<Self::Item> {
@@ -31,6 +33,7 @@ impl<'a, T: 'a> Clone for Values<'a, T> {
     }
 }
 impl<'a, T: 'a> ExactSizeIterator for Values<'a, T> {}
+impl<'a, T: 'a> FusedIterator for Values<'a, T> {}
 impl<'a, T: 'a> Iterator for Values<'a, T> {
     type Item = &'a T;
     fn next(&mut self) -> Option<Self::Item> {
@@ -50,6 +53,7 @@ impl<'a, T: 'a> DoubleEndedIterator for Values<'a, T> {
 #[derive(Debug)]
 pub struct ValuesMut<'a, T: 'a>(slice::IterMut<'a, Node<T>>);
 impl<'a, T: 'a> ExactSizeIterator for ValuesMut<'a, T> {}
+impl<'a, T: 'a> FusedIterator for ValuesMut<'a, T> {}
 impl<'a, T: 'a> Iterator for ValuesMut<'a, T> {
     type Item = &'a mut T;
     fn next(&mut self) -> Option<Self::Item> {
@@ -80,6 +84,7 @@ impl<'a, T: 'a> Clone for Nodes<'a, T> {
     }
 }
 impl<'a, T: 'a> ExactSizeIterator for Nodes<'a, T> {}
+impl<'a, T: 'a> FusedIterator for Nodes<'a, T> {}
 impl<'a, T: 'a> Iterator for Nodes<'a, T> {
     type Item = NodeRef<'a, T>;
     fn next(&mut self) -> Option<Self::Item> {
@@ -138,6 +143,7 @@ macro_rules! axis_iterators {
                     $i(self.0)
                 }
             }
+            impl<'a, T: 'a> FusedIterator for $i<'a, T> {}
             impl<'a, T: 'a> Iterator for $i<'a, T> {
                 type Item = NodeRef<'a, T>;
                 fn next(&mut self) -> Option<Self::Item> {
@@ -181,6 +187,7 @@ impl<'a, T: 'a> Clone for Children<'a, T> {
         }
     }
 }
+impl<'a, T: 'a> FusedIterator for Children<'a, T> {}
 impl<'a, T: 'a> Iterator for Children<'a, T> {
     type Item = NodeRef<'a, T>;
     fn next(&mut self) -> Option<Self::Item> {
@@ -236,7 +243,7 @@ impl<'a, T: 'a> PartialEq for Edge<'a, T> {
 /// Iterator which traverses a subtree.
 #[derive(Debug)]
 pub struct Traverse<'a, T: 'a> {
-    root: NodeRef<'a, T>,
+    root: Option<NodeRef<'a, T>>,
     edge: Option<Edge<'a, T>>,
 }
 impl<'a, T: 'a> Clone for Traverse<'a, T> {
@@ -247,12 +254,15 @@ impl<'a, T: 'a> Clone for Traverse<'a, T> {
         }
     }
 }
+impl<'a, T: 'a> FusedIterator for Traverse<'a, T> {}
 impl<'a, T: 'a> Iterator for Traverse<'a, T> {
     type Item = Edge<'a, T>;
     fn next(&mut self) -> Option<Self::Item> {
         match self.edge {
             None => {
-                self.edge = Some(Edge::Open(self.root));
+                if let Some(root) = self.root {
+                    self.edge = Some(Edge::Open(root));
+                }
             }
             Some(Edge::Open(node)) => {
                 if let Some(first_child) = node.first_child() {
@@ -262,7 +272,8 @@ impl<'a, T: 'a> Iterator for Traverse<'a, T> {
                 }
             }
             Some(Edge::Close(node)) => {
-                if node == self.root {
+                if node == self.root.unwrap() {
+                    self.root = None;
                     self.edge = None;
                 } else if let Some(next_sibling) = node.next_sibling() {
                     self.edge = Some(Edge::Open(next_sibling));
@@ -283,6 +294,7 @@ impl<'a, T: 'a> Clone for Descendants<'a, T> {
         Descendants(self.0.clone())
     }
 }
+impl<'a, T: 'a> FusedIterator for Descendants<'a, T> {}
 impl<'a, T: 'a> Iterator for Descendants<'a, T> {
     type Item = NodeRef<'a, T>;
     fn next(&mut self) -> Option<Self::Item> {
@@ -332,7 +344,7 @@ impl<'a, T: 'a> NodeRef<'a, T> {
     /// Returns an iterator which traverses the subtree starting at this node.
     pub fn traverse(&self) -> Traverse<'a, T> {
         Traverse {
-            root: *self,
+            root: Some(*self),
             edge: None,
         }
     }

tests/iter.rs

@@ -61,6 +61,23 @@ fn ancestors() {
     );
 }
 
+#[test]
+fn ancestors_fused() {
+    let tree = tree!('a' => { 'b' => { 'c' => { 'd' } } });
+    let d = tree
+        .root()
+        .last_child()
+        .unwrap()
+        .last_child()
+        .unwrap()
+        .last_child()
+        .unwrap();
+
+    let mut ancestors = d.ancestors();
+    assert_eq!(ancestors.by_ref().count(), 3);
+    assert_eq!(ancestors.next(), None);
+}
+
 #[test]
 fn prev_siblings() {
     let tree = tree!('a' => { 'b', 'c', 'd' });
@@ -101,6 +118,16 @@ fn children() {
     );
 }
 
+#[test]
+fn children_fused() {
+    let tree = tree!('a' => { 'b', 'c', 'd' });
+
+    let mut children = tree.root().children();
+
+    assert_eq!(children.by_ref().count(), 3);
+    assert_eq!(children.next(), None);
+}
+
 #[test]
 fn children_rev() {
     let tree = tree!('a' => { 'b', 'c', 'd' });
@@ -176,6 +203,16 @@ fn traverse() {
     );
 }
 
+#[test]
+fn traverse_fused() {
+    let tree = tree!('a' => { 'b' => { 'd', 'e' }, 'c' });
+
+    let mut traversal = tree.root().traverse();
+
+    assert_eq!(traversal.by_ref().count(), 2 * 5);
+    assert_eq!(traversal.next(), None);
+}
+
 #[test]
 fn descendants() {
     let tree = tree!('a' => { 'b' => { 'd', 'e' }, 'c' });
@@ -188,3 +225,13 @@ fn descendants() {
 
     assert_eq!(&[&'a', &'b', &'d', &'e', &'c',], &descendants[..]);
 }
+
+#[test]
+fn descendants_fused() {
+    let tree = tree!('a' => { 'b' => { 'd', 'e' }, 'c' });
+
+    let mut descendants = tree.root().descendants();
+
+    assert_eq!(descendants.by_ref().count(), 5);
+    assert_eq!(descendants.next(), None);
+}