Java XPathContext.pushCurrentNode方法代码示例

import com.sun.org.apache.xpath.internal.XPathContext; //导入方法依赖的package包/类
/**
 * Get the match score of the given node.
 *
 * @param xctxt The XPath runtime context.
 * @param context The node to be tested.
 *
 * @return {@link com.sun.org.apache.xpath.internal.patterns.NodeTest#SCORE_NODETEST},
 *         {@link com.sun.org.apache.xpath.internal.patterns.NodeTest#SCORE_NONE},
 *         {@link com.sun.org.apache.xpath.internal.patterns.NodeTest#SCORE_NSWILD},
 *         {@link com.sun.org.apache.xpath.internal.patterns.NodeTest#SCORE_QNAME}, or
 *         {@link com.sun.org.apache.xpath.internal.patterns.NodeTest#SCORE_OTHER}.
 *
 * @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 = execute(xctxt);

    return score.num();
  }
  finally
  {
    xctxt.popCurrentNode();
    xctxt.popCurrentExpressionNode();
  }

  // return XPath.MATCH_SCORE_NONE;
}
 

import com.sun.org.apache.xpath.internal.XPathContext; //导入方法依赖的package包/类
/**
 * Execute the match pattern step relative to another step.
 *
 *
 * @param xctxt The XPath runtime context.
 * @param dtm The DTM of the current node.
 * @param currentNode The current node context.
 *
 * @return {@link com.sun.org.apache.xpath.internal.patterns.NodeTest#SCORE_NODETEST},
 *         {@link com.sun.org.apache.xpath.internal.patterns.NodeTest#SCORE_NONE},
 *         {@link com.sun.org.apache.xpath.internal.patterns.NodeTest#SCORE_NSWILD},
 *         {@link com.sun.org.apache.xpath.internal.patterns.NodeTest#SCORE_QNAME}, or
 *         {@link com.sun.org.apache.xpath.internal.patterns.NodeTest#SCORE_OTHER}.
 *
 * @throws javax.xml.transform.TransformerException
 */
protected final XObject executeRelativePathPattern(
        XPathContext xctxt, DTM dtm, int currentNode)
          throws javax.xml.transform.TransformerException
{

  XObject score = NodeTest.SCORE_NONE;
  int context = currentNode;
  DTMAxisTraverser traverser;

  traverser = dtm.getAxisTraverser(m_axis);

  for (int relative = traverser.first(context); DTM.NULL != relative;
          relative = traverser.next(context, relative))
  {
    try
    {
      xctxt.pushCurrentNode(relative);

      score = execute(xctxt);

      if (score != NodeTest.SCORE_NONE)
        break;
    }
    finally
    {
      xctxt.popCurrentNode();
    }
  }

  return score;
}
 

import com.sun.org.apache.xpath.internal.XPathContext; //导入方法依赖的package包/类
/**
 * 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;
}
 

import com.sun.org.apache.xpath.internal.XPathContext; //导入方法依赖的package包/类
/**
 *  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 = m_lpi.getXPathContext();

  try
  {
    xctxt.pushCurrentNode(n);

    XObject score = execute(xctxt, n);

    // System.out.println("\n::acceptNode - score: "+score.num()+"::");
    if (score != NodeTest.SCORE_NONE)
    {
      if (getPredicateCount() > 0)
      {
        countProximityPosition(0);

        if (!executePredicates(n, xctxt))
          return DTMIterator.FILTER_SKIP;
      }

      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;
}
 

import com.sun.org.apache.xpath.internal.XPathContext; //导入方法依赖的package包/类
/**
 * The dyn:max function calculates the maximum value for the nodes passed as
 * the first argument, where the value of each node is calculated dynamically
 * using an XPath expression passed as a string as the second argument.
 * <p>
 * The expressions are evaluated relative to the nodes passed as the first argument.
 * In other words, the value for each node is calculated by evaluating the XPath
 * expression with all context information being the same as that for the call to
 * the dyn:max function itself, except for the following:
 * <p>
 * <ul>
 *  <li>the context node is the node whose value is being calculated.</li>
 *  <li>the context position is the position of the node within the node set passed as
 *   the first argument to the dyn:max function, arranged in document order.</li>
 *  <li>the context size is the number of nodes passed as the first argument to the
 *   dyn:max function.</li>
 * </ul>
 * <p>
 * The dyn:max function returns the maximum of these values, calculated in exactly
 * the same way as for math:max.
 * <p>
 * If the expression string passed as the second argument is an invalid XPath
 * expression (including an empty string), this function returns NaN.
 * <p>
 * This function must take a second argument. To calculate the maximum of a set of
 * nodes based on their string values, you should use the math:max function.
 *
 * @param myContext The ExpressionContext passed by the extension processor
 * @param nl The node set
 * @param expr The expression string
 *
 * @return The maximum evaluation value
 */
