ai.platon.pulsar.common.NodeWalker Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package ai.platon.pulsar.common;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.util.Stack;
/**
*
* A utility class that allows the walking of any DOM tree using a stack instead
* of recursion. As the node tree is walked the next node is popped off of the
* stack and all of its children are automatically added to the stack to be
* called in tree order.
*
*
* Currently this class is not thread safe. It is assumed that only one thread
* will be accessing the NodeWalker at any given time.
*
*
* @author vincent
* @version $Id: $Id
*/
public class NodeWalker {
// the root node the stack holding the nodes
private Node currentNode;
private NodeList currentChildren;
private Stack nodes;
/**
* Starts the Node tree from the root node.
*
* @param rootNode a {@link org.w3c.dom.Node} object.
*/
public NodeWalker(Node rootNode) {
nodes = new Stack();
nodes.add(rootNode);
}
/**
*
* Returns the next Node on the stack and pushes all of its
* children onto the stack, allowing us to walk the node tree without the use
* of recursion. If there are no more nodes on the stack then null is
* returned.
*
*
* @return Node The next Node on the stack or null if there isn't
* a next node.
*/
public Node nextNode() {
// if no next node return null
if (!hasNext()) {
return null;
}
// pop the next node off of the stack and push all of its children onto
// the stack
currentNode = nodes.pop();
currentChildren = currentNode.getChildNodes();
int childLen = (currentChildren != null) ? currentChildren.getLength() : 0;
// put the children node on the stack in first to last order
for (int i = childLen - 1; i >= 0; i--) {
nodes.add(currentChildren.item(i));
}
return currentNode;
}
/**
*
* Skips over and removes from the node stack the children of the last node.
* When getting a next node from the walker, that node's children are
* automatically added to the stack. You can call this method to remove those
* children from the stack.
*
*
*
* This is useful when you don't want to process deeper into the current path
* of the node tree but you want to continue processing sibling nodes.
*
*/
public void skipChildren() {
int childLen = (currentChildren != null) ? currentChildren.getLength() : 0;
for (int i = 0; i < childLen; i++) {
Node child = nodes.peek();
if (child.equals(currentChildren.item(i))) {
nodes.pop();
}
}
}
/**
* Return the current node.
*
* @return Node
*/
public Node getCurrentNode() {
return currentNode;
}
/**
* * Returns true if there are more nodes on the current stack.
*
* @return a boolean.
*/
public boolean hasNext() {
return (nodes.size() > 0);
}
}