FileDocCategorySizeDatePackage
NodeSet.javaAPI DocJava SE 5 API35838Fri Aug 26 14:56:06 BST 2005com.sun.org.apache.xpath.internal

NodeSet

public class NodeSet extends Object implements NodeIterator, NodeList, Cloneable, ContextNodeList

The NodeSet class can act as either a NodeVector, NodeList, or NodeIterator. However, in order for it to act as a NodeVector or NodeList, it's required that setShouldCacheNodes(true) be called before the first nextNode() is called, in order that nodes can be added as they are fetched. Derived classes that implement iterators must override runTo(int index), in order that they may run the iteration to the given index.

Note that we directly implement the DOM's NodeIterator interface. We do not emulate all the behavior of the standard NodeIterator. In particular, we do not guarantee to present a "live view" of the document ... but in XSLT, the source document should never be mutated, so this should never be an issue.

Thought: Should NodeSet really implement NodeList and NodeIterator, or should there be specific subclasses of it which do so? The advantage of doing it all here is that all NodeSets will respond to the same calls; the disadvantage is that some of them may return less-than-enlightening results when you do so.

xsl.usage
advanced

Fields Summary
protected transient int
m_next
If this node is being used as an iterator, the next index that nextNode() will return.
protected transient boolean
m_mutable
True if this list can be mutated.
protected transient boolean
m_cacheNodes
True if this list is cached.
private transient int
m_last
private int
m_blocksize
Size of blocks to allocate.
Node[]
m_map
Array of nodes this points to.
protected int
m_firstFree
Number of nodes in this NodeVector.
private int
m_mapSize
Size of the array this points to.
Constructors Summary
public NodeSet()
Create an empty nodelist.

    m_blocksize = 32;
    m_mapSize = 0;
public NodeSet(int blocksize)
Create an empty, using the given block size.

param
blocksize Size of blocks to allocate

    m_blocksize = blocksize;
    m_mapSize = 0;
public NodeSet(NodeList nodelist)
Create a NodeSet, and copy the members of the given nodelist into it.

param
nodelist List of Nodes to be made members of the new set.


    this(32);

    addNodes(nodelist);
public NodeSet(NodeSet nodelist)
Create a NodeSet, and copy the members of the given NodeSet into it.

param
nodelist Set of Nodes to be made members of the new set.


    this(32);

    addNodes((NodeIterator) nodelist);
public NodeSet(NodeIterator ni)
Create a NodeSet, and copy the members of the given NodeIterator into it.

param
ni Iterator which yields Nodes to be made members of the new set.


    this(32);

    addNodes(ni);
public NodeSet(Node node)
Create a NodeSet which contains the given Node.

param
node Single node to be added to the new set.


    this(32);

    addNode(node);
Methods Summary
public voidaddElement(org.w3c.dom.Node value)
Append a Node onto the vector.

param
value Node to add to the vector

    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    if ((m_firstFree + 1) >= m_mapSize)
    {
      if (null == m_map)
      {
        m_map = new Node[m_blocksize];
        m_mapSize = m_blocksize;
      }
      else
      {
        m_mapSize += m_blocksize;

        Node newMap[] = new Node[m_mapSize];

        System.arraycopy(m_map, 0, newMap, 0, m_firstFree + 1);

        m_map = newMap;
      }
    }

    m_map[m_firstFree] = value;

    m_firstFree++;
public voidaddNode(org.w3c.dom.Node n)
Add a node to the NodeSet. Not all types of NodeSets support this operation

param
n Node to be added
throws
RuntimeException thrown if this NodeSet is not of a mutable type.


    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    this.addElement(n);
public intaddNodeInDocOrder(org.w3c.dom.Node node, boolean test, com.sun.org.apache.xpath.internal.XPathContext support)
Add the node into a vector of nodes where it should occur in document order.

