Java Code Examples for com.sun.org.apache.xpath.internal.NodeSet#setShouldCacheNodes()

/**
 * The math:highest function returns the nodes in the node set whose value is the maximum
 * value for the node set. The maximum value for the node set is the same as the value as
 * calculated by math:max. A node has this maximum value if the result of converting its
 * string value to a number as if by the number function is equal to the maximum value,
 * where the equality comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:max function will
 * return NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any
 * of the nodes in the node set has a non-numeric value, math:highest will return an empty
 * node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the maximum value found, an empty node-set
 * if any node cannot be converted to a number.
 */
public static NodeList highest (NodeList nl)
{
  double maxValue = max(nl);

  NodeSet highNodes = new NodeSet();
  highNodes.setShouldCacheNodes(true);

  if (Double.isNaN(maxValue))
    return highNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == maxValue)
      highNodes.addElement(n);
  }
  return highNodes;
}
 

/**
 * The math:highest function returns the nodes in the node set whose value is the maximum
 * value for the node set. The maximum value for the node set is the same as the value as
 * calculated by math:max. A node has this maximum value if the result of converting its
 * string value to a number as if by the number function is equal to the maximum value,
 * where the equality comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:max function will
 * return NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any
 * of the nodes in the node set has a non-numeric value, math:highest will return an empty
 * node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the maximum value found, an empty node-set
 * if any node cannot be converted to a number.
 */
public static NodeList highest (NodeList nl)
{
  double maxValue = max(nl);

  NodeSet highNodes = new NodeSet();
  highNodes.setShouldCacheNodes(true);

  if (Double.isNaN(maxValue))
    return highNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == maxValue)
      highNodes.addElement(n);
  }
  return highNodes;
}
 

/**
 * The math:highest function returns the nodes in the node set whose value is the maximum
 * value for the node set. The maximum value for the node set is the same as the value as
 * calculated by math:max. A node has this maximum value if the result of converting its
 * string value to a number as if by the number function is equal to the maximum value,
 * where the equality comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:max function will
 * return NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any
 * of the nodes in the node set has a non-numeric value, math:highest will return an empty
 * node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the maximum value found, an empty node-set
 * if any node cannot be converted to a number.
 */
public static NodeList highest (NodeList nl)
{
  double maxValue = max(nl);

  NodeSet highNodes = new NodeSet();
  highNodes.setShouldCacheNodes(true);

  if (Double.isNaN(maxValue))
    return highNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == maxValue)
      highNodes.addElement(n);
  }
  return highNodes;
}
 

/**
 * The math:highest function returns the nodes in the node set whose value is the maximum
 * value for the node set. The maximum value for the node set is the same as the value as
 * calculated by math:max. A node has this maximum value if the result of converting its
 * string value to a number as if by the number function is equal to the maximum value,
 * where the equality comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:max function will
 * return NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any
 * of the nodes in the node set has a non-numeric value, math:highest will return an empty
 * node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the maximum value found, an empty node-set
 * if any node cannot be converted to a number.
 */
public static NodeList highest (NodeList nl)
{
  double maxValue = max(nl);

  NodeSet highNodes = new NodeSet();
  highNodes.setShouldCacheNodes(true);

  if (Double.isNaN(maxValue))
    return highNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == maxValue)
      highNodes.addElement(n);
  }
  return highNodes;
}
 

/**
 * The set:intersection function returns a node set comprising the nodes that are within
 * both the node sets passed as arguments to it.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that are also
 * in nl2.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList intersection(NodeList nl1, NodeList nl2)
{
  NodeSet ns1 = new NodeSet(nl1);
  NodeSet ns2 = new NodeSet(nl2);
  NodeSet inter = new NodeSet();

  inter.setShouldCacheNodes(true);

  for (int i = 0; i < ns1.getLength(); i++)
  {
    Node n = ns1.elementAt(i);

    if (ns2.contains(n))
      inter.addElement(n);
  }

  return inter;
}
 

/**
 * The math:lowest function returns the nodes in the node set whose value is the minimum value
 * for the node set. The minimum value for the node set is the same as the value as calculated
 * by math:min. A node has this minimum value if the result of converting its string value to
 * a number as if by the number function is equal to the minimum value, where the equality
 * comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:min function will return
 * NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any of the nodes
 * in the node set has a non-numeric value, math:lowest will return an empty node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the minimum value found, an empty node-set
 * if any node cannot be converted to a number.
 *
 */
