com.sun.org.apache.xml.internal.utils.DOM2Helper Java Examples

/**
 * The set:leading function returns the nodes in the node set passed as the first argument that
 * precede, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that precede in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList leading (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet leadNodes = new NodeSet();
  Node endNode = nl2.item(0);
  if (!ns1.contains(endNode))
    return leadNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(testNode, endNode)
        && !DOM2Helper.isNodeTheSame(testNode, endNode))
      leadNodes.addElement(testNode);
  }
  return leadNodes;
}
 

/**
 * The set:leading function returns the nodes in the node set passed as the first argument that
 * precede, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that precede in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList leading (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet leadNodes = new NodeSet();
  Node endNode = nl2.item(0);
  if (!ns1.contains(endNode))
    return leadNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(testNode, endNode)
        && !DOM2Helper.isNodeTheSame(testNode, endNode))
      leadNodes.addElement(testNode);
  }
  return leadNodes;
}
 

/**
 * The set:trailing function returns the nodes in the node set passed as the first argument that
 * follow, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that follow in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList trailing (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet trailNodes = new NodeSet();
  Node startNode = nl2.item(0);
  if (!ns1.contains(startNode))
    return trailNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(startNode, testNode)
        && !DOM2Helper.isNodeTheSame(startNode, testNode))
      trailNodes.addElement(testNode);
  }
  return trailNodes;
}
 

/**
 * The set:trailing function returns the nodes in the node set passed as the first argument that
 * follow, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that follow in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList trailing (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet trailNodes = new NodeSet();
  Node startNode = nl2.item(0);
  if (!ns1.contains(startNode))
    return trailNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(startNode, testNode)
        && !DOM2Helper.isNodeTheSame(startNode, testNode))
      trailNodes.addElement(testNode);
  }
  return trailNodes;
}
 

/**
 * The set:trailing function returns the nodes in the node set passed as the first argument that
 * follow, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that follow in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList trailing (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet trailNodes = new NodeSet();
  Node startNode = nl2.item(0);
  if (!ns1.contains(startNode))
    return trailNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(startNode, testNode)
        && !DOM2Helper.isNodeTheSame(startNode, testNode))
      trailNodes.addElement(testNode);
  }
  return trailNodes;
}
 

/**
 * The set:leading function returns the nodes in the node set passed as the first argument that
 * precede, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that precede in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList leading (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet leadNodes = new NodeSet();
  Node endNode = nl2.item(0);
  if (!ns1.contains(endNode))
    return leadNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(testNode, endNode)
        && !DOM2Helper.isNodeTheSame(testNode, endNode))
      leadNodes.addElement(testNode);
  }
  return leadNodes;
}
 

/**
 * The set:leading function returns the nodes in the node set passed as the first argument that
 * precede, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that precede in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList leading (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet leadNodes = new NodeSet();
  Node endNode = nl2.item(0);
  if (!ns1.contains(endNode))
    return leadNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(testNode, endNode)
        && !DOM2Helper.isNodeTheSame(testNode, endNode))
      leadNodes.addElement(testNode);
  }
  return leadNodes;
}
 

/**
 * The set:trailing function returns the nodes in the node set passed as the first argument that
 * follow, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that follow in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList trailing (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet trailNodes = new NodeSet();
  Node startNode = nl2.item(0);
  if (!ns1.contains(startNode))
    return trailNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(startNode, testNode)
        && !DOM2Helper.isNodeTheSame(startNode, testNode))
      trailNodes.addElement(testNode);
  }
  return trailNodes;
}
 

/**
 * The set:leading function returns the nodes in the node set passed as the first argument that
 * precede, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that precede in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList leading (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet leadNodes = new NodeSet();
  Node endNode = nl2.item(0);
  if (!ns1.contains(endNode))
    return leadNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(testNode, endNode)
        && !DOM2Helper.isNodeTheSame(testNode, endNode))
      leadNodes.addElement(testNode);
  }
  return leadNodes;
}
 

/**
 * The set:trailing function returns the nodes in the node set passed as the first argument that
 * follow, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that follow in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList trailing (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet trailNodes = new NodeSet();
  Node startNode = nl2.item(0);
  if (!ns1.contains(startNode))
    return trailNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(startNode, testNode)
        && !DOM2Helper.isNodeTheSame(startNode, testNode))
      trailNodes.addElement(testNode);
  }
  return trailNodes;
}
 

/**
 * 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.
 */
private boolean addNodesInDocOrder(int start, int end, int testIndex,
                                   NodeList nodelist, XPathContext support)
{

  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;
}
 

/**
 * 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.
 */
private boolean addNodesInDocOrder(int start, int end, int testIndex,
                                   NodeList nodelist, XPathContext support)
{

  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 = 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;
}
 

/**
 * Add the node into a vector of nodes where it should occur in
 * document order.
 * @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.
 */
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 = 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 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.
 */
private boolean addNodesInDocOrder(int start, int end, int testIndex,
                                   NodeList nodelist, XPathContext support)
{

  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;
}
 

/**
 * Add the node into a vector of nodes where it should occur in
 * document order.
 * @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.
 */
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.
 * @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.
 */
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.
 * @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.
 */
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 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.
 */
private boolean addNodesInDocOrder(int start, int end, int testIndex,
                                   NodeList nodelist, XPathContext support)
{

  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;
}
 

/**
 * Add the node into a vector of nodes where it should occur in
 * document order.
 * @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.
 */
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 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.
 */
private boolean addNodesInDocOrder(int start, int end, int testIndex,
                                   NodeList nodelist, XPathContext support)
{

  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;
}
 

/**
 * 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.
 */
private boolean addNodesInDocOrder(int start, int end, int testIndex,
                                   NodeList nodelist, XPathContext support)
{

  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;
}
 

/**
 * Add the node into a vector of nodes where it should occur in
 * document order.
 * @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.
 */
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 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.
 */
private boolean addNodesInDocOrder(int start, int end, int testIndex,
                                   NodeList nodelist, XPathContext support)
{

  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;
}
 

/**
 * Add the node into a vector of nodes where it should occur in
 * document order.
 * @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.
 */
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 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.
 */
private boolean addNodesInDocOrder(int start, int end, int testIndex,
                                   NodeList nodelist, XPathContext support)
{

  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;
}
 

/**
 * Add the node into a vector of nodes where it should occur in
 * document order.
 * @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.
 */
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 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.
 */
private boolean addNodesInDocOrder(int start, int end, int testIndex,
                                   NodeList nodelist, XPathContext support)
{

  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;
}
 

/**
 * Add the node into a vector of nodes where it should occur in
 * document order.
 * @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.
 */
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 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.
 */
private boolean addNodesInDocOrder(int start, int end, int testIndex,
                                   NodeList nodelist, XPathContext support)
{

  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;
}
 

/**
 * Add the node into a vector of nodes where it should occur in
 * document order.
 * @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.
 */
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;
}