Java Code Examples for com.sun.org.apache.xml.internal.dtm.DTM#isNodeAfter()

/**
 *  Returns the next node in the set and advances the position of the
 * iterator in the set. After a DTMIterator is created, the first call
 * to nextNode() returns the first node in the set.
 * @return  The next <code>Node</code> in the set being iterated over, or
 *   <code>null</code> if there are no more members in that set.
 */
public int nextNode()
{
      if(m_foundLast)
              return DTM.NULL;

  // Loop through the iterators getting the current fetched
  // node, and get the earliest occuring in document order
  int earliestNode = DTM.NULL;

  if (null != m_iterators)
  {
    int n = m_iterators.length;
    int iteratorUsed = -1;

    for (int i = 0; i < n; i++)
    {
      int node = m_iterators[i].getCurrentNode();

      if (DTM.NULL == node)
        continue;
      else if (DTM.NULL == earliestNode)
      {
        iteratorUsed = i;
        earliestNode = node;
      }
      else
      {
        if (node == earliestNode)
        {

          // Found a duplicate, so skip past it.
          m_iterators[i].nextNode();
        }
        else
        {
          DTM dtm = getDTM(node);

          if (dtm.isNodeAfter(node, earliestNode))
          {
            iteratorUsed = i;
            earliestNode = node;
          }
        }
      }
    }

    if (DTM.NULL != earliestNode)
    {
      m_iterators[iteratorUsed].nextNode();

      incrementCurrentPos();
    }
    else
      m_foundLast = true;
  }

  m_lastFetched = earliestNode;

  return earliestNode;
}
 

/**
 *  Returns the next node in the set and advances the position of the
 * iterator in the set. After a DTMIterator is created, the first call
 * to nextNode() returns the first node in the set.
 * @return  The next <code>Node</code> in the set being iterated over, or
 *   <code>null</code> if there are no more members in that set.
 */
public int nextNode()
{
      if(m_foundLast)
              return DTM.NULL;

  // Loop through the iterators getting the current fetched
  // node, and get the earliest occuring in document order
  int earliestNode = DTM.NULL;

  if (null != m_iterators)
  {
    int n = m_iterators.length;
    int iteratorUsed = -1;

    for (int i = 0; i < n; i++)
    {
      int node = m_iterators[i].getCurrentNode();

      if (DTM.NULL == node)
        continue;
      else if (DTM.NULL == earliestNode)
      {
        iteratorUsed = i;
        earliestNode = node;
      }
      else
      {
        if (node == earliestNode)
        {

          // Found a duplicate, so skip past it.
          m_iterators[i].nextNode();
        }
        else
        {
          DTM dtm = getDTM(node);

          if (dtm.isNodeAfter(node, earliestNode))
          {
            iteratorUsed = i;
            earliestNode = node;
          }
        }
      }
    }

    if (DTM.NULL != earliestNode)
    {
      m_iterators[iteratorUsed].nextNode();

      incrementCurrentPos();
    }
    else
      m_foundLast = true;
  }

  m_lastFetched = earliestNode;

  return earliestNode;
}
 

/**
* Add the node into a vector of nodes where it should occur in
* document order.
* @param node The node to be added.
* @return insertIndex.
* @throws RuntimeException thrown if this NodeSetDTM is not of
* a mutable type.
*/
protected int addNodeInDocOrder(int node)
{
   assertion(hasCache(), "addNodeInDocOrder must be done on a mutable sequence!");

   int insertIndex = -1;

   NodeVector vec = getVector();

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

   for (i = size - 1; i >= 0; i--)
   {
     int child = vec.elementAt(i);

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

       break;
     }

     DTM dtm = m_dtmMgr.getDTM(node);
     if (!dtm.isNodeAfter(node, child))
     {
       break;
     }
   }

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

     vec.insertElementAt(node, insertIndex);
   }

   // 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 NodeSetDTM is not of
 * a mutable type.
 */
