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

/**
 * Create a new NodeSequence from a (already cloned) iterator.
 *
 * @param nodeVector
 */
public NodeSequence(Object nodeVector)
{
      super(nodeVector);
  if (nodeVector instanceof NodeVector) {
      SetVector((NodeVector) nodeVector);
  }
      if(null != nodeVector)
      {
              assertion(nodeVector instanceof NodeVector,
                      "Must have a NodeVector as the object for NodeSequence!");
              if(nodeVector instanceof DTMIterator)
              {
                      setIter((DTMIterator)nodeVector);
                      m_last = ((DTMIterator)nodeVector).getLength();
              }

      }
}
 

/**
 * Create a new NodeSequence from a (already cloned) iterator.
 *
 * @param nodeVector
 */
public NodeSequence(Object nodeVector)
{
      super(nodeVector);
  if (nodeVector instanceof NodeVector) {
      SetVector((NodeVector) nodeVector);
  }
      if(null != nodeVector)
      {
              assertion(nodeVector instanceof NodeVector,
                      "Must have a NodeVector as the object for NodeSequence!");
              if(nodeVector instanceof DTMIterator)
              {
                      setIter((DTMIterator)nodeVector);
                      m_last = ((DTMIterator)nodeVector).getLength();
              }

      }
}
 

/**
 * @see DTMIterator#getCurrentNode()
 */
public int getCurrentNode()
{
      if(hasCache())
      {
              int currentIndex = m_next-1;
              NodeVector vec = getVector();
              if((currentIndex >= 0) && (currentIndex < vec.size()))
                      return vec.elementAt(currentIndex);
              else
                      return DTM.NULL;
      }

      if(null != m_iter)
      {
      return m_iter.getCurrentNode();
      }
      else
              return DTM.NULL;
}
 

/**
 * Create a new NodeSequence from a (already cloned) iterator.
 *
 * @param nodeVector
 */
public NodeSequence(Object nodeVector)
{
      super(nodeVector);
  if (nodeVector instanceof NodeVector) {
      SetVector((NodeVector) nodeVector);
  }
      if(null != nodeVector)
      {
              assertion(nodeVector instanceof NodeVector,
                      "Must have a NodeVector as the object for NodeSequence!");
              if(nodeVector instanceof DTMIterator)
              {
                      setIter((DTMIterator)nodeVector);
                      m_last = ((DTMIterator)nodeVector).getLength();
              }

      }
}
 

/**
 * @see DTMIterator#getCurrentNode()
 */
public int getCurrentNode()
{
      if(hasCache())
      {
              int currentIndex = m_next-1;
              NodeVector vec = getVector();
              if((currentIndex >= 0) && (currentIndex < vec.size()))
                      return vec.elementAt(currentIndex);
              else
                      return DTM.NULL;
      }

      if(null != m_iter)
      {
      return m_iter.getCurrentNode();
      }
      else
              return DTM.NULL;
}
 

/**
 * Create a new NodeSequence from a (already cloned) iterator.
 *
 * @param nodeVector
 */
public NodeSequence(Object nodeVector)
{
      super(nodeVector);
  if (nodeVector instanceof NodeVector) {
      SetVector((NodeVector) nodeVector);
  }
      if(null != nodeVector)
      {
              assertion(nodeVector instanceof NodeVector,
                      "Must have a NodeVector as the object for NodeSequence!");
              if(nodeVector instanceof DTMIterator)
              {
                      setIter((DTMIterator)nodeVector);
                      m_last = ((DTMIterator)nodeVector).getLength();
              }

      }
}
 

/**
 * Create a new NodeSequence from a (already cloned) iterator.
 *
 * @param nodeVector
 */
public NodeSequence(Object nodeVector)
{
      super(nodeVector);
  if (nodeVector instanceof NodeVector) {
      SetVector((NodeVector) nodeVector);
  }
      if(null != nodeVector)
      {
              assertion(nodeVector instanceof NodeVector,
                      "Must have a NodeVector as the object for NodeSequence!");
              if(nodeVector instanceof DTMIterator)
              {
                      setIter((DTMIterator)nodeVector);
                      m_last = ((DTMIterator)nodeVector).getLength();
              }

      }
}
 