public static double max(ExpressionContext myContext, NodeList nl, String expr)
  throws SAXNotSupportedException
{

  XPathContext xctxt = null;
  if (myContext instanceof XPathContext.XPathExpressionContext)
    xctxt = ((XPathContext.XPathExpressionContext) myContext).getXPathContext();
  else
    throw new SAXNotSupportedException(XSLMessages.createMessage(XSLTErrorResources.ER_INVALID_CONTEXT_PASSED, new Object[]{myContext }));

  if (expr == null || expr.length() == 0)
    return Double.NaN;

  NodeSetDTM contextNodes = new NodeSetDTM(nl, xctxt);
  xctxt.pushContextNodeList(contextNodes);

  double maxValue = - Double.MAX_VALUE;
  for (int i = 0; i < contextNodes.getLength(); i++)
  {
    int contextNode = contextNodes.item(i);
    xctxt.pushCurrentNode(contextNode);

    double result = 0;
    try
    {
      XPath dynamicXPath = new XPath(expr, xctxt.getSAXLocator(),
                                     xctxt.getNamespaceContext(),
                                     XPath.SELECT);
      result = dynamicXPath.execute(xctxt, contextNode, xctxt.getNamespaceContext()).num();
    }
    catch (TransformerException e)
    {
      xctxt.popCurrentNode();
      xctxt.popContextNodeList();
      return Double.NaN;
    }

    xctxt.popCurrentNode();

    if (result > maxValue)
        maxValue = result;
  }

  xctxt.popContextNodeList();
  return maxValue;

}
 

import com.sun.org.apache.xpath.internal.XPathContext; //导入方法依赖的package包/类
/**
 * The dyn:min function calculates the minimum value for the nodes passed as the
 * first argument, where the value of each node is calculated dynamically using
 * an XPath expression passed as a string as the second argument.
 * <p>
 * The expressions are evaluated relative to the nodes passed as the first argument.
 * In other words, the value for each node is calculated by evaluating the XPath
 * expression with all context information being the same as that for the call to
 * the dyn:min function itself, except for the following:
 * <p>
 * <ul>
 *  <li>the context node is the node whose value is being calculated.</li>
 *  <li>the context position is the position of the node within the node set passed
 *    as the first argument to the dyn:min function, arranged in document order.</li>
 *  <li>the context size is the number of nodes passed as the first argument to the
 *    dyn:min function.</li>
 * </ul>
 * <p>
 * The dyn:min function returns the minimum of these values, calculated in exactly
 * the same way as for math:min.
 * <p>
 * If the expression string passed as the second argument is an invalid XPath expression
 * (including an empty string), this function returns NaN.
 * <p>
 * This function must take a second argument. To calculate the minimum of a set of
 * nodes based on their string values, you should use the math:min function.
 *
 * @param myContext The ExpressionContext passed by the extension processor
 * @param nl The node set
 * @param expr The expression string
 *
 * @return The minimum evaluation value
 */