public int addNodeInDocOrder(int node, boolean test, XPathContext support)
{

  if (!m_mutable)
    throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESETDTM_NOT_MUTABLE, null)); //"This NodeSetDTM 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--)
    {
      int child = elementAt(i);

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

        break;
      }

      DTM dtm = support.getDTM(node);
      if (!dtm.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 (i == node)
      {
        foundit = true;

        break;
      }
    }

    if (!foundit)
      addElement(node);
  }

  // checkDups();
  return insertIndex;
}
 

/**
 *  Returns the next node in the set and advances the position of the
 * iterator in the set. After a DTMIterator is created, the first call
 * to nextNode() returns the first node in the set.
 * @return  The next <code>Node</code> in the set being iterated over, or
 *   <code>null</code> if there are no more members in that set.
 */
public int nextNode()
{
      if(m_foundLast)
              return DTM.NULL;

  // Loop through the iterators getting the current fetched
  // node, and get the earliest occuring in document order
  int earliestNode = DTM.NULL;

  if (null != m_iterators)
  {
    int n = m_iterators.length;
    int iteratorUsed = -1;

    for (int i = 0; i < n; i++)
    {
      int node = m_iterators[i].getCurrentNode();

      if (DTM.NULL == node)
        continue;
      else if (DTM.NULL == earliestNode)
      {
        iteratorUsed = i;
        earliestNode = node;
      }
      else
      {
        if (node == earliestNode)
        {

          // Found a duplicate, so skip past it.
          m_iterators[i].nextNode();
        }
        else
        {
          DTM dtm = getDTM(node);

          if (dtm.isNodeAfter(node, earliestNode))
          {
            iteratorUsed = i;
            earliestNode = node;
          }
        }
      }
    }

    if (DTM.NULL != earliestNode)
    {
      m_iterators[iteratorUsed].nextNode();

      incrementCurrentPos();
    }
    else
      m_foundLast = true;
  }

  m_lastFetched = earliestNode;

  return earliestNode;
}
 

/**
 *  Returns the next node in the set and advances the position of the
 * iterator in the set. After a DTMIterator is created, the first call
 * to nextNode() returns the first node in the set.
 * @return  The next <code>Node</code> in the set being iterated over, or
 *   <code>null</code> if there are no more members in that set.
 */
public int nextNode()
{
      if(m_foundLast)
              return DTM.NULL;

  // Loop through the iterators getting the current fetched
  // node, and get the earliest occuring in document order
  int earliestNode = DTM.NULL;

  if (null != m_iterators)
  {
    int n = m_iterators.length;
    int iteratorUsed = -1;

    for (int i = 0; i < n; i++)
    {
      int node = m_iterators[i].getCurrentNode();

      if (DTM.NULL == node)
        continue;
      else if (DTM.NULL == earliestNode)
      {
        iteratorUsed = i;
        earliestNode = node;
      }
      else
      {
        if (node == earliestNode)
        {

          // Found a duplicate, so skip past it.
          m_iterators[i].nextNode();
        }
        else
        {
          DTM dtm = getDTM(node);

          if (dtm.isNodeAfter(node, earliestNode))
          {
            iteratorUsed = i;
            earliestNode = node;
          }
        }
      }
    }

    if (DTM.NULL != earliestNode)
    {
      m_iterators[iteratorUsed].nextNode();

      incrementCurrentPos();
    }
    else
      m_foundLast = true;
  }

  m_lastFetched = earliestNode;

  return earliestNode;
}
 

/**
 * 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 NodeSetDTM is not of
 * a mutable type.
 */
public int addNodeInDocOrder(int node, boolean test, XPathContext support)
{

  if (!m_mutable)
    throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESETDTM_NOT_MUTABLE, null)); //"This NodeSetDTM 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--)
    {
      int child = elementAt(i);

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

        break;
      }

      DTM dtm = support.getDTM(node);
      if (!dtm.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 (i == node)
      {
        foundit = true;

        break;
      }
    }

    if (!foundit)
      addElement(node);
  }

  // checkDups();
  return insertIndex;
}
 

/**
 *  Returns the next node in the set and advances the position of the
 * iterator in the set. After a DTMIterator is created, the first call
 * to nextNode() returns the first node in the set.
 * @return  The next <code>Node</code> in the set being iterated over, or
 *   <code>null</code> if there are no more members in that set.
 */
