/**
* Get the match score of the given node.
*
* @param xctxt XPath runtime context.
* @param context The current source tree context node.
* @return score, one of {@link #MATCH_SCORE_NODETEST}, {@link #MATCH_SCORE_NONE}, {@link
* #MATCH_SCORE_OTHER}, or {@link #MATCH_SCORE_QNAME}.
* @throws javax.xml.transform.TransformerException
*/
public double getMatchScore(XPathContext xctxt, int context)
throws javax.xml.transform.TransformerException {
xctxt.pushCurrentNode(context);
xctxt.pushCurrentExpressionNode(context);
try {
XObject score = m_mainExp.execute(xctxt);
if (DEBUG_MATCHES) {
DTM dtm = xctxt.getDTM(context);
System.out.println(
"score: "
+ score.num()
+ " for "
+ dtm.getNodeName(context)
+ " for xpath "
+ this.getPatternString());
}
return score.num();
} finally {
xctxt.popCurrentNode();
xctxt.popCurrentExpressionNode();
}
// return XPath.MATCH_SCORE_NONE;
}
/**
* Test whether a specified node is visible in the logical view of a TreeWalker or NodeIterator.
* This function will be called by the implementation of TreeWalker and NodeIterator; it is not
* intended to be called directly from user code.
*
* @param n The node to check to see if it passes the filter or not.
* @return a constant to determine whether the node is accepted, rejected, or skipped, as defined
* above .
*/
public short acceptNode(int n, XPathContext xctxt) {
try {
xctxt.pushCurrentNode(n);
xctxt.pushIteratorRoot(m_context);
if (DEBUG) {
System.out.println("traverser: " + m_traverser);
System.out.print("node: " + n);
System.out.println(", " + m_cdtm.getNodeName(n));
// if(m_cdtm.getNodeName(n).equals("near-east"))
System.out.println("pattern: " + m_pattern.toString());
m_pattern.debugWhatToShow(m_pattern.getWhatToShow());
}
XObject score = m_pattern.execute(xctxt);
if (DEBUG) {
// System.out.println("analysis: "+Integer.toBinaryString(m_analysis));
System.out.println("score: " + score);
System.out.println("skip: " + (score == NodeTest.SCORE_NONE));
}
// System.out.println("\n::acceptNode - score: "+score.num()+"::");
return (score == NodeTest.SCORE_NONE) ? DTMIterator.FILTER_SKIP : DTMIterator.FILTER_ACCEPT;
} catch (javax.xml.transform.TransformerException se) {
// TODO: Fix this.
throw new RuntimeException(se.getMessage());
} finally {
xctxt.popCurrentNode();
xctxt.popIteratorRoot();
}
}
/**
* The number of nodes in the list. The range of valid child node indices is 0 to <code>length-1
* </code> inclusive.
*
* @return The number of nodes in the list, always greater or equal to zero.
*/
public int getLength() {
if (!isReverseAxes()) return super.getLength();
// Tell if this is being called from within a predicate.
boolean isPredicateTest = (this == m_execContext.getSubContextList());
// And get how many total predicates are part of this step.
int predCount = getPredicateCount();
// If we have already calculated the length, and the current predicate
// is the first predicate, then return the length. We don't cache
// the anything but the length of the list to the first predicate.
if (-1 != m_length && isPredicateTest && m_predicateIndex < 1) return m_length;
int count = 0;
XPathContext xctxt = getXPathContext();
try {
OneStepIterator clone = (OneStepIterator) this.cloneWithReset();
int root = getRoot();
xctxt.pushCurrentNode(root);
clone.setRoot(root, xctxt);
clone.m_predCount = m_predicateIndex;
int next;
while (DTM.NULL != (next = clone.nextNode())) {
count++;
}
} catch (CloneNotSupportedException cnse) {
// can't happen
} finally {
xctxt.popCurrentNode();
}
if (isPredicateTest && m_predicateIndex < 1) m_length = count;
return count;
}
/**
* Get the current sub-context position. In order to do the reverse axes count, for the moment
* this re-searches the axes up to the predicate. An optimization on this is to cache the nodes
* searched, but, for the moment, this case is probably rare enough that the added complexity
* isn't worth it.
*
* @param predicateIndex The predicate index of the proximity position.
* @return The pridicate index, or -1.
*/
protected int getProximityPosition(int predicateIndex) {
if (!isReverseAxes()) return super.getProximityPosition(predicateIndex);
// A negative predicate index seems to occur with
// (preceding-sibling::*|following-sibling::*)/ancestor::*[position()]/*[position()]
// -sb
if (predicateIndex < 0) return -1;
if (m_proximityPositions[predicateIndex] <= 0) {
XPathContext xctxt = getXPathContext();
try {
OneStepIterator clone = (OneStepIterator) this.clone();
int root = getRoot();
xctxt.pushCurrentNode(root);
clone.setRoot(root, xctxt);
// clone.setPredicateCount(predicateIndex);
clone.m_predCount = predicateIndex;
// Count 'em all
int count = 1;
int next;
while (DTM.NULL != (next = clone.nextNode())) {
count++;
}
m_proximityPositions[predicateIndex] += count;
} catch (CloneNotSupportedException cnse) {
// can't happen
} finally {
xctxt.popCurrentNode();
}
}
return m_proximityPositions[predicateIndex];
}
/**
* Test whether a specified node is visible in the logical view of a TreeWalker or NodeIterator.
* This function will be called by the implementation of TreeWalker and NodeIterator; it is not
* intended to be called directly from user code.
*
* @param n The node to check to see if it passes the filter or not.
* @return a constant to determine whether the node is accepted, rejected, or skipped, as defined
* above .
*/
public short acceptNode(int n) {
XPathContext xctxt = getXPathContext();
try {
xctxt.pushCurrentNode(n);
for (int i = 0; i < m_nodeTests.length; i++) {
PredicatedNodeTest pnt = m_nodeTests[i];
XObject score = pnt.execute(xctxt, n);
if (score != NodeTest.SCORE_NONE) {
// Note that we are assuming there are no positional predicates!
if (pnt.getPredicateCount() > 0) {
if (pnt.executePredicates(n, xctxt)) return DTMIterator.FILTER_ACCEPT;
} else return DTMIterator.FILTER_ACCEPT;
}
}
} catch (javax.xml.transform.TransformerException se) {
// TODO: Fix this.
throw new RuntimeException(se.getMessage());
} finally {
xctxt.popCurrentNode();
}
return DTMIterator.FILTER_SKIP;
}