tree_flat/
iter.rs

1use std::fmt::Debug;
2
3use crate::prelude::*;
4
5pub struct TreeIter<'a, T> {
6    pub(crate) pos: usize,
7    pub(crate) tree: &'a Tree<T>,
8}
9
10impl<'a, T: Debug> Iterator for TreeIter<'a, T> {
11    type Item = Node<'a, T>;
12
13    fn next(&mut self) -> Option<Self::Item> {
14        let id = NodeId::from_index(self.pos);
15        self.pos += 1;
16        if self.pos <= self.tree.len() {
17            Some(self.tree._make_node(id))
18        } else {
19            None
20        }
21    }
22
23    fn size_hint(&self) -> (usize, Option<usize>) {
24        (0, Some(self.tree.len()))
25    }
26}
27
28pub struct IntoIter<'a, T> {
29    pub(crate) tree: &'a Tree<T>,
30}
31
32impl<'a, T: Debug> IntoIterator for IntoIter<'a, T> {
33    type Item = Node<'a, T>;
34    type IntoIter = TreeIter<'a, T>;
35
36    fn into_iter(self) -> Self::IntoIter {
37        TreeIter {
38            pos: 0,
39            tree: self.tree,
40        }
41    }
42}
43
44impl<'a, T: Debug> IntoIterator for &'a Tree<T> {
45    type Item = Node<'a, T>;
46    type IntoIter = TreeIter<'a, T>;
47
48    fn into_iter(self) -> Self::IntoIter {
49        TreeIter { pos: 0, tree: self }
50    }
51}
52
53#[derive(Debug)]
54pub struct ParentIter<'a, T> {
55    pub(crate) parent: usize,
56    pub(crate) node: NodeId,
57    pub(crate) tree: &'a Tree<T>,
58}
59
60impl<'a, T: Debug> Iterator for ParentIter<'a, T> {
61    type Item = Node<'a, T>;
62
63    fn next(&mut self) -> Option<Self::Item> {
64        // dbg!(self.pos, self.parent, self.node.0);
65        if self.node.to_index() > 0 {
66            self.node = NodeId::from_index(self.parent);
67            self.parent = self.tree.parent[self.parent];
68            Some(self.tree._make_node(self.node))
69        } else {
70            None
71        }
72    }
73}
74
75#[derive(Debug)]
76pub struct ChildrenIter<'a, T> {
77    pub(crate) pos: usize,
78    pub(crate) parent: NodeId,
79    pub(crate) range: &'a [usize],
80    pub(crate) tree: &'a Tree<T>,
81}
82
83impl<'a, T> ChildrenIter<'a, T> {
84    pub fn new(parent: NodeId, tree: &'a Tree<T>) -> Self {
85        let range = &tree.parent[parent.to_index() + 1..];
86        //dbg!(range);
87        ChildrenIter {
88            pos: 1,
89            parent,
90            range,
91            tree,
92        }
93    }
94}
95
96impl<'a, T: Debug> Iterator for ChildrenIter<'a, T> {
97    type Item = Node<'a, T>;
98
99    fn next(&mut self) -> Option<Self::Item> {
100        //dbg!(self.pos, self.range.len());
101        if self.pos <= self.range.len() {
102            let idx = self.parent.to_index();
103            let level_parent = self.tree.level[idx];
104            let node = NodeId::from_index(self.pos + idx);
105            let level_child = self.tree.level[node.to_index()];
106            //dbg!(self.pos, level_parent, node, level_child);
107            self.pos += 1;
108
109            if level_child > level_parent {
110                Some(self.tree._make_node(node))
111            } else {
112                None
113            }
114        } else {
115            None
116        }
117    }
118}
119
120#[derive(Debug)]
121pub struct SiblingsIter<'a, T> {
122    pub(crate) pos: usize,
123    pub(crate) level: usize,
124    pub(crate) node: NodeId,
125    pub(crate) tree: &'a Tree<T>,
126}
127
128impl<'a, T: Debug> Iterator for SiblingsIter<'a, T> {
129    type Item = Node<'a, T>;
130
131    fn next(&mut self) -> Option<Self::Item> {
132        //dbg!(self.pos, self.range.len());
133        if self.pos <= self.tree.len() {
134            let start = self.pos;
135            if let Some(pos) =
136                self.tree.level[start..]
137                    .iter()
138                    .enumerate()
139                    .find_map(|(pos, level)| {
140                        let idx = self.pos + pos;
141                        if *level == self.level && self.node.to_index() != idx {
142                            Some(idx)
143                        } else {
144                            None
145                        }
146                    })
147            {
148                self.pos = pos + 1;
149                Some(self.tree._make_node(NodeId::from_index(pos)))
150            } else {
151                None
152            }
153        } else {
154            None
155        }
156    }
157}
tree_flat/iter.rs

tree_flat/
iter.rs