public static NodeList lowest (NodeList nl)
{
  double minValue = min(nl);

  NodeSet lowNodes = new NodeSet();
  lowNodes.setShouldCacheNodes(true);

  if (Double.isNaN(minValue))
    return lowNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == minValue)
      lowNodes.addElement(n);
  }
  return lowNodes;
}
 

/**
 * The set:intersection function returns a node set comprising the nodes that are within
 * both the node sets passed as arguments to it.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that are also
 * in nl2.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList intersection(NodeList nl1, NodeList nl2)
{
  NodeSet ns1 = new NodeSet(nl1);
  NodeSet ns2 = new NodeSet(nl2);
  NodeSet inter = new NodeSet();

  inter.setShouldCacheNodes(true);

  for (int i = 0; i < ns1.getLength(); i++)
  {
    Node n = ns1.elementAt(i);

    if (ns2.contains(n))
      inter.addElement(n);
  }

  return inter;
}
 

/**
 * The math:highest function returns the nodes in the node set whose value is the maximum
 * value for the node set. The maximum value for the node set is the same as the value as
 * calculated by math:max. A node has this maximum value if the result of converting its
 * string value to a number as if by the number function is equal to the maximum value,
 * where the equality comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:max function will
 * return NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any
 * of the nodes in the node set has a non-numeric value, math:highest will return an empty
 * node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the maximum value found, an empty node-set
 * if any node cannot be converted to a number.
 */
public static NodeList highest (NodeList nl)
{
  double maxValue = max(nl);

  NodeSet highNodes = new NodeSet();
  highNodes.setShouldCacheNodes(true);

  if (Double.isNaN(maxValue))
    return highNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == maxValue)
      highNodes.addElement(n);
  }
  return highNodes;
}
 

/**
 * The set:intersection function returns a node set comprising the nodes that are within
 * both the node sets passed as arguments to it.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that are also
 * in nl2.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList intersection(NodeList nl1, NodeList nl2)
{
  NodeSet ns1 = new NodeSet(nl1);
  NodeSet ns2 = new NodeSet(nl2);
  NodeSet inter = new NodeSet();

  inter.setShouldCacheNodes(true);

  for (int i = 0; i < ns1.getLength(); i++)
  {
    Node n = ns1.elementAt(i);

    if (ns2.contains(n))
      inter.addElement(n);
  }

  return inter;
}
 

/**
 * The math:highest function returns the nodes in the node set whose value is the maximum
 * value for the node set. The maximum value for the node set is the same as the value as
 * calculated by math:max. A node has this maximum value if the result of converting its
 * string value to a number as if by the number function is equal to the maximum value,
 * where the equality comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:max function will
 * return NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any
 * of the nodes in the node set has a non-numeric value, math:highest will return an empty
 * node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the maximum value found, an empty node-set
 * if any node cannot be converted to a number.
 */
public static NodeList highest (NodeList nl)
{
  double maxValue = max(nl);

  NodeSet highNodes = new NodeSet();
  highNodes.setShouldCacheNodes(true);

  if (Double.isNaN(maxValue))
    return highNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == maxValue)
      highNodes.addElement(n);
  }
  return highNodes;
}
 

/**
 * The set:difference function returns the difference between two node sets - those nodes that
 * are in the node set passed as the first argument that are not in the node set passed as the
 * second argument.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that are not in nl2.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList difference(NodeList nl1, NodeList nl2)
{
  NodeSet ns1 = new NodeSet(nl1);
  NodeSet ns2 = new NodeSet(nl2);

  NodeSet diff = new NodeSet();

  diff.setShouldCacheNodes(true);

  for (int i = 0; i < ns1.getLength(); i++)
  {
    Node n = ns1.elementAt(i);

    if (!ns2.contains(n))
      diff.addElement(n);
  }

  return diff;
}
 

/**
 * The math:lowest function returns the nodes in the node set whose value is the minimum value
 * for the node set. The minimum value for the node set is the same as the value as calculated
 * by math:min. A node has this minimum value if the result of converting its string value to
 * a number as if by the number function is equal to the minimum value, where the equality
 * comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:min function will return
 * NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any of the nodes
 * in the node set has a non-numeric value, math:lowest will return an empty node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the minimum value found, an empty node-set
 * if any node cannot be converted to a number.
 *
 */
public static NodeList lowest (NodeList nl)
{
  double minValue = min(nl);

  NodeSet lowNodes = new NodeSet();
  lowNodes.setShouldCacheNodes(true);

  if (Double.isNaN(minValue))
    return lowNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == minValue)
      lowNodes.addElement(n);
  }
  return lowNodes;
}
 