public int nextNode()
{
      if(m_foundLast)
              return DTM.NULL;

  // Loop through the iterators getting the current fetched
  // node, and get the earliest occuring in document order
  int earliestNode = DTM.NULL;

  if (null != m_iterators)
  {
    int n = m_iterators.length;
    int iteratorUsed = -1;

    for (int i = 0; i < n; i++)
    {
      int node = m_iterators[i].getCurrentNode();

      if (DTM.NULL == node)
        continue;
      else if (DTM.NULL == earliestNode)
      {
        iteratorUsed = i;
        earliestNode = node;
      }
      else
      {
        if (node == earliestNode)
        {

          // Found a duplicate, so skip past it.
          m_iterators[i].nextNode();
        }
        else
        {
          DTM dtm = getDTM(node);

          if (dtm.isNodeAfter(node, earliestNode))
          {
            iteratorUsed = i;
            earliestNode = node;
          }
        }
      }
    }

    if (DTM.NULL != earliestNode)
    {
      m_iterators[iteratorUsed].nextNode();

      incrementCurrentPos();
    }
    else
      m_foundLast = true;
  }

  m_lastFetched = earliestNode;

  return earliestNode;
}
 

/**
* Add the node into a vector of nodes where it should occur in
* document order.
* @param node The node to be added.
* @return insertIndex.
* @throws RuntimeException thrown if this NodeSetDTM is not of
* a mutable type.
*/
protected int addNodeInDocOrder(int node)
{
   assertion(hasCache(), "addNodeInDocOrder must be done on a mutable sequence!");

   int insertIndex = -1;

   NodeVector vec = getVector();

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

   for (i = size - 1; i >= 0; i--)
   {
     int child = vec.elementAt(i);

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

       break;
     }

     DTM dtm = m_dtmMgr.getDTM(node);
     if (!dtm.isNodeAfter(node, child))
     {
       break;
     }
   }

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

     vec.insertElementAt(node, insertIndex);
   }

   // 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 NodeSetDTM is not of
 * a mutable type.
 */
public int addNodeInDocOrder(int node, boolean test, XPathContext support)
{

  if (!m_mutable)
    throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESETDTM_NOT_MUTABLE, null)); //"This NodeSetDTM 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--)
    {
      int child = elementAt(i);

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

        break;
      }

      DTM dtm = support.getDTM(node);
      if (!dtm.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 (i == node)
      {
        foundit = true;

        break;
      }
    }

    if (!foundit)
      addElement(node);
  }

  // checkDups();
  return insertIndex;
}
 

/**
 *  Returns the next node in the set and advances the position of the
 * iterator in the set. After a DTMIterator is created, the first call
 * to nextNode() returns the first node in the set.
 * @return  The next <code>Node</code> in the set being iterated over, or
 *   <code>null</code> if there are no more members in that set.
 */
public int nextNode()
{
      if(m_foundLast)
              return DTM.NULL;

  // Loop through the iterators getting the current fetched
  // node, and get the earliest occuring in document order
  int earliestNode = DTM.NULL;

  if (null != m_iterators)
  {
    int n = m_iterators.length;
    int iteratorUsed = -1;

    for (int i = 0; i < n; i++)
    {
      int node = m_iterators[i].getCurrentNode();

      if (DTM.NULL == node)
        continue;
      else if (DTM.NULL == earliestNode)
      {
        iteratorUsed = i;
        earliestNode = node;
      }
      else
      {
        if (node == earliestNode)
        {

          // Found a duplicate, so skip past it.
          m_iterators[i].nextNode();
        }
        else
        {
          DTM dtm = getDTM(node);

          if (dtm.isNodeAfter(node, earliestNode))
          {
            iteratorUsed = i;
            earliestNode = node;
          }
        }
      }
    }

    if (DTM.NULL != earliestNode)
    {
      m_iterators[iteratorUsed].nextNode();

      incrementCurrentPos();
    }
    else
      m_foundLast = true;
  }

  m_lastFetched = earliestNode;

  return earliestNode;
}
 

