| Methods Summary |
|---|
| protected void | SetVector(com.sun.org.apache.xml.internal.utils.NodeVector v)Set the vector where nodes will be stored.
m_obj = v;
|
| protected int | addNodeInDocOrder(int node)Add the node into a vector of nodes where it should occur in
document order.
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;
|
| public void | allowDetachToRelease(boolean allowRelease)Calling this with a value of false will cause the nodeset
to be cached.
if((false == allowRelease) && !hasCache())
{
setShouldCacheNodes(true);
}
if(null != m_iter)
m_iter.allowDetachToRelease(allowRelease);
super.allowDetachToRelease(allowRelease);
|
| public java.lang.Object | clone()Get a clone of this iterator, but don't reset the iteration in the
process, so that it may be used from the current position.
Note: Not a deep clone.
return super.clone();
|
| public com.sun.org.apache.xml.internal.dtm.DTMIterator | cloneWithReset()Note: Not a deep clone.
NodeSequence seq = (NodeSequence)super.clone();
seq.m_next = 0;
return seq;
|
| public void | detach()
if(null != m_iter)
m_iter.detach();
super.detach();
|
| public void | fixupVariables(java.util.Vector vars, int globalsSize)
super.fixupVariables(vars, globalsSize);
|
| public int | getAnalysisBits()
if((null != m_iter) && (m_iter instanceof PathComponent))
return ((PathComponent)m_iter).getAnalysisBits();
else
return 0;
|
| public int | getAxis()
if(null != m_iter)
return m_iter.getAxis();
else
{
assertion(false, "Can not getAxis from a non-iterated node sequence!");
return 0;
}
|
| public final com.sun.org.apache.xml.internal.dtm.DTMIterator | getContainedIter()Get the functional iterator that fetches nodes.
return m_iter;
|
| 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;
|
| public int | getCurrentPos()
return m_next;
|
| public com.sun.org.apache.xml.internal.dtm.DTM | getDTM(int nodeHandle)
DTMManager mgr = getDTMManager();
if(null != mgr)
return getDTMManager().getDTM(nodeHandle);
else
{
assertion(false, "Can not get a DTM Unless a DTMManager has been set!");
return null;
}
|
| public com.sun.org.apache.xml.internal.dtm.DTMManager | getDTMManager()
return m_dtmMgr;
|
| public boolean | getExpandEntityReferences()
if(null != m_iter)
return m_iter.getExpandEntityReferences();
else
return true;
|
| public int | getLength()
if(hasCache())
{
// 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;
}
|
| public int | getRoot()
if(null != m_iter)
return m_iter.getRoot();
else
{
// NodeSetDTM will call this, and so it's not a good thing to throw
// an assertion here.
// assertion(false, "Can not get the root from a non-iterated NodeSequence!");
return DTM.NULL;
}
|
| protected com.sun.org.apache.xml.internal.utils.NodeVector | getVector()If this iterator needs to cache nodes that are fetched, they
are stored in the Vector in the generic object.
return (NodeVector)m_obj;
|
| public int | getWhatToShow()
return hasCache() ? (DTMFilter.SHOW_ALL & ~DTMFilter.SHOW_ENTITY_REFERENCE)
: m_iter.getWhatToShow();
|
| public boolean | hasCache()If this iterator needs to cache nodes that are fetched, they
are stored here.
return (m_obj != null);
|
| public boolean | isDocOrdered()
if(null != m_iter)
return m_iter.isDocOrdered();
else
return true; // can't be sure?
|
| public boolean | isFresh()
return (0 == m_next);
|
| public boolean | isMutable()
return hasCache(); // though may be surprising if it also has an iterator!
|
| public int | item(int index)
setCurrentPos(index);
int n = nextNode();
m_next = index;
return n;
|
| public int | nextNode()
// If the cache is on, and the node has already been found, then
// just return from the list.
NodeVector vec = getVector();
if (null != vec)
{
if(m_next < vec.size())
{
int next = vec.elementAt(m_next);
m_next++;
return next;
}
else if((-1 != m_last) || (null == m_iter))
{
m_next++;
return DTM.NULL;
}
}
if (null == m_iter)
return DTM.NULL;
int next = m_iter.nextNode();
if(DTM.NULL != next)
{
if(hasCache())
{
if(m_iter.isDocOrdered())
{
getVector().addElement(next);
m_next++;
}
else
{
int insertIndex = addNodeInDocOrder(next);
if(insertIndex >= 0)
m_next++;
}
}
else
m_next++;
}
else
{
m_last = m_next;
m_next++;
}
return next;
|
| public int | previousNode()
if(hasCache())
{
if(m_next <= 0)
return DTM.NULL;
else
{
m_next--;
return item(m_next);
}
}
else
{
int n = m_iter.previousNode();
m_next = m_iter.getCurrentPos();
return m_next;
}
|
| public void | reset()
m_next = 0;
// not resetting the iterator on purpose!!!
|
| public void | runTo(int index)
int n;
if (-1 == index)
{
int pos = m_next;
while (DTM.NULL != (n = nextNode()));
m_next = pos;
}
else if(m_next == index)
{
return;
}
else if(hasCache() && m_next < getVector().size())
{
m_next = index;
}
else if((null == getVector()) && (index < m_next))
{
while ((m_next >= index) && DTM.NULL != (n = previousNode()));
}
else
{
while ((m_next < index) && DTM.NULL != (n = nextNode()));
}
|
| public void | setCurrentPos(int i)
runTo(i);
|
| public void | setItem(int node, int index)
NodeVector vec = getVector();
if(null != vec)
{
vec.setElementAt(node, index);
m_last = vec.size();
}
else
m_iter.setItem(node, index);
|
| public final void | setIter(com.sun.org.apache.xml.internal.dtm.DTMIterator iter)Set the functional iterator that fetches nodes.
m_iter = iter;
|
| public void | setRoot(int nodeHandle, java.lang.Object environment)
if(null != m_iter)
{
XPathContext xctxt = (XPathContext)environment;
m_dtmMgr = xctxt.getDTMManager();
m_iter.setRoot(nodeHandle, environment);
if(!m_iter.isDocOrdered())
{
if(!hasCache())
setShouldCacheNodes(true);
runTo(-1);
m_next=0;
}
}
else
assertion(false, "Can not setRoot on a non-iterated NodeSequence!");
|
| public void | setShouldCacheNodes(boolean b)
if (b)
{
if(!hasCache())
{
SetVector(new NodeVector());
}
// else
// getVector().RemoveAllNoClear(); // Is this good?
}
else
SetVector(null);
|