param
v Vector of nodes, presumably containing Nodes
param
obj Node object.
param
node The node to be added.
param
test true if we should test for doc order
param
support The XPath runtime context.
return
insertIndex.
throws
RuntimeException thrown if this NodeSet is not of a mutable type.


    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    int insertIndex = -1;

    if (test)
    {

      // This needs to do a binary search, but a binary search 
      // is somewhat tough because the sequence test involves 
      // two nodes.
      int size = size(), i;

      for (i = size - 1; i >= 0; i--)
      {
        Node child = (Node) elementAt(i);

        if (child == node)
        {
          i = -2;  // Duplicate, suppress insert

          break;
        }

        if (!DOM2Helper.isNodeAfter(node, child))
        {
          break;
        }
      }

      if (i != -2)
      {
        insertIndex = i + 1;

        insertElementAt(node, insertIndex);
      }
    }
    else
    {
      insertIndex = this.size();

      boolean foundit = false;

      for (int i = 0; i < insertIndex; i++)
      {
        if (this.item(i).equals(node))
        {
          foundit = true;

          break;
        }
      }

      if (!foundit)
        addElement(node);
    }

    // checkDups();
    return insertIndex;
public intaddNodeInDocOrder(org.w3c.dom.Node node, com.sun.org.apache.xpath.internal.XPathContext support)
Add the node into a vector of nodes where it should occur in document order.

param
v Vector of nodes, presumably containing Nodes
param
obj Node object.
param
node The node to be added.
param
support The XPath runtime context.
return
The index where it was inserted.
throws
RuntimeException thrown if this NodeSet is not of a mutable type.


    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    return addNodeInDocOrder(node, true, support);
public voidaddNodes(org.w3c.dom.NodeList nodelist)
Copy NodeList members into this nodelist, adding in document order. If a node is null, don't add it.

param
nodelist List of nodes which should now be referenced by this NodeSet.
throws
RuntimeException thrown if this NodeSet is not of a mutable type.


    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    if (null != nodelist)  // defensive to fix a bug that Sanjiva reported.
    {
      int nChildren = nodelist.getLength();

      for (int i = 0; i < nChildren; i++)
      {
        Node obj = nodelist.item(i);

        if (null != obj)
        {
          addElement(obj);
        }
      }
    }

    // checkDups();
public voidaddNodes(com.sun.org.apache.xpath.internal.NodeSet ns)

Copy NodeList members into this nodelist, adding in document order. Only genuine node references will be copied; nulls appearing in the source NodeSet will not be added to this one.

In case you're wondering why this function is needed: NodeSet implements both NodeIterator and NodeList. If this method isn't provided, Java can't decide which of those to use when addNodes() is invoked. Providing the more-explicit match avoids that ambiguity.)

param
ns NodeSet whose members should be merged into this NodeSet.
throws
RuntimeException thrown if this NodeSet is not of a mutable type.


    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    addNodes((NodeIterator) ns);
public voidaddNodes(org.w3c.dom.traversal.NodeIterator iterator)
Copy NodeList members into this nodelist, adding in document order. Null references are not added.

param
iterator NodeIterator which yields the nodes to be added.
throws
RuntimeException thrown if this NodeSet is not of a mutable type.


    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    if (null != iterator)  // defensive to fix a bug that Sanjiva reported.
    {
      Node obj;

      while (null != (obj = iterator.nextNode()))
      {
        addElement(obj);
      }
    }

    // checkDups();
public voidaddNodesInDocOrder(org.w3c.dom.NodeList nodelist, com.sun.org.apache.xpath.internal.XPathContext support)
Copy NodeList members into this nodelist, adding in document order. If a node is null, don't add it.

param
nodelist List of nodes to be added
param
support The XPath runtime context.
throws
RuntimeException thrown if this NodeSet is not of a mutable type.


    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    int nChildren = nodelist.getLength();

    for (int i = 0; i < nChildren; i++)
    {
      Node node = nodelist.item(i);

      if (null != node)
      {
        addNodeInDocOrder(node, support);
      }
    }
public voidaddNodesInDocOrder(org.w3c.dom.traversal.NodeIterator iterator, com.sun.org.apache.xpath.internal.XPathContext support)
Copy NodeList members into this nodelist, adding in document order. If a node is null, don't add it.