/**
* Add the node into a vector of nodes where it should occur in
* document order.
* @param node The node to be added.
* @return insertIndex.
* @throws RuntimeException thrown if this NodeSetDTM is not of
* a mutable type.
*/
protected int addNodeInDocOrder(int node)
{
   assertion(hasCache(), "addNodeInDocOrder must be done on a mutable sequence!");

   int insertIndex = -1;

   NodeVector vec = getVector();

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

   for (i = size - 1; i >= 0; i--)
   {
     int child = vec.elementAt(i);

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

       break;
     }

     DTM dtm = m_dtmMgr.getDTM(node);
     if (!dtm.isNodeAfter(node, child))
     {
       break;
     }
   }

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

     vec.insertElementAt(node, insertIndex);
   }

   // 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 NodeSetDTM is not of
 * a mutable type.
 */
public int addNodeInDocOrder(int node, boolean test, XPathContext support)
{

  if (!m_mutable)
    throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESETDTM_NOT_MUTABLE, null)); //"This NodeSetDTM 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--)
    {
      int child = elementAt(i);

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

        break;
      }

      DTM dtm = support.getDTM(node);
      if (!dtm.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 (i == node)
      {
        foundit = true;

        break;
      }
    }

    if (!foundit)
      addElement(node);
  }

  // checkDups();
  return insertIndex;
}
 

/**
 *  Returns the next node in the set and advances the position of the
 * iterator in the set. After a DTMIterator is created, the first call
 * to nextNode() returns the first node in the set.
 * @return  The next <code>Node</code> in the set being iterated over, or
 *   <code>null</code> if there are no more members in that set.
 */
public int nextNode()
{
      if(m_foundLast)
              return DTM.NULL;

  // Loop through the iterators getting the current fetched
  // node, and get the earliest occuring in document order
  int earliestNode = DTM.NULL;

  if (null != m_iterators)
  {
    int n = m_iterators.length;
    int iteratorUsed = -1;

    for (int i = 0; i < n; i++)
    {
      int node = m_iterators[i].getCurrentNode();

      if (DTM.NULL == node)
        continue;
      else if (DTM.NULL == earliestNode)
      {
        iteratorUsed = i;
        earliestNode = node;
      }
      else
      {
        if (node == earliestNode)
        {

          // Found a duplicate, so skip past it.
          m_iterators[i].nextNode();
        }
        else
        {
          DTM dtm = getDTM(node);

          if (dtm.isNodeAfter(node, earliestNode))
          {
            iteratorUsed = i;
            earliestNode = node;
          }
        }
      }
    }

    if (DTM.NULL != earliestNode)
    {
      m_iterators[iteratorUsed].nextNode();

      incrementCurrentPos();
    }
    else
      m_foundLast = true;
  }

  m_lastFetched = earliestNode;

  return earliestNode;
}
 

/**
* Add the node into a vector of nodes where it should occur in
* document order.
* @param node The node to be added.
* @return insertIndex.
* @throws RuntimeException thrown if this NodeSetDTM is not of
* a mutable type.
*/
protected int addNodeInDocOrder(int node)
{
   assertion(hasCache(), "addNodeInDocOrder must be done on a mutable sequence!");

   int insertIndex = -1;

   NodeVector vec = getVector();

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

   for (i = size - 1; i >= 0; i--)
   {
     int child = vec.elementAt(i);

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

       break;
     }

     DTM dtm = m_dtmMgr.getDTM(node);
     if (!dtm.isNodeAfter(node, child))
     {
       break;
     }
   }

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

     vec.insertElementAt(node, insertIndex);
   }

   // 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.
* @return insertIndex.
* @throws RuntimeException thrown if this NodeSetDTM is not of
* a mutable type.
*/
protected int addNodeInDocOrder(int node)
{
   assertion(hasCache(), "addNodeInDocOrder must be done on a mutable sequence!");

   int insertIndex = -1;

   NodeVector vec = getVector();

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

   for (i = size - 1; i >= 0; i--)
   {
     int child = vec.elementAt(i);

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

       break;
     }

     DTM dtm = m_dtmMgr.getDTM(node);
     if (!dtm.isNodeAfter(node, child))
     {
       break;
     }
   }

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

     vec.insertElementAt(node, insertIndex);
   }

   // 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 NodeSetDTM is not of
 * a mutable type.
 */
