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

/**
 * 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:trailing function returns the nodes in the node set passed as the first argument that
 * follow, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that follow in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList trailing (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet trailNodes = new NodeSet();
  Node startNode = nl2.item(0);
  if (!ns1.contains(startNode))
    return trailNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(startNode, testNode)
        && !DOM2Helper.isNodeTheSame(startNode, testNode))
      trailNodes.addElement(testNode);
  }
  return trailNodes;
}
 

/**
 * 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 set:leading function returns the nodes in the node set passed as the first argument that
 * precede, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that precede in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList leading (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet leadNodes = new NodeSet();
  Node endNode = nl2.item(0);
  if (!ns1.contains(endNode))
    return leadNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(testNode, endNode)
        && !DOM2Helper.isNodeTheSame(testNode, endNode))
      leadNodes.addElement(testNode);
  }
  return leadNodes;
}
 

/**
 * The set:trailing function returns the nodes in the node set passed as the first argument that
 * follow, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that follow in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList trailing (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet trailNodes = new NodeSet();
  Node startNode = nl2.item(0);
  if (!ns1.contains(startNode))
    return trailNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOMHelper.isNodeAfter(startNode, testNode)
        && !DOMHelper.isNodeTheSame(startNode, testNode))
      trailNodes.addElement(testNode);
  }
  return trailNodes;
}
 

/**
 * 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 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:trailing function returns the nodes in the node set passed as the first argument that
 * follow, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that follow in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList trailing (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet trailNodes = new NodeSet();
  Node startNode = nl2.item(0);
  if (!ns1.contains(startNode))
    return trailNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(startNode, testNode)
        && !DOM2Helper.isNodeTheSame(startNode, testNode))
      trailNodes.addElement(testNode);
  }
  return trailNodes;
}
 

/**
 * The set:leading function returns the nodes in the node set passed as the first argument that
 * precede, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that precede in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList leading (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet leadNodes = new NodeSet();
  Node endNode = nl2.item(0);
  if (!ns1.contains(endNode))
    return leadNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOMHelper.isNodeAfter(testNode, endNode)
        && !DOMHelper.isNodeTheSame(testNode, endNode))
      leadNodes.addElement(testNode);
  }
  return leadNodes;
}
 

/**
 * 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:leading function returns the nodes in the node set passed as the first argument that
 * precede, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that precede in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList leading (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet leadNodes = new NodeSet();
  Node endNode = nl2.item(0);
  if (!ns1.contains(endNode))
    return leadNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(testNode, endNode)
        && !DOM2Helper.isNodeTheSame(testNode, endNode))
      leadNodes.addElement(testNode);
  }
  return leadNodes;
}
 

/**
 * 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: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 set:trailing function returns the nodes in the node set passed as the first argument that
 * follow, in document order, the first node in the node set passed as the second argument. If
 * the first node in the second node set is not contained in the first node set, then an empty
 * node set is returned. If the second node set is empty, then the first node set is returned.
 *
 * @param nl1 NodeList for first node-set.
 * @param nl2 NodeList for second node-set.
 * @return a NodeList containing the nodes in nl1 that follow in document order the first
 * node in nl2; an empty node-set if the first node in nl2 is not in nl1; all of nl1 if nl2
 * is empty.
 *
 * @see <a href="http://www.exslt.org/">EXSLT</a>
 */
public static NodeList trailing (NodeList nl1, NodeList nl2)
{
  if (nl2.getLength() == 0)
    return nl1;

  NodeSet ns1 = new NodeSet(nl1);
  NodeSet trailNodes = new NodeSet();
  Node startNode = nl2.item(0);
  if (!ns1.contains(startNode))
    return trailNodes; // empty NodeSet

  for (int i = 0; i < nl1.getLength(); i++)
  {
    Node testNode = nl1.item(i);
    if (DOM2Helper.isNodeAfter(startNode, testNode)
        && !DOM2Helper.isNodeTheSame(startNode, testNode))
      trailNodes.addElement(testNode);
  }
  return trailNodes;
}
 

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