/**
 * @see DTMIterator#getCurrentNode()
 */
public int getCurrentNode()
{
      if(hasCache())
      {
              int currentIndex = m_next-1;
              NodeVector vec = getVector();
              if((currentIndex >= 0) && (currentIndex < vec.size()))
                      return vec.elementAt(currentIndex);
              else
                      return DTM.NULL;
      }

      if(null != m_iter)
      {
      return m_iter.getCurrentNode();
      }
      else
              return DTM.NULL;
}
 

/**
 * Create a new NodeSequence from a (already cloned) iterator.
 *
 * @param nodeVector
 */
public NodeSequence(Object nodeVector)
{
      super(nodeVector);
  if (nodeVector instanceof NodeVector) {
      SetVector((NodeVector) nodeVector);
  }
      if(null != nodeVector)
      {
              assertion(nodeVector instanceof NodeVector,
                      "Must have a NodeVector as the object for NodeSequence!");
              if(nodeVector instanceof DTMIterator)
              {
                      setIter((DTMIterator)nodeVector);
                      m_last = ((DTMIterator)nodeVector).getLength();
              }

      }
}
 

/**
 * @see DTMIterator#getCurrentNode()
 */
public int getCurrentNode()
{
      if(hasCache())
      {
              int currentIndex = m_next-1;
              NodeVector vec = getVector();
              if((currentIndex >= 0) && (currentIndex < vec.size()))
                      return vec.elementAt(currentIndex);
              else
                      return DTM.NULL;
      }

      if(null != m_iter)
      {
      return m_iter.getCurrentNode();
      }
      else
              return DTM.NULL;
}
 

/**
 * Create a new NodeSequence from a (already cloned) iterator.
 *
 * @param nodeVector
 */
public NodeSequence(Object nodeVector)
{
      super(nodeVector);
  if (nodeVector instanceof NodeVector) {
      SetVector((NodeVector) nodeVector);
  }
      if(null != nodeVector)
      {
              assertion(nodeVector instanceof NodeVector,
                      "Must have a NodeVector as the object for NodeSequence!");
              if(nodeVector instanceof DTMIterator)
              {
                      setIter((DTMIterator)nodeVector);
                      m_last = ((DTMIterator)nodeVector).getLength();
              }

      }
}
 

/**
 * @see DTMIterator#getCurrentNode()
 */
public int getCurrentNode()
{
      if(hasCache())
      {
              int currentIndex = m_next-1;
              NodeVector vec = getVector();
              if((currentIndex >= 0) && (currentIndex < vec.size()))
                      return vec.elementAt(currentIndex);
              else
                      return DTM.NULL;
      }

      if(null != m_iter)
      {
      return m_iter.getCurrentNode();
      }
      else
              return DTM.NULL;
}
 

/**
   * @see DTMIterator#setShouldCacheNodes(boolean)
   */
  public void setShouldCacheNodes(boolean b)
  {
    if (b)
    {
      if(!hasCache())
      {
        SetVector(new NodeVector());
      }
//        else
//          getVector().RemoveAllNoClear();  // Is this good?
    }
    else
      SetVector(null);
  }
 

/**
 * If this NodeSequence has a cache, mark that it is complete.
 * This method should be called after the iterator is exhausted.
 */
private void markCacheComplete() {
    NodeVector nv = getVector();
    if (nv != null) {
        m_cache.setCacheComplete(true);
    }
}
 

/**
 * @see DTMIterator#getLength()
 */
public int getLength()
{
  IteratorCache cache = getCache();

      if(cache != null)
      {
      // Nodes from the iterator are cached
      if (cache.isComplete()) {
          // All of the nodes from the iterator are cached
          // so just return the number of nodes in the cache
          NodeVector nv = cache.getVector();
          return nv.size();
      }

      // If this NodeSequence wraps a mutable nodeset, then
      // m_last will not reflect the size of the nodeset if
      // it has been mutated...
      if (m_iter instanceof NodeSetDTM)
      {
          return m_iter.getLength();
      }

              if(-1 == m_last)
              {
                      int pos = m_next;
                      runTo(-1);
                      m_next = pos;
              }
          return m_last;
      }
      else
      {
              return (-1 == m_last) ? (m_last = m_iter.getLength()) : m_last;
      }
}
 