param
iterator NodeIterator which yields the nodes to be added.
param
support The XPath runtime context.
throws
RuntimeException thrown if this NodeSet is not of a mutable type.


    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    Node node;

    while (null != (node = iterator.nextNode()))
    {
      addNodeInDocOrder(node, support);
    }
private booleanaddNodesInDocOrder(int start, int end, int testIndex, org.w3c.dom.NodeList nodelist, com.sun.org.apache.xpath.internal.XPathContext support)
Add the node list to this node set in document order.

param
start index.
param
end index.
param
testIndex index.
param
nodelist The nodelist to add.
param
support The XPath runtime context.
return
false always.
throws
RuntimeException thrown if this NodeSet is not of a mutable type.


    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    boolean foundit = false;
    int i;
    Node node = nodelist.item(testIndex);

    for (i = end; i >= start; i--)
    {
      Node child = (Node) elementAt(i);

      if (child == node)
      {
        i = -2;  // Duplicate, suppress insert

        break;
      }

      if (!DOM2Helper.isNodeAfter(node, child))
      {
        insertElementAt(node, i + 1);

        testIndex--;

        if (testIndex > 0)
        {
          boolean foundPrev = addNodesInDocOrder(0, i, testIndex, nodelist,
                                                 support);

          if (!foundPrev)
          {
            addNodesInDocOrder(i, size() - 1, testIndex, nodelist, support);
          }
        }

        break;
      }
    }

    if (i == -1)
    {
      insertElementAt(node, 0);
    }

    return foundit;
public voidappendNodes(com.sun.org.apache.xpath.internal.NodeSet nodes)
Append the nodes to the list.

param
nodes NodeVector to append to this list


    int nNodes = nodes.size();

    if (null == m_map)
    {
      m_mapSize = nNodes + m_blocksize;
      m_map = new Node[m_mapSize];
    }
    else if ((m_firstFree + nNodes) >= m_mapSize)
    {
      m_mapSize += (nNodes + m_blocksize);

      Node newMap[] = new Node[m_mapSize];

      System.arraycopy(m_map, 0, newMap, 0, m_firstFree + nNodes);

      m_map = newMap;
    }

    System.arraycopy(nodes.m_map, 0, m_map, m_firstFree, nNodes);

    m_firstFree += nNodes;
public java.lang.Objectclone()
Get a cloned LocPathIterator.

return
A clone of this
throws
CloneNotSupportedException

  // lazy initialization

                
      
  

    NodeSet clone = (NodeSet) super.clone();

    if ((null != this.m_map) && (this.m_map == clone.m_map))
    {
      clone.m_map = new Node[this.m_map.length];

      System.arraycopy(this.m_map, 0, clone.m_map, 0, this.m_map.length);
    }

    return clone;
public org.w3c.dom.traversal.NodeIteratorcloneWithReset()
Get a cloned Iterator, and reset its state to the beginning of the iteration.

return
a new NodeSet of the same type, having the same state... except that the reset() operation has been called.
throws
CloneNotSupportedException if this subclass of NodeSet does not support the clone() operation.


    NodeSet clone = (NodeSet) clone();

    clone.reset();

    return clone;
public booleancontains(org.w3c.dom.Node s)
Tell if the table contains the given node.

param
s Node to look for
return
True if the given node was found.

    runTo(-1);

    if (null == m_map)
      return false;

    for (int i = 0; i < m_firstFree; i++)
    {
      Node node = m_map[i];

      if ((null != node) && node.equals(s))
        return true;
    }

    return false;
public voiddetach()
Detaches the iterator from the set which it iterated over, releasing any computational resources and placing the iterator in the INVALID state. Afterdetach has been invoked, calls to nextNode orpreviousNode will raise the exception INVALID_STATE_ERR.

This operation is a no-op in NodeSet, and will not cause INVALID_STATE_ERR to be raised by later operations. 

