Java Code Examples for com.sun.org.apache.xpath.internal.XPathContext#pushContextNodeList()

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}
 

/**
 * 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;

}