socarel 0.4.0

Fast and compact crate to generate, manipulate and traverse trees.
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use socarel::{Forest, NodeContent, Node};

fn main() {
    let mut forest = <Forest>::new();
    forest.new_tree("my_tree");
    forest.new_tree("other_tree");

    println!("Forest = {:#?}", forest);

    if let Some(my_tree) = forest.get_mut_tree("my_tree") {
        let _root = my_tree.set_root("my root node").unwrap();
        let _child_1 = my_tree.link_node("bad child node 1", _root).unwrap();
        let _child_2 = my_tree.link_node("child node 2", _root).unwrap();
        let _grandchild_2 = my_tree.link_node("grandchild 2 node", _child_2).unwrap();
        let _grandchild_1 = my_tree.link_node("grandchild 1 node", _child_1).unwrap();

        println!("My Tree = {:#?}", my_tree);
        println!("Root content = {:#?}", my_tree.get_node_content(_root).unwrap().get_val());
        println!("Child 1 content = {:#?}", my_tree.get_node_content(_child_1).unwrap().get_val());
        println!("Child 2 content = {:#?}", my_tree.get_node_content(_child_2).unwrap().get_val());
        println!("Grandchild content = {:#?}", my_tree.get_node_content(_grandchild_1).unwrap().get_val());

        println!("-------------------------------------------------------");

        my_tree.update_node("child node 1", _child_1);

        println!("New Child 1 content = {:#?}", my_tree.get_node_content(_child_1).unwrap().get_val());

        println!("My Tree after node update = {:#?}", my_tree);

        println!("-------------------------------------------------------");

        my_tree.unlink_node(_child_1);

        println!("My Tree after unlink = {:#?}", my_tree);

        println!("-------------------------------------------------------");

        // Is the unlinked node, will return None
        let _found_node_a = my_tree.find_node(&["my root node", "child node 1", "grandchild 1 node"]);
        println!("find '/my root node/child node 1/grandchild 1 node/' index = {:#?}", _found_node_a);

        let _found_node_b = my_tree.find_node(&["my root node", "child node 2", "grandchild 2 node"]);
        println!("find '/my root node/child node 2/grandchild 2 node/' index = {:#?}", _found_node_b);

        let _found_root = my_tree.find_node(&["my root node"]);
        println!("find '/my root node/' index = {:#?}", _found_root);

        println!("-------------------------------------------------------");

        println!("Sequential Iter:");
        iterate(my_tree.iterators().sequential());
        println!("Inv Sequential Iter:");
        iterate(my_tree.iterators().inv_sequential());
        println!("BFS Iter:");
        iterate(my_tree.iterators().bfs());
        println!("Inv BFS Iter:");
        iterate(my_tree.iterators().inv_bfs());
        println!("Pre DFS Iter:");
        iterate(my_tree.iterators().pre_dfs());
        println!("Inv Pre DFS Iter:");
        iterate(my_tree.iterators().inv_pre_dfs());
        println!("Post DFS Iter:");
        iterate(my_tree.iterators().post_dfs());
        println!("Inv Post DFS Iter:");
        iterate(my_tree.iterators().inv_post_dfs());
    }

    println!("-------------------------------------------------------");
    println!("All trees:");
    for (k,v) in forest.iter() {
        println!("Tree name `{}` tree = {:#?}", k, v);
    }
}

fn iterate<'a>(iter: impl Iterator<Item=(&'a Node, usize)>) {
    for (node, index) in iter {
        println!("At index {} found node `{}` ({})", index, node.get_content_ref().get_val(), node.get_level());
    }
}