public org.w3c.dom.NodeelementAt(int i)
Get the nth element.
param
i Index of node to get
return
Node at specified index

    if (null == m_map)
      return null;

    return m_map[i];
  
public org.w3c.dom.NodegetCurrentNode()
Return the last fetched node. Needed to support the UnionPathIterator.
return
the last fetched node.
throws
RuntimeException thrown if this NodeSet is not of
a cached type, and thus doesn't permit indexed access.

    if (!m_cacheNodes)
      throw new RuntimeException(
        XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_INDEX, null)); //"This NodeSet can not do indexing or counting functions!");

    int saved = m_next;
    Node n = (m_next < m_firstFree) ? elementAt(m_next) : null;
    m_next = saved; // HACK: I think this is a bit of a hack.  -sb
    return n;
  
public intgetCurrentPos()
Get the current position, which is one less than
the next nextNode() call will retrieve. i.e. if
you call getCurrentPos() and the return is 0, the next
fetch will take place at index 1.
return
The the current position index.

                                              
    
  
    return m_next;
  
public booleangetExpandEntityReferences()
The value of this flag determines whether the children of entity
reference nodes are visible to the iterator. If false, they will be
skipped over.

 To produce a view of the document that has entity references
expanded and does not expose the entity reference node itself, use the
whatToShow flags to hide the entity reference node and set
expandEntityReferences to true when creating the iterator. To produce
a view of the document that has entity reference nodes but no entity
expansion, use the whatToShow flags to show the entity reference node
and set expandEntityReferences to false.
return
true for all iterators based on NodeSet, meaning that the
contents of EntityRefrence nodes may be returned (though whatToShow
says that the EntityReferences themselves are not shown.)
    return true;
  
public org.w3c.dom.traversal.NodeFiltergetFilter()
The filter object used to screen nodes. Filters are applied to
further reduce (and restructure) the NodeIterator's view of the
document. In our case, we will be using hardcoded filters built
into our iterators... but getFilter() is part of the DOM's
NodeIterator interface, so we have to support it.
return
null, which is slightly misleading. True, there is no
user-written filter object, but in fact we are doing some very
sophisticated custom filtering. A DOM purist might suggest
returning a placeholder object just to indicate that this is
not going to return all nodes selected by whatToShow.
    return null;
  
public intgetLast()
  
    
  
    return m_last;
  
public intgetLength()
The number of nodes in the list. The range of valid child node indices is
0 to length-1 inclusive. Note that this operation requires
finding all the matching nodes, which may defeat attempts to defer
that work.
return
integer indicating how many nodes are represented by this list.

    runTo(-1);

    return this.size();
  
public org.w3c.dom.NodegetRoot()
return
The root node of the Iterator, as specified when it was created.
For non-Iterator NodeSets, this will be null.
    return null;
  
public booleangetShouldCacheNodes()
Get whether or not this is a cached node set.
return
True if this list is cached.

                      
    
  
    return m_cacheNodes;
  
public intgetWhatToShow()
This attribute determines which node types are presented via the
iterator. The available set of constants is defined in the
NodeFilter interface. For NodeSets, the mask has been
hardcoded to show all nodes except EntityReference nodes, which have
no equivalent in the XPath data model.
return
integer used as a bit-array, containing flags defined in
the DOM's NodeFilter class. The value will be
SHOW_ALL & ~SHOW_ENTITY_REFERENCE, meaning that
only entity references are suppressed.
    return NodeFilter.SHOW_ALL & ~NodeFilter.SHOW_ENTITY_REFERENCE;
  
public intindexOf(org.w3c.dom.Node elem, int index)
Searches for the first occurence of the given argument,
beginning the search at index, and testing for equality
using the equals method.
param
elem Node to look for
param
index Index of where to start the search
return
the index of the first occurrence of the object
argument in this vector at position index or later in the
vector; returns -1 if the object is not found.
    runTo(-1);

    if (null == m_map)
      return -1;

    for (int i = index; i < m_firstFree; i++)
    {
      Node node = m_map[i];

      if ((null != node) && node.equals(elem))
        return i;
    }

    return -1;
  
