/** * This function is used to fixup variables from QNames to stack frame indexes at stylesheet build * time. * * @param vars List of QNames that correspond to variables. This list should be searched backwards * for the first qualified name that corresponds to the variable reference qname. The position * of the QName in the vector from the start of the vector will be its position in the stack * frame (but variables above the globalsTop value will need to be offset to the current stack * frame). */ public void fixupVariables(java.util.Vector vars, int globalsSize) { m_predicateIndex = -1; AxesWalker walker = m_firstWalker; while (null != walker) { walker.fixupVariables(vars, globalsSize); walker = walker.getNextWalker(); } }
/** * Get the analysis bits for this walker, as defined in the WalkerFactory. * * @return One of WalkerFactory#BIT_DESCENDANT, etc. */ public int getAnalysisBits() { int bits = 0; if (null != m_firstWalker) { AxesWalker walker = m_firstWalker; while (null != walker) { int bit = walker.getAnalysisBits(); bits |= bit; walker = walker.getNextWalker(); } } return bits; }
/** * Detaches the iterator from the set which it iterated over, releasing any computational * resources and placing the iterator in the INVALID state. After<code>detach</code> has been * invoked, calls to <code>nextNode</code> or<code>previousNode</code> will raise the exception * INVALID_STATE_ERR. */ public void detach() { if (m_allowDetach) { AxesWalker walker = m_firstWalker; while (null != walker) { walker.detach(); walker = walker.getNextWalker(); } m_lastUsedWalker = null; // Always call the superclass detach last! super.detach(); } }
/** @see Expression#deepEquals(Expression) */ public boolean deepEquals(Expression expr) { if (!super.deepEquals(expr)) return false; AxesWalker walker1 = m_firstWalker; AxesWalker walker2 = ((WalkingIterator) expr).m_firstWalker; while ((null != walker1) && (null != walker2)) { if (!walker1.deepEquals(walker2)) return false; walker1 = walker1.getNextWalker(); walker2 = walker2.getNextWalker(); } if ((null != walker1) || (null != walker2)) return false; return true; }
/** * Moves the <code>TreeWalker</code> to the next visible node in document order relative to the * current node, and returns the new node. If the current node has no next node, or if the search * for nextNode attempts to step upward from the TreeWalker's root node, returns <code>null</code> * , and retains the current node. * * @return The new node, or <code>null</code> if the current node has no next node in the * TreeWalker's logical view. */ public int nextNode() { int nextNode = DTM.NULL; AxesWalker walker = wi().getLastUsedWalker(); while (true) { if (null == walker) break; nextNode = walker.getNextNode(); if (DTM.NULL == nextNode) { walker = walker.m_prevWalker; } else { if (walker.acceptNode(nextNode) != DTMIterator.FILTER_ACCEPT) { continue; } if (null == walker.m_nextWalker) { wi().setLastUsedWalker(walker); // return walker.returnNextNode(nextNode); break; } else { AxesWalker prev = walker; walker = walker.m_nextWalker; walker.setRoot(nextNode); walker.m_prevWalker = prev; continue; } } // if(null != nextNode) } // while(null != walker) return nextNode; }
/** * Do a deep clone of this walker, including next and previous walkers. If the this AxesWalker is * on the clone list, don't clone but return the already cloned version. * * @param cloneOwner non-null reference to the cloned location path iterator to which this clone * will be added. * @param cloneList non-null vector of sources in odd elements, and the corresponding clones in * even vectors. * @return non-null clone, which may be a new clone, or may be a clone contained on the cloneList. */ AxesWalker cloneDeep(WalkingIterator cloneOwner, Vector cloneList) throws CloneNotSupportedException { AxesWalker clone = findClone(this, cloneList); if (null != clone) return clone; clone = (AxesWalker) this.clone(); clone.setLocPathIterator(cloneOwner); if (null != cloneList) { cloneList.addElement(this); cloneList.addElement(clone); } if (wi().m_lastUsedWalker == this) cloneOwner.m_lastUsedWalker = clone; if (null != m_nextWalker) clone.m_nextWalker = m_nextWalker.cloneDeep(cloneOwner, cloneList); // If you don't check for the cloneList here, you'll go into an // recursive infinate loop. if (null != cloneList) { if (null != m_prevWalker) clone.m_prevWalker = m_prevWalker.cloneDeep(cloneOwner, cloneList); } else { if (null != m_nextWalker) clone.m_nextWalker.m_prevWalker = clone; } return clone; }
/** * Get the index of the last node that can be itterated to. * * @param xctxt XPath runtime context. * @return the index of the last node that can be itterated to. */ public int getLastPos(XPathContext xctxt) { int pos = getProximityPosition(); AxesWalker walker; try { walker = (AxesWalker) clone(); } catch (CloneNotSupportedException cnse) { return -1; } walker.setPredicateCount(walker.getPredicateCount() - 1); walker.setNextWalker(null); walker.setPrevWalker(null); WalkingIterator lpi = wi(); AxesWalker savedWalker = lpi.getLastUsedWalker(); try { lpi.setLastUsedWalker(walker); int next; while (DTM.NULL != (next = walker.nextNode())) { pos++; } // TODO: Should probably save this in the iterator. } finally { lpi.setLastUsedWalker(savedWalker); } // System.out.println("pos: "+pos); return pos; }
/** * Detaches the walker from the set which it iterated over, releasing any computational resources * and placing the iterator in the INVALID state. */ public void detach() { m_iterator = null; super.detach(); }
/** * Set the root node of the TreeWalker. (Not part of the DOM2 TreeWalker interface). * * @param root The context node of this step. */ public void setRoot(int root) { super.setRoot(root); m_iterator = getDTM(root).getAxisIterator(m_axis); m_iterator.setStartNode(root); }