Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 20:50:07 +01:00
Code Issues Projects Releases Packages Wiki Activity

Remove unused script::dom::node::NodeIterator

Browse source 
Was introduced in 7aee1cae84

I noticed it isn't actively in use, so unless there's some bigger reason
why it exists, it could probably be removed
This commit is contained in:
Corey Farwell 2015-03-25 21:45:28 -04:00
parent 04d78b6fdb
commit 01ac9a6c87
1 changed files with 0 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

83
components/script/dom/node.rs
View file

@ -1134,89 +1134,6 @@ impl<'a> Iterator for TreeIterator<'a> {
}
}
#[must_root]
pub struct NodeIterator {
pub start_node: JS<Node>,
pub current_node: Option<JS<Node>>,
pub depth: uint,
include_start: bool,
include_descendants_of_void: bool
}
impl NodeIterator {
pub fn new<'a>(start_node: JSRef<'a, Node>,
include_start: bool,
include_descendants_of_void: bool) -> NodeIterator {
NodeIterator {
start_node: JS::from_rooted(start_node),
current_node: None,
depth: 0,
include_start: include_start,
include_descendants_of_void: include_descendants_of_void
}
}
fn next_child<'b>(&self, node: JSRef<'b, Node>) -> Option<JSRef<'b, Node>> {
let skip = |element: JSRef<Element>| {
!self.include_descendants_of_void && element.is_void()
};
match ElementCast::to_ref(node) {
Some(element) if skip(element) => None,
_ => node.first_child().map(|child| child.root().get_unsound_ref_forever()),
}
}
}
impl<'a> Iterator for NodeIterator {
type Item = JSRef<'a, Node>;
fn next(&mut self) -> Option<JSRef<'a, Node>> {
self.current_node = match self.current_node.as_ref().map(|node| node.root()) {
None => {
if self.include_start {
Some(self.start_node)
} else {
self.next_child(self.start_node.root().r())
.map(|child| JS::from_rooted(child))
}
},
Some(node) => {
match self.next_child(node.r()) {
Some(child) => {
self.depth += 1;
Some(JS::from_rooted(child))
},
None if JS::from_rooted(node.r()) == self.start_node => None,
None => {
match node.r().next_sibling().root() {
Some(sibling) => Some(JS::from_rooted(sibling.r())),
None => {
let mut candidate = node.get_unsound_ref_forever();
while candidate.next_sibling().is_none() {
candidate = candidate.parent_node()
.expect("Got to root without reaching start node")
.root()
.get_unsound_ref_forever();
if JS::from_rooted(candidate) == self.start_node {
break;
}
self.depth -= 1;
}
if JS::from_rooted(candidate) != self.start_node {
candidate.next_sibling().map(|node| JS::from_rooted(node.root().r()))
} else {
None
}
}
}
}
}
}
};
self.current_node.map(|node| node.root().get_unsound_ref_forever())
}
}
/// Specifies whether children must be recursively cloned or not.
#[derive(Copy, PartialEq)]