public intindexOf(org.w3c.dom.Node elem)
Searches for the first occurence of the given argument,
beginning the search at index, and testing for equality
using the equals method.
param
elem Node to look for
return
the index of the first occurrence of the object
argument in this vector at position index or later in the
vector; returns -1 if the object is not found.
    runTo(-1);

    if (null == m_map)
      return -1;

    for (int i = 0; i < m_firstFree; i++)
    {
      Node node = m_map[i];

      if ((null != node) && node.equals(elem))
        return i;
    }

    return -1;
  
public voidinsertElementAt(org.w3c.dom.Node value, int at)
Inserts the specified node in this vector at the specified index.
Each component in this vector with an index greater or equal to
the specified index is shifted upward to have an index one greater
than the value it had previously.
param
value Node to insert
param
at Position where to insert
    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    if (null == m_map)
    {
      m_map = new Node[m_blocksize];
      m_mapSize = m_blocksize;
    }
    else if ((m_firstFree + 1) >= m_mapSize)
    {
      m_mapSize += m_blocksize;

      Node newMap[] = new Node[m_mapSize];

      System.arraycopy(m_map, 0, newMap, 0, m_firstFree + 1);

      m_map = newMap;
    }

    if (at <= (m_firstFree - 1))
    {
      System.arraycopy(m_map, at, m_map, at + 1, m_firstFree - at);
    }

    m_map[at] = value;

    m_firstFree++;
  
public voidinsertNode(org.w3c.dom.Node n, int pos)
Insert a node at a given position.
param
n Node to be added
param
pos Offset at which the node is to be inserted,
with 0 being the first position.
throws
RuntimeException thrown if this NodeSet is not of
a mutable type.

    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    insertElementAt(n, pos);
  
public booleanisFresh()
Tells if this NodeSet is "fresh", in other words, if
the first nextNode() that is called will return the
first node in the set.
return
true if nextNode() would return the first node in the set,
false if it would return a later one.
    return (m_next == 0);
  
public org.w3c.dom.Nodeitem(int index)
Returns the indexth item in the collection. If
index is greater than or equal to the number of nodes in
the list, this returns null.

TODO: What happens if index is out of range?
param
index Index into the collection.
return
The node at the indexth position in the
NodeList, or null if that is not a valid
index.

    runTo(index);

    return (Node) this.elementAt(index);
  
public org.w3c.dom.NodenextNode()
Returns the next node in the set and advances the position of the
iterator in the set. After a NodeIterator is created, the first call
to nextNode() returns the first node in the set.
return
The next Node in the set being iterated over, or
null if there are no more members in that set.
throws
DOMException
INVALID_STATE_ERR: Raised if this method is called after the
detach method was invoked.

    if ((m_next) < this.size())
    {
      Node next = this.elementAt(m_next);

      m_next++;

      return next;
    }
    else
      return null;
  
public final org.w3c.dom.NodepeepOrNull()
Return the node at the top of the stack without popping the stack.
Special purpose method for TransformerImpl, pushElemTemplateElement.
Performance critical.
return
Node at the top of the stack or null if stack is empty.
    return ((null != m_map) && (m_firstFree > 0))
           ? m_map[m_firstFree - 1] : null;
  
public final org.w3c.dom.NodepeepTail()
Return the node at the tail of the vector without popping
Special purpose method for TransformerImpl, pushElemTemplateElement.
Performance critical.
return
Node at the tail of the vector
    return m_map[m_firstFree - 1];
  
public final org.w3c.dom.NodepeepTailSub1()
Return the node one position from the tail without popping.
Special purpose method for TransformerImpl, pushElemTemplateElement.
Performance critical.
return
Node one away from the tail
    return m_map[m_firstFree - 2];
  
public final org.w3c.dom.Nodepop()
Pop a node from the tail of the vector and return the result.
return
the node at the tail of the vector

    m_firstFree--;

    Node n = m_map[m_firstFree];

    m_map[m_firstFree] = null;

    return n;
  