/**
 * The math:highest function returns the nodes in the node set whose value is the maximum
 * value for the node set. The maximum value for the node set is the same as the value as
 * calculated by math:max. A node has this maximum value if the result of converting its
 * string value to a number as if by the number function is equal to the maximum value,
 * where the equality comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:max function will
 * return NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any
 * of the nodes in the node set has a non-numeric value, math:highest will return an empty
 * node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the maximum value found, an empty node-set
 * if any node cannot be converted to a number.
 */
public static NodeList highest (NodeList nl)
{
  double maxValue = max(nl);

  NodeSet highNodes = new NodeSet();
  highNodes.setShouldCacheNodes(true);

  if (Double.isNaN(maxValue))
    return highNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == maxValue)
      highNodes.addElement(n);
  }
  return highNodes;
}
 

/**
 * The math:lowest function returns the nodes in the node set whose value is the minimum value
 * for the node set. The minimum value for the node set is the same as the value as calculated
 * by math:min. A node has this minimum value if the result of converting its string value to
 * a number as if by the number function is equal to the minimum value, where the equality
 * comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:min function will return
 * NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any of the nodes
 * in the node set has a non-numeric value, math:lowest will return an empty node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the minimum value found, an empty node-set
 * if any node cannot be converted to a number.
 *
 */
public static NodeList lowest (NodeList nl)
{
  double minValue = min(nl);

  NodeSet lowNodes = new NodeSet();
  lowNodes.setShouldCacheNodes(true);

  if (Double.isNaN(minValue))
    return lowNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == minValue)
      lowNodes.addElement(n);
  }
  return lowNodes;
}
 

/**
 * The math:lowest function returns the nodes in the node set whose value is the minimum value
 * for the node set. The minimum value for the node set is the same as the value as calculated
 * by math:min. A node has this minimum value if the result of converting its string value to
 * a number as if by the number function is equal to the minimum value, where the equality
 * comparison is defined as a numerical comparison using the = operator.
 * <p>
 * If any of the nodes in the node set has a non-numeric value, the math:min function will return
 * NaN. The definition numeric comparisons entails that NaN != NaN. Therefore if any of the nodes
 * in the node set has a non-numeric value, math:lowest will return an empty node set.
 *
 * @param nl The NodeList for the node-set to be evaluated.
 *
 * @return node-set with nodes containing the minimum value found, an empty node-set
 * if any node cannot be converted to a number.
 *
 */
public static NodeList lowest (NodeList nl)
{
  double minValue = min(nl);

  NodeSet lowNodes = new NodeSet();
  lowNodes.setShouldCacheNodes(true);

  if (Double.isNaN(minValue))
    return lowNodes;  // empty Nodeset

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node n = nl.item(i);
    double d = toNumber(n);
    if (d == minValue)
      lowNodes.addElement(n);
  }
  return lowNodes;
}
 

/**
 * The set:distinct function returns a subset of the nodes contained in the node-set NS passed
 * as the first argument. Specifically, it selects a node N if there is no node in NS that has
 * the same string value as N, and that precedes N in document order.
 *
 * @param nl NodeList for the node-set.
 * @return a NodeList with nodes from nl containing distinct string values.
 * In other words, if more than one node in nl contains the same string value,
 * only include the first such node found.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList distinct(NodeList nl)
{
  NodeSet dist = new NodeSet();
  dist.setShouldCacheNodes(true);

  Map<String, Node> stringTable = new HashMap<>();

  for (int i = 0; i < nl.getLength(); i++)
  {
    Node currNode = nl.item(i);
    String key = toString(currNode);

    if (key == null)
      dist.addElement(currNode);
    else if (!stringTable.containsKey(key))
    {
      stringTable.put(key, currNode);
      dist.addElement(currNode);
    }
  }

  return dist;
}
 

/**
 * The set:difference function returns the difference between two node sets - those nodes that
 * are in the node set passed as the first argument that are not in the node set passed as the
 * second argument.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that are not in nl2.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList difference(NodeList nl1, NodeList nl2)
{
  NodeSet ns1 = new NodeSet(nl1);
  NodeSet ns2 = new NodeSet(nl2);

  NodeSet diff = new NodeSet();

  diff.setShouldCacheNodes(true);

  for (int i = 0; i < ns1.getLength(); i++)
  {
    Node n = ns1.elementAt(i);

    if (!ns2.contains(n))
      diff.addElement(n);
  }

  return diff;
}
 

/**
 * The str:split function splits up a string and returns a node set of token
 * elements, each containing one token from the string.
 * <p>
 * The first argument is the string to be split. The second argument is a pattern
 * string. The string given by the first argument is split at any occurrence of
 * this pattern. For example:
 * <pre>
 * str:split('a, simple, list', ', ') gives the node set consisting of:
 *
 * <token>a</token>
 * <token>simple</token>
 * <token>list</token>
 * </pre>
 * If the second argument is omitted, the default is the string '&#x20;' (i.e. a space).
 *
 * @param str The string to be split
 * @param pattern The pattern
 *
 * @return A node set of split tokens
 */
