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
88
89
90
91
92
93
94
95
96
97
98
99



pub struct Node<T> {
    nodes: *mut Tree<T>,
    parent: Option<*const Node<T>>,
    value: T,
}


impl<T> Node<T> {
    fn new(nodes: *mut Tree<T>, parent: Option<*const Node<T>>, value: T) -> Self {
        Node {
            nodes: nodes,
            parent: parent,
            value: value,
        }
    }

    pub fn push(&self, val: T) -> &Node<T> {
        let node = Node::new(self.nodes, Some(self), val);
        unsafe {
            let nodes = &mut *self.nodes;
            nodes.values.push(node);
            nodes.values.last().unwrap()
        }
    }

    pub fn value(&self) -> &T {
        &self.value
    }

    pub fn parent(&self) -> Option<&Node<T>> {
        unsafe { self.parent.map(|p| &*p) }
    }

    pub fn iter(&self) -> NodeIter<T> {
        NodeIter { node: Some(self) }
    }
}


pub struct NodeIter<'a, T: 'a> {
    node: Option<&'a Node<T>>,
}

impl<'a, T> Iterator for NodeIter<'a, T> {
    type Item = &'a T;

    fn next(&mut self) -> Option<&'a T> {
        self.node.map(|n| {
            self.node = n.parent();
            &n.value
        })
    }
}


struct Tree<T> {
    values: Vec<Node<T>>,
}

impl<T> Tree<T> {
    fn new() -> Self {
        Tree { values: Vec::new() }
    }
}


pub struct PPTree<T> {
    tree: Box<Tree<T>>,
}

impl<T> PPTree<T> {
    pub fn new(val: T) -> Self {
        let mut tree = Box::from(Tree::new());
        let node = Node::new(&mut *tree, None, val);
        tree.values.push(node);
        PPTree { tree: tree }
    }

    pub fn root(&self) -> &Node<T> {
        &self.tree.values[0]
    }
}


#[test]
fn test() {
    let tree = PPTree::new(0);
    let root = tree.root();
    let x = root.push(1).push(2).push(3);
    let y = root.push(2).push(5);

    for v in x.iter() {
        println!("{:?}", v);
    }

    println!("{:?}", y.iter().collect::<Vec<_>>());
}