public final org.w3c.dom.NodepopAndTop()
Pop a node from the tail of the vector and return the
top of the stack after the pop.
return
The top of the stack after it's been popped

    m_firstFree--;

    m_map[m_firstFree] = null;

    return (m_firstFree == 0) ? null : m_map[m_firstFree - 1];
  
public final voidpopPair()
Pop a pair of nodes from the tail of the stack.
Special purpose method for TransformerImpl, pushElemTemplateElement.
Performance critical.

    m_firstFree -= 2;
    m_map[m_firstFree] = null;
    m_map[m_firstFree + 1] = null;
  
public final voidpopQuick()
Pop a node from the tail of the vector.

    m_firstFree--;

    m_map[m_firstFree] = null;
  
public org.w3c.dom.NodepreviousNode()
Returns the previous node in the set and moves the position of the
iterator backwards in the set.
return
The previous Node in the set being iterated over,
ornull if there are no more members in that set.
throws
DOMException
INVALID_STATE_ERR: Raised if this method is called after the
detach method was invoked.
throws
RuntimeException thrown if this NodeSet is not of
a cached type, and hence doesn't know what the previous node was.

    if (!m_cacheNodes)
      throw new RuntimeException(
        XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_ITERATE, null)); //"This NodeSet can not iterate to a previous node!");

    if ((m_next - 1) > 0)
    {
      m_next--;

      return this.elementAt(m_next);
    }
    else
      return null;
  
public final voidpush(org.w3c.dom.Node value)
Append a Node onto the vector.
param
value Node to add to the vector

    int ff = m_firstFree;

    if ((ff + 1) >= m_mapSize)
    {
      if (null == m_map)
      {
        m_map = new Node[m_blocksize];
        m_mapSize = m_blocksize;
      }
      else
      {
        m_mapSize += m_blocksize;

        Node newMap[] = new Node[m_mapSize];

        System.arraycopy(m_map, 0, newMap, 0, ff + 1);

        m_map = newMap;
      }
    }

    m_map[ff] = value;

    ff++;

    m_firstFree = ff;
  
public final voidpushPair(org.w3c.dom.Node v1, org.w3c.dom.Node v2)
Push a pair of nodes into the stack.
Special purpose method for TransformerImpl, pushElemTemplateElement.
Performance critical.
param
v1 First node to add to vector
param
v2 Second node to add to vector

    if (null == m_map)
    {
      m_map = new Node[m_blocksize];
      m_mapSize = m_blocksize;
    }
    else
    {
      if ((m_firstFree + 2) >= m_mapSize)
      {
        m_mapSize += m_blocksize;

        Node newMap[] = new Node[m_mapSize];

        System.arraycopy(m_map, 0, newMap, 0, m_firstFree);

        m_map = newMap;
      }
    }

    m_map[m_firstFree] = v1;
    m_map[m_firstFree + 1] = v2;
    m_firstFree += 2;
  
public voidremoveAllElements()
Inserts the specified node in this vector at the specified index.
Each component in this vector with an index greater or equal to
the specified index is shifted upward to have an index one greater
than the value it had previously.

    if (null == m_map)
      return;

    for (int i = 0; i < m_firstFree; i++)
    {
      m_map[i] = null;
    }

    m_firstFree = 0;
  
public booleanremoveElement(org.w3c.dom.Node s)
Removes the first occurrence of the argument from this vector.
If the object is found in this vector, each component in the vector
with an index greater or equal to the object's index is shifted
downward to have an index one smaller than the value it had
previously.
param
s Node to remove from the list
return
True if the node was successfully removed
    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    if (null == m_map)
      return false;

    for (int i = 0; i < m_firstFree; i++)
    {
      Node node = m_map[i];

      if ((null != node) && node.equals(s))
      {
        if (i < m_firstFree - 1)
          System.arraycopy(m_map, i + 1, m_map, i, m_firstFree - i - 1);

        m_firstFree--;
        m_map[m_firstFree] = null;

        return true;
      }
    }

    return false;
  