public int addNodeInDocOrder(int node, boolean test, XPathContext support)
{

  if (!m_mutable)
    throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESETDTM_NOT_MUTABLE, null)); //"This NodeSetDTM 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--)
    {
      int child = elementAt(i);

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

        break;
      }

      DTM dtm = support.getDTM(node);
      if (!dtm.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 (i == node)
      {
        foundit = true;

        break;
      }
    }

    if (!foundit)
      addElement(node);
  }

  // checkDups();
  return insertIndex;
}
 

/**
 *  Returns the next node in the set and advances the position of the
 * iterator in the set. After a DTMIterator is created, the first call
 * to nextNode() returns the first node in the set.
 * @return  The next <code>Node</code> in the set being iterated over, or
 *   <code>null</code> if there are no more members in that set.
 */
public int nextNode()
{
      if(m_foundLast)
              return DTM.NULL;

  // Loop through the iterators getting the current fetched
  // node, and get the earliest occuring in document order
  int earliestNode = DTM.NULL;

  if (null != m_iterators)
  {
    int n = m_iterators.length;
    int iteratorUsed = -1;

    for (int i = 0; i < n; i++)
    {
      int node = m_iterators[i].getCurrentNode();

      if (DTM.NULL == node)
        continue;
      else if (DTM.NULL == earliestNode)
      {
        iteratorUsed = i;
        earliestNode = node;
      }
      else
      {
        if (node == earliestNode)
        {

          // Found a duplicate, so skip past it.
          m_iterators[i].nextNode();
        }
        else
        {
          DTM dtm = getDTM(node);

          if (dtm.isNodeAfter(node, earliestNode))
          {
            iteratorUsed = i;
            earliestNode = node;
          }
        }
      }
    }

    if (DTM.NULL != earliestNode)
    {
      m_iterators[iteratorUsed].nextNode();

      incrementCurrentPos();
    }
    else
      m_foundLast = true;
  }

  m_lastFetched = earliestNode;

  return earliestNode;
}
 

/**
 * 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 NodeSetDTM is not of
 * a mutable type.
 */
public int addNodeInDocOrder(int node, boolean test, XPathContext support)
{

  if (!m_mutable)
    throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESETDTM_NOT_MUTABLE, null)); //"This NodeSetDTM 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--)
    {
      int child = elementAt(i);

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

        break;
      }

      DTM dtm = support.getDTM(node);
      if (!dtm.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 (i == node)
      {
        foundit = true;

        break;
      }
    }

    if (!foundit)
      addElement(node);
  }

  // checkDups();
  return insertIndex;
}
 

/**
 *  Returns the next node in the set and advances the position of the
 * iterator in the set. After a DTMIterator is created, the first call
 * to nextNode() returns the first node in the set.
 * @return  The next <code>Node</code> in the set being iterated over, or
 *   <code>null</code> if there are no more members in that set.
 */
public int nextNode()
{
      if(m_foundLast)
              return DTM.NULL;

  // Loop through the iterators getting the current fetched
  // node, and get the earliest occuring in document order
  int earliestNode = DTM.NULL;

  if (null != m_iterators)
  {
    int n = m_iterators.length;
    int iteratorUsed = -1;

    for (int i = 0; i < n; i++)
    {
      int node = m_iterators[i].getCurrentNode();

      if (DTM.NULL == node)
        continue;
      else if (DTM.NULL == earliestNode)
      {
        iteratorUsed = i;
        earliestNode = node;
      }
      else
      {
        if (node == earliestNode)
        {

          // Found a duplicate, so skip past it.
          m_iterators[i].nextNode();
        }
        else
        {
          DTM dtm = getDTM(node);

          if (dtm.isNodeAfter(node, earliestNode))
          {
            iteratorUsed = i;
            earliestNode = node;
          }
        }
      }
    }

    if (DTM.NULL != earliestNode)
    {
      m_iterators[iteratorUsed].nextNode();

      incrementCurrentPos();
    }
    else
      m_foundLast = true;
  }

  m_lastFetched = earliestNode;

  return earliestNode;
}