serial:

serial:

serial:

 public NodeSet() 
{
    m_blocksize = 32;
    m_mapSize = 0;
}

Create an empty nodelist.

 public NodeSet(int blocksize) 
{
    m_blocksize = blocksize;
    m_mapSize = 0;
}

Create an empty, using the given block size.

Parameters:

blocksize - Size of blocks to allocate

 public NodeSet(NodeList nodelist) 
{
    this(32);
    addNodes(nodelist);
}

Create a NodeSet, and copy the members of the given nodelist into it.

Parameters:

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

 public NodeSet(NodeSet nodelist) 
{
    this(32);
    addNodes((NodeIterator) nodelist);
}

Create a NodeSet, and copy the members of the given NodeSet into it.

Parameters:

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

 public NodeSet(NodeIterator ni) 
{
    this(32);
    addNodes(ni);
}

Create a NodeSet, and copy the members of the given NodeIterator into it.

Parameters:

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

 public NodeSet(Node node) 
{
    this(32);
    addNode(node);
}

Create a NodeSet which contains the given Node.

Parameters:

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

 public  void addElement(Node value) 
{
    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++;
}

Append a Node onto the vector.

 public  void addNode(Node n) 
{
    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
    this.addElement(n);
}

Add a node to the NodeSet. Not all types of NodeSets support this operation

 public int addNodeInDocOrder(Node node,
    XPathContext support) 
{
    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
    return addNodeInDocOrder(node, true, support);
}

Add the node into a vector of nodes where it should occur in document order.

 public int addNodeInDocOrder(Node node,
    boolean test,
    XPathContext support) 
{
    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;
}

Add the node into a vector of nodes where it should occur in document order.

 public  void addNodes(NodeList nodelist) 
{
    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();
}

Copy NodeList members into this nodelist, adding in document order. If a node is null, don't add it.

 public  void addNodes(NodeSet ns) 
{
    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
    addNodes((NodeIterator) 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.)

 public  void addNodes(NodeIterator iterator) 
{
    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();
}

Copy NodeList members into this nodelist, adding in document order. Null references are not added.

 public  void addNodesInDocOrder(NodeList nodelist,
    XPathContext support) 
{
    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);
      }
    }
}

Copy NodeList members into this nodelist, adding in document order. If a node is null, don't add it.

 public  void addNodesInDocOrder(NodeIterator iterator,
    XPathContext support) 
{
    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);
    }
}

Copy NodeList members into this nodelist, adding in document order. If a node is null, don't add it.

 public  void appendNodes(NodeSet nodes) 
{
    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;
}

Append the nodes to the list.

 public Object clone() 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;
}

Get a cloned LocPathIterator.

 public NodeIterator cloneWithReset() throws CloneNotSupportedException 
{
    NodeSet clone = (NodeSet) clone();
    clone.reset();
    return clone;
}

Get a cloned Iterator, and reset its state to the beginning of the iteration.

 public boolean contains(Node s) 
{
    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;
}

Tell if the table contains the given node.

 public  void detach() 
{

}

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 Node elementAt(int i) 
{
    if (null == m_map)
      return null;
    return m_map[i];
}

Get the nth element.

 public Node getCurrentNode() 
{
    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;
}

Return the last fetched node. Needed to support the UnionPathIterator.

 public int getCurrentPos() 
{
                                              
    return m_next;
}

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.

 public boolean getExpandEntityReferences() 
{
    return true;
}

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.

 public NodeFilter getFilter() 
{
    return null;
}

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.

 public int getLast() 
{
    
    return m_last;
}

 public int getLength() 
{
    runTo(-1);
    return this.size();
}

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.

 public Node getRoot() 
{
    return null;
}

 public boolean getShouldCacheNodes() 
{
                      
    return m_cacheNodes;
}

Get whether or not this is a cached node set.

 public int getWhatToShow() 
{
    return NodeFilter.SHOW_ALL & ~NodeFilter.SHOW_ENTITY_REFERENCE;
}

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.

 public int indexOf(Node elem) 
{
    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;
}

Searches for the first occurence of the given argument, beginning the search at index, and testing for equality using the equals method.

 public int indexOf(Node elem,
    int index) 
{
    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;
}

