grapes 0.3.0

Persistent graph data structures: Tree, Graph, Arena & more
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

use crate::tree::node_ref::NodeRef;
use crate::tree::{NodeId, Tree};

/// An iterator over the children of a node
#[derive(Clone, Debug)]
#[must_use]
pub struct Children<'a, T: Clone> {
    tree: &'a Tree<T>,
    next_index: Option<NodeId>,
}

impl<'a, T: Clone> Children<'a, T> {
    pub(crate) fn new(tree: &'a Tree<T>, next_index: Option<NodeId>) -> Self {
        Self { tree, next_index }
    }
}

impl<'a, T: Clone> Iterator for Children<'a, T> {
    type Item = NodeRef<'a, T>;

    fn next(&mut self) -> Option<Self::Item> {
        let current_index = self.next_index?;
        let node = &self.tree.arena[current_index.0];
        self.next_index = node.next_sibling;
        Some(NodeRef::new(self.tree, current_index))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn no_children() {
        let tree = Tree::new_with_root(42);
        let root = tree.root();
        let mut iterator = root.children();
        assert!(iterator.next().is_none());
    }

    #[test]
    fn root_children() {
        let mut tree = Tree::new_with_root(42);
        let mut root = tree.root_mut();
        root.push_front_child(43);
        root.push_front_child(44);
        root.push_front_child(45);

        let root = tree.root();
        let mut iterator = root.children();
        assert_eq!(iterator.next().unwrap().data(), &45);
        assert_eq!(iterator.next().unwrap().data(), &44);
        assert_eq!(iterator.next().unwrap().data(), &43);
        assert!(iterator.next().is_none());
    }
}