ziyy_core/resolver/document/
iter.rs

1use std::{ops::Deref, rc::Rc};
2
3use super::Node;
4
5#[derive(Debug)]
6pub struct Children<'a> {
7    front: Option<Rc<Node<'a>>>,
8    back: Option<Rc<Node<'a>>>,
9}
10
11impl<'a> Clone for Children<'a> {
12    fn clone(&self) -> Self {
13        Self {
14            front: self.front.clone(),
15            back: self.back.clone(),
16        }
17    }
18}
19
20impl<'a> Iterator for Children<'a> {
21    type Item = Rc<Node<'a>>;
22    fn next(&mut self) -> Option<Self::Item> {
23        if self.front == self.back {
24            let node = self.front.take();
25            self.back = None;
26            node
27        } else {
28            let node = self.front.take();
29            self.front = node.as_deref().and_then(Node::next_sibling);
30            node
31        }
32    }
33}
34
35/// Open or close edge of a node.
36#[derive(Debug, Clone)]
37pub enum Edge<'a> {
38    /// Open.
39    Open(Rc<Node<'a>>),
40    /// Close.
41    Close(Rc<Node<'a>>),
42}
43
44impl<'a> Eq for Edge<'a> {}
45
46impl<'a> PartialEq for Edge<'a> {
47    fn eq(&self, other: &Self) -> bool {
48        match (self, other) {
49            (Edge::Open(a), Edge::Open(b)) | (Edge::Close(a), Edge::Close(b)) => a == b,
50            _ => false,
51        }
52    }
53}
54
55/// Iterator which traverses a subtree.
56#[derive(Debug, Clone)]
57pub struct Traverse<'a> {
58    root: Option<Rc<Node<'a>>>,
59    edge: Option<Edge<'a>>,
60}
61
62impl<'a> Iterator for Traverse<'a> {
63    type Item = Edge<'a>;
64    fn next(&mut self) -> Option<Self::Item> {
65        match &self.edge {
66            None => {
67                if let Some(root) = &self.root {
68                    self.edge = Some(Edge::Open(root.clone()));
69                }
70            }
71            Some(Edge::Open(node)) => {
72                if let Some(first_child) = node.first_child() {
73                    self.edge = Some(Edge::Open(first_child));
74                } else {
75                    self.edge = Some(Edge::Close(node.clone()));
76                }
77            }
78            Some(Edge::Close(node)) => {
79                if *node == self.root.clone().unwrap() {
80                    self.root = None;
81                    self.edge = None;
82                } else if let Some(next_sibling) = node.next_sibling() {
83                    self.edge = Some(Edge::Open(next_sibling));
84                } else {
85                    self.edge = node.parent().map(Edge::Close);
86                }
87            }
88        }
89        self.edge.clone()
90    }
91}
92
93/// Iterator over a node and its descendants.
94#[derive(Debug)]
95pub struct Descendants<'a>(Traverse<'a>);
96
97impl<'a> Clone for Descendants<'a> {
98    fn clone(&self) -> Self {
99        Descendants(self.0.clone())
100    }
101}
102
103impl<'a> Iterator for Descendants<'a> {
104    type Item = Rc<Node<'a>>;
105    fn next(&mut self) -> Option<Self::Item> {
106        for edge in &mut self.0 {
107            if let Edge::Open(node) = edge {
108                return Some(node);
109            }
110        }
111        None
112    }
113}
114
115macro_rules! axis_iterators {
116    ($(#[$m:meta] $i:ident($f:path);)*) => {
117        $(
118            #[$m]
119            #[derive(Debug)]
120            pub struct $i<'a>(Option<Rc<Node<'a>>>);
121            impl<'a> Clone for $i<'a> {
122                fn clone(&self) -> Self {
123                    $i(self.0.clone())
124                }
125            }
126
127            impl<'a> Iterator for $i<'a> {
128                type Item = Rc<Node<'a>>;
129                fn next(&mut self) -> Option<Self::Item> {
130                    let node = self.0.take();
131                    self.0 = node.as_ref().map(|x| x.deref()).and_then($f);
132                    node
133                }
134            }
135        )*
136    };
137}
138
139axis_iterators! {
140    /// Iterator over ancestors.
141    Ancestors(Node::parent);
142
143    /// Iterator over previous siblings.
144    PrevSiblings(Node::prev_sibling);
145
146    /// Iterator over next siblings.
147    NextSiblings(Node::next_sibling);
148
149    /// Iterator over first children.
150    FirstChildren(Node::first_child);
151
152    /// Iterator over last children.
153    LastChildren(Node::last_child);
154}
155
156impl<'a> Node<'a> {
157    /// Returns an iterator over children.
158    pub fn children(&self) -> Children<'a> {
159        Children {
160            front: self.first_child(),
161            back: self.last_child(),
162        }
163    }
164
165    /// Returns an iterator which traverses the subtree starting at this node.
166    pub fn traverse(self: &Rc<Node<'a>>) -> Traverse<'a> {
167        Traverse {
168            root: Some(self.clone()),
169            edge: None,
170        }
171    }
172
173    /// Returns an iterator over this node and its descendants.
174    pub fn descendants(self: &Rc<Node<'a>>) -> Descendants<'a> {
175        Descendants(self.traverse())
176    }
177
178    /// Returns an iterator over ancestors.
179    pub fn ancestors(self: &Rc<Node<'a>>) -> Ancestors<'a> {
180        Ancestors(Some(self.clone()))
181    }
182}
ziyy_core/resolver/document/iter.rs

ziyy_core/resolver/document/
iter.rs