Searches for the first occurence of the given argument, beginning the search at index, and testing for equality using the equals method.

 public  void insertElementAt(Node value,
    int at) 
{
    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++;
}

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.

 public  void insertNode(Node n,
    int pos) 
{
    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
    insertElementAt(n, pos);
}

Insert a node at a given position.

 public boolean isFresh() 
{
    return (m_next == 0);
}

Tells if this NodeSet is "fresh", in other words, if the first nextNode() that is called will return the first node in the set.

 public Node item(int index) 
{
    runTo(index);
    return (Node) this.elementAt(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?

 public Node nextNode() throws DOMException 
{
    if ((m_next) <  this.size())
    {
      Node next = this.elementAt(m_next);
      m_next++;
      return next;
    }
    else
      return null;
}

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.

 public final Node peepOrNull() 
{
    return ((null != m_map) && (m_firstFree  > 0))
           ? m_map[m_firstFree - 1] : null;
}

Return the node at the top of the stack without popping the stack. Special purpose method for TransformerImpl, pushElemTemplateElement. Performance critical.

 public final Node peepTail() 
{
    return m_map[m_firstFree - 1];
}

Return the node at the tail of the vector without popping Special purpose method for TransformerImpl, pushElemTemplateElement. Performance critical.

 public final Node peepTailSub1() 
{
    return m_map[m_firstFree - 2];
}

Return the node one position from the tail without popping. Special purpose method for TransformerImpl, pushElemTemplateElement. Performance critical.

 public final Node pop() 
{
    m_firstFree--;
    Node n = m_map[m_firstFree];
    m_map[m_firstFree] = null;
    return n;
}

Pop a node from the tail of the vector and return the result.

 public final Node popAndTop() 
{
    m_firstFree--;
    m_map[m_firstFree] = null;
    return (m_firstFree == 0) ? null : m_map[m_firstFree - 1];
}

Pop a node from the tail of the vector and return the top of the stack after the pop.

 public final  void popPair() 
{
    m_firstFree -= 2;
    m_map[m_firstFree] = null;
    m_map[m_firstFree + 1] = null;
}

Pop a pair of nodes from the tail of the stack. Special purpose method for TransformerImpl, pushElemTemplateElement. Performance critical.

 public final  void popQuick() 
{
    m_firstFree--;
    m_map[m_firstFree] = null;
}

Pop a node from the tail of the vector.

 public Node previousNode() throws DOMException 
{
    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;
}

Returns the previous node in the set and moves the position of the iterator backwards in the set.

 public final  void push(Node value) 
{
    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;
}

Append a Node onto the vector.

 public final  void pushPair(Node v1,
    Node v2) 
{
    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;
}

Push a pair of nodes into the stack. Special purpose method for TransformerImpl, pushElemTemplateElement. Performance critical.

 public  void removeAllElements() 
{
    if (null == m_map)
      return;
    for (int i = 0; i <  m_firstFree; i++)
    {
      m_map[i] = null;
    }
    m_firstFree = 0;
}

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.

 public boolean removeElement(Node s) 
{
    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;
}

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.

 public  void removeElementAt(int i) 
{
    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;
}

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.

 public  void removeNode(Node n) 
{
    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
    this.removeElement(n);
}

Remove a node.

 public  void reset() 
{
    m_next = 0;
}

Reset the iterator. May have no effect on non-iterator Nodesets.

 public  void runTo(int index) 
{
    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;
}

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.

 public  void setCurrentPos(int i) 
{
    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;
}

Set the current position in the node set.

 public  void setElementAt(Node node,
    int index) 
{
    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;
}

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.

 public  void setLast(int last) 
{
    m_last = last;
}

 public  void setShouldCacheNodes(boolean b) 
{
    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;
}

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.

 public final  void setTail(Node n) 
{
    m_map[m_firstFree - 1] = n;
}

Set the tail of the stack to the given node. Special purpose method for TransformerImpl, pushElemTemplateElement. Performance critical.

 public final  void setTailSub1(Node n) 
{
    m_map[m_firstFree - 2] = n;
}

Set the given node one position from the tail. Special purpose method for TransformerImpl, pushElemTemplateElement. Performance critical.

 public int size() 
{
    return m_firstFree;
}

Get the length of the list.