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

use crate::VecTree;
/**

# Example:

```
use flange_flat_tree::Builder;
use flange_flat_tree::Tree;
use flange_flat_tree::Subtree;

let mut b = Builder::new();
b.start_element("root");
b.start_end_element("first_child");
b.start_element("second_child_with_children");
b.start_end_element("deep_child");
b.end_element();
b.end_element();

let tree = b.build();

assert_eq!(tree.root().value(), &"root");
assert_eq!(tree.root().children()[0].value(), &"first_child");
assert_eq!(tree.root().children()[1].children()[0].value(), &"deep_child");
```
*/
pub struct Builder<A> {
    nav_builder: crate::navigator::Builder,
    values: Vec<A>,
}

impl<A> Builder<A> {
    pub fn new() -> Builder<A> {
        Builder {
            nav_builder: crate::navigator::Builder::default(),
            values: Vec::new(),
        }
    }

    pub fn with_capacity(c: usize) -> Builder<A> {
        Builder {
            nav_builder: crate::navigator::Builder::with_capacity(c),
            values: Vec::with_capacity(c),
        }
    }

    pub fn get(&self, index: usize) -> Option<&A> {
        self.values.get(index)
    }

    pub fn get_mut(&mut self, index: usize) -> Option<&mut A> {
        self.values.get_mut(index)
    }

    pub fn start_element(&mut self, el: A) -> usize {
        self.values.push(el);
        self.nav_builder.start_element()
    }

    pub fn end_element(&mut self) -> usize {
        self.nav_builder.end_element()
    }

    pub fn start_end_element(&mut self, el: A) -> usize {
        self.values.push(el);
        self.nav_builder.start_end_element()
    }
}

impl<A> Default for Builder<A> {
    fn default() -> Self {
        Self::new()
    }
}

impl<A> Builder<A> {
    pub fn build(self) -> VecTree<A> {
        VecTree {
            nav: self.nav_builder.build(),
            values: self.values,
        }
    }
}