/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 1999-2002,2004 The Apache Software Foundation.
*
* Licensed 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 com.sun.org.apache.xerces.internal.dom;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.util.Vector;
/**
* This class implements the DOM's NodeList behavior for
* Element.getElementsByTagName()
* <P>
* The DOM describes NodeList as follows:
* <P>
* 1) It may represent EITHER nodes scattered through a subtree (when
* returned by Element.getElementsByTagName), or just the immediate
* children (when returned by Node.getChildNodes). The latter is easy,
* but the former (which this class addresses) is more challenging.
* <P>
* 2) Its behavior is "live" -- that is, it always reflects the
* current state of the document tree. To put it another way, the
* NodeLists obtained before and after a series of insertions and
* deletions are effectively identical (as far as the user is
* concerned, the former has been dynamically updated as the changes
* have been made).
* <P>
* 3) Its API accesses individual nodes via an integer index, with the
* listed nodes numbered sequentially in the order that they were
* found during a preorder depth-first left-to-right search of the tree.
* (Of course in the case of getChildNodes, depth is not involved.) As
* nodes are inserted or deleted in the tree, and hence the NodeList,
* the numbering of nodes that follow them in the NodeList will
* change.
* <P>
* It is rather painful to support the latter two in the
* getElementsByTagName case. The current solution is for Nodes to
* maintain a change count (eventually that may be a Digest instead),
* which the NodeList tracks and uses to invalidate itself.
* <P>
* Unfortunately, this does _not_ respond efficiently in the case that
* the dynamic behavior was supposed to address: scanning a tree while
* it is being extended. That requires knowing which subtrees have
* changed, which can become an arbitrarily complex problem.
* <P>
* We save some work by filling the vector only as we access the
* item()s... but I suspect the same users who demanded index-based
* access will also start by doing a getLength() to control their loop,
* blowing this optimization out of the water.
* <P>
* NOTE: Level 2 of the DOM will probably _not_ use NodeList for its
* extended search mechanisms, partly for the reasons just discussed.
*
* @xerces.internal
*
* @since PR-DOM-Level-1-19980818.
*/
public class DeepNodeListImpl
implements NodeList {
//
// Data
//
protected NodeImpl rootNode; // Where the search started
protected String tagName; // Or "*" to mean all-tags-acceptable
protected int changes=0;
protected Vector nodes;
protected String nsName;
protected boolean enableNS = false;
//
// Constructors
//
/** Constructor. */
public DeepNodeListImpl(NodeImpl rootNode, String tagName) {
this.rootNode = rootNode;
this.tagName = tagName;
nodes = new Vector();
}
/** Constructor for Namespace support. */
public DeepNodeListImpl(NodeImpl rootNode,
String nsName, String tagName) {
this(rootNode, tagName);
this.nsName = (nsName != null && !nsName.equals("")) ? nsName : null;
enableNS = true;
}
//
// NodeList methods
//
/** Returns the length of the node list. */
public int getLength() {
// Preload all matching elements. (Stops when we run out of subtree!)
item(java.lang.Integer.MAX_VALUE);
return nodes.size();
}
/** Returns the node at the specified index. */
public Node item(int index) {
Node thisNode;
// Tree changed. Do it all from scratch!
if(rootNode.changes() != changes) {
nodes = new Vector();
changes = rootNode.changes();
}
// In the cache
if (index < nodes.size())
return (Node)nodes.elementAt(index);
// Not yet seen
else {
// Pick up where we left off (Which may be the beginning)
if (nodes.size() == 0)
thisNode = rootNode;
else
thisNode=(NodeImpl)(nodes.lastElement());
// Add nodes up to the one we're looking for
while(thisNode != null && index >= nodes.size()) {
thisNode=nextMatchingElementAfter(thisNode);
if (thisNode != null)
nodes.addElement(thisNode);
}
// Either what we want, or null (not avail.)
return thisNode;
}
} // item(int):Node
//
// Protected methods (might be overridden by an extending DOM)
//
/**
* Iterative tree-walker. When you have a Parent link, there's often no
* need to resort to recursion. NOTE THAT only Element nodes are matched
* since we're specifically supporting getElementsByTagName().
*/
protected Node nextMatchingElementAfter(Node current) {
Node next;
while (current != null) {
// Look down to first child.
if (current.hasChildNodes()) {
current = (current.getFirstChild());
}
// Look right to sibling (but not from root!)
else if (current != rootNode && null != (next = current.getNextSibling())) {
current = next;
}
// Look up and right (but not past root!)
else {
next = null;
for (; current != rootNode; // Stop when we return to starting point
current = current.getParentNode()) {
next = current.getNextSibling();
if (next != null)
break;
}
current = next;
}
// Have we found an Element with the right tagName?
// ("*" matches anything.)
if (current != rootNode
&& current != null
&& current.getNodeType() == Node.ELEMENT_NODE) {
if (!enableNS) {
if (tagName.equals("*") ||
((ElementImpl) current).getTagName().equals(tagName))
{
return current;
}
} else {
// DOM2: Namespace logic.
if (tagName.equals("*")) {
if (nsName != null && nsName.equals("*")) {
return current;
} else {
ElementImpl el = (ElementImpl) current;
if ((nsName == null
&& el.getNamespaceURI() == null)
|| (nsName != null
&& nsName.equals(el.getNamespaceURI())))
{
return current;
}
}
} else {
ElementImpl el = (ElementImpl) current;
if (el.getLocalName() != null
&& el.getLocalName().equals(tagName)) {
if (nsName != null && nsName.equals("*")) {
return current;
} else {
if ((nsName == null
&& el.getNamespaceURI() == null)
|| (nsName != null &&
nsName.equals(el.getNamespaceURI())))
{
return current;
}
}
}
}
}
}
// Otherwise continue walking the tree
}
// Fell out of tree-walk; no more instances found
return null;
} // nextMatchingElementAfter(int):Node
} // class DeepNodeListImpl