/**
   * @see DTMIterator#setShouldCacheNodes(boolean)
   */
  public void setShouldCacheNodes(boolean b)
  {
    if (b)
    {
      if(!hasCache())
      {
        SetVector(new NodeVector());
      }
//        else
//          getVector().RemoveAllNoClear();  // Is this good?
    }
    else
      SetVector(null);
  }
 

/**
   * @see DTMIterator#setShouldCacheNodes(boolean)
   */
  public void setShouldCacheNodes(boolean b)
  {
    if (b)
    {
      if(!hasCache())
      {
        SetVector(new NodeVector());
      }
//        else
//          getVector().RemoveAllNoClear();  // Is this good?
    }
    else
      SetVector(null);
  }
 

/**
 * @see DTMIterator#getLength()
 */
public int getLength()
{
  IteratorCache cache = getCache();

      if(cache != null)
      {
      // Nodes from the iterator are cached
      if (cache.isComplete()) {
          // All of the nodes from the iterator are cached
          // so just return the number of nodes in the cache
          NodeVector nv = cache.getVector();
          return nv.size();
      }

      // If this NodeSequence wraps a mutable nodeset, then
      // m_last will not reflect the size of the nodeset if
      // it has been mutated...
      if (m_iter instanceof NodeSetDTM)
      {
          return m_iter.getLength();
      }

              if(-1 == m_last)
              {
                      int pos = m_next;
                      runTo(-1);
                      m_next = pos;
              }
          return m_last;
      }
      else
      {
              return (-1 == m_last) ? (m_last = m_iter.getLength()) : m_last;
      }
}
 

/**
 * Construct an empty XNodeSet object.  This is used to create a mutable
 * nodeset to which random nodes may be added.
 */
private NodeSequence(DTMManager dtmMgr)
{
  super(new NodeVector());
  m_last = 0;
  m_dtmMgr = dtmMgr;
}
 

/**
 * If this NodeSequence has a cache, mark that it is complete.
 * This method should be called after the iterator is exhausted.
 */
private void markCacheComplete() {
    NodeVector nv = getVector();
    if (nv != null) {
        m_cache.setCacheComplete(true);
    }
}
 

/**
   * @see DTMIterator#setShouldCacheNodes(boolean)
   */
  public void setShouldCacheNodes(boolean b)
  {
    if (b)
    {
      if(!hasCache())
      {
        SetVector(new NodeVector());
      }
//        else
//          getVector().RemoveAllNoClear();  // Is this good?
    }
    else
      SetVector(null);
  }
 

/**
 * Construct an empty XNodeSet object.  This is used to create a mutable
 * nodeset to which random nodes may be added.
 */
private NodeSequence(DTMManager dtmMgr)
{
  super(new NodeVector());
  m_last = 0;
  m_dtmMgr = dtmMgr;
}
 

/**
 * Append the nodes to the list.
 *
 * @param nodes The nodes to be appended to this node set.
 * @throws RuntimeException thrown if this NodeSetDTM is not of
 * a mutable type.
 */
public void appendNodes(NodeVector nodes)
{

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

  super.appendNodes(nodes);
}
 

/**
 * Construct an empty XNodeSet object.  This is used to create a mutable
 * nodeset to which random nodes may be added.
 */
private NodeSequence(DTMManager dtmMgr)
{
  super(new NodeVector());
  m_last = 0;
  m_dtmMgr = dtmMgr;
}
 

/**
 * It used to be that many locations in the code simply
 * did an assignment to this.m_obj directly, rather than
 * calling the setObject(Object) method. The problem is
 * that our super-class would be updated on what the
 * cache associated with this NodeSequence, but
 * we wouldn't know ourselves.
 * <p>
 * All setting of m_obj is done through setObject() now,
 * and this method over-rides the super-class method.
 * So now we are in the loop have an opportunity
 * to update some caching information.
 *
 */
