flange-flat-tree 0.2.2

A tree that can be expanded by attaching new values to the node without mutability of the old ones
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
81
82
83
84
85
86
87

use super::Subtree;

use super::super::tree_data::TreeData;

pub struct SubtreeImpl<TD>
where
    TD: TreeData,
{
    data: TD,
    pos: usize,
}

impl<TD> SubtreeImpl<TD>
where
    TD: TreeData,
{
    pub fn new(data: TD, pos: usize) -> Self {
        SubtreeImpl { data, pos }
    }

    fn moved(&self, new_pos: usize) -> Self {
        SubtreeImpl {
            data: self.data,
            pos: new_pos,
        }
    }

    fn children_indexes(&self) -> Vec<usize> {
        let mut res = Vec::new();
        let mut oc = self.data.get_nav().first_child(self.pos);
        while let Some(c) = oc {
            // Store the child
            res.push(c);
            // Advance to the next child
            oc = self.data.get_nav().next_sibling(c);
        }
        res
    }
}

impl<TD> Subtree for SubtreeImpl<TD>
where
    TD: TreeData,
{
    type Node = TD::Node;

    fn get_pos(&self) -> usize {
        self.pos
    }

    fn value(&self) -> TD::Node {
        self.data.get(self.pos)
    }
    fn parent(&self) -> Option<Self> {
        self.data.get_nav().parent(self.pos).map(|i| self.moved(i))
    }
    fn children(&self) -> Vec<Self> {
        self.children_indexes()
            .iter()
            .map(|&i| self.moved(i))
            .collect()
    }
    fn child_values(&self) -> Vec<Self::Node> {
        self.children_indexes()
            .iter()
            .map(|&i| self.data.get(i))
            .collect()
    }
    fn first_child(&self) -> Option<Self> {
        self.data
            .get_nav()
            .first_child(self.pos)
            .map(|i| self.moved(i))
    }
    fn prev_sibling(&self) -> Option<Self> {
        self.data
            .get_nav()
            .prev_sibling(self.pos)
            .map(|i| self.moved(i))
    }
    fn next_sibling(&self) -> Option<Self> {
        self.data
            .get_nav()
            .next_sibling(self.pos)
            .map(|i| self.moved(i))
    }
}