public static double min(ExpressionContext myContext, NodeList nl, String expr)
  throws SAXNotSupportedException
{

  XPathContext xctxt = null;
  if (myContext instanceof XPathContext.XPathExpressionContext)
    xctxt = ((XPathContext.XPathExpressionContext) myContext).getXPathContext();
  else
    throw new SAXNotSupportedException(XSLMessages.createMessage(XSLTErrorResources.ER_INVALID_CONTEXT_PASSED, new Object[]{myContext }));

  if (expr == null || expr.length() == 0)
    return Double.NaN;

  NodeSetDTM contextNodes = new NodeSetDTM(nl, xctxt);
  xctxt.pushContextNodeList(contextNodes);

  double minValue = Double.MAX_VALUE;
  for (int i = 0; i < nl.getLength(); i++)
  {
    int contextNode = contextNodes.item(i);
    xctxt.pushCurrentNode(contextNode);

    double result = 0;
    try
    {
      XPath dynamicXPath = new XPath(expr, xctxt.getSAXLocator(),
                                     xctxt.getNamespaceContext(),
                                     XPath.SELECT);
      result = dynamicXPath.execute(xctxt, contextNode, xctxt.getNamespaceContext()).num();
    }
    catch (TransformerException e)
    {
      xctxt.popCurrentNode();
      xctxt.popContextNodeList();
      return Double.NaN;
    }

    xctxt.popCurrentNode();

    if (result < minValue)
        minValue = result;
  }

  xctxt.popContextNodeList();
  return minValue;

}
 

import com.sun.org.apache.xpath.internal.XPathContext; //导入方法依赖的package包/类
/**
 * 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];
}
 

import com.sun.org.apache.xpath.internal.XPathContext; //导入方法依赖的package包/类
/**
 *  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;
}
 

import com.sun.org.apache.xpath.internal.XPathContext; //导入方法依赖的package包/类
/**
 *  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();
  }

}
 

import com.sun.org.apache.xpath.internal.XPathContext; //导入方法依赖的package包/类
/**
 * Execute the expression.  Meant for reuse by other FilterExpr iterators
 * that are not derived from this object.
 */
public static XNodeSet executeFilterExpr(int context, XPathContext xctxt,
                                                                                              PrefixResolver prefixResolver,
                                                                                              boolean isTopLevel,
                                                                                              int stackFrame,
                                                                                              Expression expr )
  throws com.sun.org.apache.xml.internal.utils.WrappedRuntimeException
{
  PrefixResolver savedResolver = xctxt.getNamespaceContext();
  XNodeSet result = null;

  try
  {
    xctxt.pushCurrentNode(context);
    xctxt.setNamespaceContext(prefixResolver);

    // The setRoot operation can take place with a reset operation,
    // and so we may not be in the context of LocPathIterator#nextNode,
    // so we have to set up the variable context, execute the expression,
    // and then restore the variable context.

    if (isTopLevel)
    {
      // System.out.println("calling m_expr.execute(getXPathContext())");
      VariableStack vars = xctxt.getVarStack();

      // These three statements need to be combined into one operation.
      int savedStart = vars.getStackFrame();
      vars.setStackFrame(stackFrame);

      result = (com.sun.org.apache.xpath.internal.objects.XNodeSet) expr.execute(xctxt);
      result.setShouldCacheNodes(true);

      // These two statements need to be combined into one operation.
      vars.setStackFrame(savedStart);
    }
    else
        result = (com.sun.org.apache.xpath.internal.objects.XNodeSet) expr.execute(xctxt);

  }
  catch (javax.xml.transform.TransformerException se)
  {

    // TODO: Fix...
    throw new com.sun.org.apache.xml.internal.utils.WrappedRuntimeException(se);
  }
  finally
  {
    xctxt.popCurrentNode();
    xctxt.setNamespaceContext(savedResolver);
  }
  return result;
}