protected void setObject(Object obj) {
    if (obj instanceof NodeVector) {
        // Keep our superclass informed of the current NodeVector
        // ... if we don't the smoketest fails (don't know why).
        super.setObject(obj);

        // A copy of the code of what SetVector() would do.
        NodeVector v = (NodeVector)obj;
        if (m_cache != null) {
            m_cache.setVector(v);
        } else if (v!=null) {
            m_cache = new IteratorCache();
            m_cache.setVector(v);
        }
    } else if (obj instanceof IteratorCache) {
        IteratorCache cache = (IteratorCache) obj;
        m_cache = cache;
        m_cache.increaseUseCount();

        // Keep our superclass informed of the current NodeVector
        super.setObject(cache.getVector());
    } else {
        super.setObject(obj);
    }

}
 

/**
 * It used to be that many locations in the code simply
 * did an assignment to this.m_obj directly, rather than
 * calling the setObject(Object) method. The problem is
 * that our super-class would be updated on what the
 * cache associated with this NodeSequence, but
 * we wouldn't know ourselves.
 * <p>
 * All setting of m_obj is done through setObject() now,
 * and this method over-rides the super-class method.
 * So now we are in the loop have an opportunity
 * to update some caching information.
 *
 */
protected void setObject(Object obj) {
    if (obj instanceof NodeVector) {
        // Keep our superclass informed of the current NodeVector
        // ... if we don't the smoketest fails (don't know why).
        super.setObject(obj);

        // A copy of the code of what SetVector() would do.
        NodeVector v = (NodeVector)obj;
        if (m_cache != null) {
            m_cache.setVector(v);
        } else if (v!=null) {
            m_cache = new IteratorCache();
            m_cache.setVector(v);
        }
    } else if (obj instanceof IteratorCache) {
        IteratorCache cache = (IteratorCache) obj;
        m_cache = cache;
        m_cache.increaseUseCount();

        // Keep our superclass informed of the current NodeVector
        super.setObject(cache.getVector());
    } else {
        super.setObject(obj);
    }

}
 

/**
 * Append the nodes to the list.
 *
 * @param nodes The nodes to be appended to this node set.
 * @throws RuntimeException thrown if this NodeSetDTM is not of
 * a mutable type.
 */
public void appendNodes(NodeVector nodes)
{

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

  super.appendNodes(nodes);
}
 

/**
   * @see DTMIterator#setShouldCacheNodes(boolean)
   */
  public void setShouldCacheNodes(boolean b)
  {
    if (b)
    {
      if(!hasCache())
      {
        SetVector(new NodeVector());
      }
//        else
//          getVector().RemoveAllNoClear();  // Is this good?
    }
    else
      SetVector(null);
  }
 

/**
 * It used to be that many locations in the code simply
 * did an assignment to this.m_obj directly, rather than
 * calling the setObject(Object) method. The problem is
 * that our super-class would be updated on what the
 * cache associated with this NodeSequence, but
 * we wouldn't know ourselves.
 * <p>
 * All setting of m_obj is done through setObject() now,
 * and this method over-rides the super-class method.
 * So now we are in the loop have an opportunity
 * to update some caching information.
 *
 */
protected void setObject(Object obj) {
    if (obj instanceof NodeVector) {
        // Keep our superclass informed of the current NodeVector
        // ... if we don't the smoketest fails (don't know why).
        super.setObject(obj);

        // A copy of the code of what SetVector() would do.
        NodeVector v = (NodeVector)obj;
        if (m_cache != null) {
            m_cache.setVector(v);
        } else if (v!=null) {
            m_cache = new IteratorCache();
            m_cache.setVector(v);
        }
    } else if (obj instanceof IteratorCache) {
        IteratorCache cache = (IteratorCache) obj;
        m_cache = cache;
        m_cache.increaseUseCount();

        // Keep our superclass informed of the current NodeVector
        super.setObject(cache.getVector());
    } else {
        super.setObject(obj);
    }

}
 

/**
 * If this NodeSequence has a cache, mark that it is complete.
 * This method should be called after the iterator is exhausted.
 */
private void markCacheComplete() {
    NodeVector nv = getVector();
    if (nv != null) {
        m_cache.setCacheComplete(true);
    }
}