public voidremoveElementAt(int i)
Deletes the component at the specified index. Each component in
this vector with an index greater or equal to the specified
index is shifted downward to have an index one smaller than
the value it had previously.
param
i Index of node to remove

    if (null == m_map)
      return;
      
    if (i >= m_firstFree)
      throw new ArrayIndexOutOfBoundsException(i + " >= " + m_firstFree);
    else if (i < 0)
      throw new ArrayIndexOutOfBoundsException(i);

    if (i < m_firstFree - 1)
      System.arraycopy(m_map, i + 1, m_map, i, m_firstFree - i - 1);

    m_firstFree--;
    m_map[m_firstFree] = null;
  
public voidremoveNode(org.w3c.dom.Node n)
Remove a node.
param
n Node to be added
throws
RuntimeException thrown if this NodeSet is not of
a mutable type.

    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    this.removeElement(n);
  
public voidreset()
Reset the iterator. May have no effect on non-iterator Nodesets.
    m_next = 0;
  
public voidrunTo(int index)
If an index is requested, NodeSet will call this method
to run the iterator to the index. By default this sets
m_next to the index. If the index argument is -1, this
signals that the iterator should be run to the end.
param
index Position to advance (or retreat) to, with
0 requesting the reset ("fresh") position and -1 (or indeed
any out-of-bounds value) requesting the final position.
throws
RuntimeException thrown if this NodeSet is not
one of the types which supports indexing/counting.

    if (!m_cacheNodes)
      throw new RuntimeException(
        XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_INDEX, null)); //"This NodeSet can not do indexing or counting functions!");

    if ((index >= 0) && (m_next < m_firstFree))
      m_next = index;
    else
      m_next = m_firstFree - 1;
  
public voidsetCurrentPos(int i)
Set the current position in the node set.
param
i Must be a valid index.
throws
RuntimeException thrown if this NodeSet is not of
a cached type, and thus doesn't permit indexed access.

    if (!m_cacheNodes)
      throw new RuntimeException(
        XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_INDEX, null)); //"This NodeSet can not do indexing or counting functions!");

    m_next = i;
  
public voidsetElementAt(org.w3c.dom.Node node, int index)
Sets the component at the specified index of this vector to be the
specified object. The previous component at that position is discarded.

The index must be a value greater than or equal to 0 and less
than the current size of the vector.
param
node Node to set
param
index Index of where to set the node
    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    if (null == m_map)
    {
      m_map = new Node[m_blocksize];
      m_mapSize = m_blocksize;
    }

    m_map[index] = node;
  
public voidsetLast(int last)
    m_last = last;
  
public voidsetShouldCacheNodes(boolean b)
If setShouldCacheNodes(true) is called, then nodes will
be cached. They are not cached by default. This switch must
be set before the first call to nextNode is made, to ensure
that all nodes are cached.
param
b true if this node set should be cached.
throws
RuntimeException thrown if an attempt is made to
request caching after we've already begun stepping through the
nodes in this set.

    if (!isFresh())
      throw new RuntimeException(
        XSLMessages.createXPATHMessage(XPATHErrorResources.ER_CANNOT_CALL_SETSHOULDCACHENODE, null)); //"Can not call setShouldCacheNodes after nextNode has been called!");

    m_cacheNodes = b;
    m_mutable = true;
  
public final voidsetTail(org.w3c.dom.Node n)
Set the tail of the stack to the given node.
Special purpose method for TransformerImpl, pushElemTemplateElement.
Performance critical.
param
n Node to set at the tail of vector
    m_map[m_firstFree - 1] = n;
  
public final voidsetTailSub1(org.w3c.dom.Node n)
Set the given node one position from the tail.
Special purpose method for TransformerImpl, pushElemTemplateElement.
Performance critical.
param
n Node to set
    m_map[m_firstFree - 2] = n;
  
public intsize()
Get the length of the list.
return
Number of nodes in this NodeVector
    return m_firstFree;