public static NodeList split(String str, String pattern)
{


  NodeSet resultSet = new NodeSet();
  resultSet.setShouldCacheNodes(true);

  boolean done = false;
  int fromIndex = 0;
  int matchIndex = 0;
  String token = null;

  while (!done && fromIndex < str.length())
  {
    matchIndex = str.indexOf(pattern, fromIndex);
    if (matchIndex >= 0)
    {
      token = str.substring(fromIndex, matchIndex);
      fromIndex = matchIndex + pattern.length();
    }
    else
    {
      done = true;
      token = str.substring(fromIndex);
    }

    Document doc = JdkXmlUtils.getDOMDocument();
    synchronized (doc)
    {
      Element element = doc.createElement("token");
      Text text = doc.createTextNode(token);
      element.appendChild(text);
      resultSet.addNode(element);
    }
  }

  return resultSet;
}
 

/**
 * The str:split function splits up a string and returns a node set of token
 * elements, each containing one token from the string.
 * <p>
 * The first argument is the string to be split. The second argument is a pattern
 * string. The string given by the first argument is split at any occurrence of
 * this pattern. For example:
 * <pre>
 * str:split('a, simple, list', ', ') gives the node set consisting of:
 *
 * <token>a</token>
 * <token>simple</token>
 * <token>list</token>
 * </pre>
 * If the second argument is omitted, the default is the string '&#x20;' (i.e. a space).
 *
 * @param str The string to be split
 * @param pattern The pattern
 *
 * @return A node set of split tokens
 */
public static NodeList split(String str, String pattern)
{


  NodeSet resultSet = new NodeSet();
  resultSet.setShouldCacheNodes(true);

  boolean done = false;
  int fromIndex = 0;
  int matchIndex = 0;
  String token = null;

  while (!done && fromIndex < str.length())
  {
    matchIndex = str.indexOf(pattern, fromIndex);
    if (matchIndex >= 0)
    {
      token = str.substring(fromIndex, matchIndex);
      fromIndex = matchIndex + pattern.length();
    }
    else
    {
      done = true;
      token = str.substring(fromIndex);
    }

    Document doc = JdkXmlUtils.getDOMDocument();
    synchronized (doc)
    {
      Element element = doc.createElement("token");
      Text text = doc.createTextNode(token);
      element.appendChild(text);
      resultSet.addNode(element);
    }
  }

  return resultSet;
}
 

/**
 * The str:split function splits up a string and returns a node set of token
 * elements, each containing one token from the string.
 * <p>
 * The first argument is the string to be split. The second argument is a pattern
 * string. The string given by the first argument is split at any occurrence of
 * this pattern. For example:
 * <pre>
 * str:split('a, simple, list', ', ') gives the node set consisting of:
 *
 * <token>a</token>
 * <token>simple</token>
 * <token>list</token>
 * </pre>
 * If the second argument is omitted, the default is the string '&#x20;' (i.e. a space).
 *
 * @param str The string to be split
 * @param pattern The pattern
 *
 * @return A node set of split tokens
 */
public static NodeList split(String str, String pattern)
{


  NodeSet resultSet = new NodeSet();
  resultSet.setShouldCacheNodes(true);

  boolean done = false;
  int fromIndex = 0;
  int matchIndex = 0;
  String token = null;

  while (!done && fromIndex < str.length())
  {
    matchIndex = str.indexOf(pattern, fromIndex);
    if (matchIndex >= 0)
    {
      token = str.substring(fromIndex, matchIndex);
      fromIndex = matchIndex + pattern.length();
    }
    else
    {
      done = true;
      token = str.substring(fromIndex);
    }

    Document doc = JdkXmlUtils.getDOMDocument();
    synchronized (doc)
    {
      Element element = doc.createElement("token");
      Text text = doc.createTextNode(token);
      element.appendChild(text);
      resultSet.addNode(element);
    }
  }

  return resultSet;
}