Java源码示例：com.sun.org.apache.xpath.internal.NodeSet
示例1
/**
* 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;
}
示例2
/**
* 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;
}
示例3
/**
* 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;
}
示例4
/**
* 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;
}
示例5
/**
* Returns a NodeSet containing one text node for each token in the first argument.
* Delimiters are specified in the second argument.
* Tokens are determined by a call to <code>StringTokenizer</code>.
* If the first argument is an empty string or contains only delimiters, the result
* will be an empty NodeSet.
*
* Contributed to XalanJ1 by <a href="mailto:[email protected]">Benoit Cerrina</a>.
*
* @param toTokenize The string to be split into text tokens.
* @param delims The delimiters to use.
* @return a NodeSet as described above.
*/
public static NodeList tokenize(String toTokenize, String delims)
{
Document doc = getDocument();
StringTokenizer lTokenizer = new StringTokenizer(toTokenize, delims);
NodeSet resultSet = new NodeSet();
synchronized (doc)
{
while (lTokenizer.hasMoreTokens())
{
resultSet.addNode(doc.createTextNode(lTokenizer.nextToken()));
}
}
return resultSet;
}
示例6
/**
* 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;
}
示例7
/**
* 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;
}
示例8
/**
* 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;
}
示例9
/**
* Returns a NodeSet containing one text node for each token in the first argument.
* Delimiters are specified in the second argument.
* Tokens are determined by a call to <code>StringTokenizer</code>.
* If the first argument is an empty string or contains only delimiters, the result
* will be an empty NodeSet.
*
* Contributed to XalanJ1 by <a href="mailto:[email protected]">Benoit Cerrina</a>.
*
* @param toTokenize The string to be split into text tokens.
* @param delims The delimiters to use.
* @return a NodeSet as described above.
*/
public static NodeList tokenize(String toTokenize, String delims)
{
Document doc = JdkXmlUtils.getDOMDocument();
StringTokenizer lTokenizer = new StringTokenizer(toTokenize, delims);
NodeSet resultSet = new NodeSet();
synchronized (doc)
{
while (lTokenizer.hasMoreTokens())
{
resultSet.addNode(doc.createTextNode(lTokenizer.nextToken()));
}
}
return resultSet;
}
示例10
/**
* 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;
}
示例11
/**
* 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;
}
示例12
/**
* 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;
}
示例13
/**
* 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;
}
示例14
/**
* 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;
}
示例15
/**
* 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;
}
示例16
/**
* Returns true if both node-sets contain the same set of nodes.
*
* @param nl1 NodeList for first node-set
* @param nl2 NodeList for second node-set
* @return true if nl1 and nl2 contain exactly the same set of nodes.
*/
public static boolean hasSameNodes(NodeList nl1, NodeList nl2)
{
NodeSet ns1 = new NodeSet(nl1);
NodeSet ns2 = new NodeSet(nl2);
if (ns1.getLength() != ns2.getLength())
return false;
for (int i = 0; i < ns1.getLength(); i++)
{
Node n = ns1.elementAt(i);
if (!ns2.contains(n))
return false;
}
return true;
}
示例17
/**
* Returns a NodeSet containing one text node for each token in the first argument.
* Delimiters are specified in the second argument.
* Tokens are determined by a call to <code>StringTokenizer</code>.
* If the first argument is an empty string or contains only delimiters, the result
* will be an empty NodeSet.
*
* Contributed to XalanJ1 by <a href="mailto:[email protected]">Benoit Cerrina</a>.
*
* @param toTokenize The string to be split into text tokens.
* @param delims The delimiters to use.
* @return a NodeSet as described above.
*/
public static NodeList tokenize(String toTokenize, String delims)
{
Document doc = JdkXmlUtils.getDOMDocument();
StringTokenizer lTokenizer = new StringTokenizer(toTokenize, delims);
NodeSet resultSet = new NodeSet();
synchronized (doc)
{
while (lTokenizer.hasMoreTokens())
{
resultSet.addNode(doc.createTextNode(lTokenizer.nextToken()));
}
}
return resultSet;
}
示例18
/**
* 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;
}
示例19
/**
* 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;
}
示例20
/**
* Returns true if both node-sets contain the same set of nodes.
*
* @param nl1 NodeList for first node-set
* @param nl2 NodeList for second node-set
* @return true if nl1 and nl2 contain exactly the same set of nodes.
*/
public static boolean hasSameNodes(NodeList nl1, NodeList nl2)
{
NodeSet ns1 = new NodeSet(nl1);
NodeSet ns2 = new NodeSet(nl2);
if (ns1.getLength() != ns2.getLength())
return false;
for (int i = 0; i < ns1.getLength(); i++)
{
Node n = ns1.elementAt(i);
if (!ns2.contains(n))
return false;
}
return true;
}
示例21
/**
* 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;
}
示例22
/**
* 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;
}
示例23
/**
* 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;
}
示例24
/**
* 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);
Hashtable stringTable = new Hashtable();
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;
}
示例25
/**
* Returns a NodeSet containing one text node for each token in the first argument.
* Delimiters are specified in the second argument.
* Tokens are determined by a call to <code>StringTokenizer</code>.
* If the first argument is an empty string or contains only delimiters, the result
* will be an empty NodeSet.
*
* Contributed to XalanJ1 by <a href="mailto:[email protected]">Benoit Cerrina</a>.
*
* @param toTokenize The string to be split into text tokens.
* @param delims The delimiters to use.
* @return a NodeSet as described above.
*/
public static NodeList tokenize(String toTokenize, String delims)
{
Document doc = getDocument();
StringTokenizer lTokenizer = new StringTokenizer(toTokenize, delims);
NodeSet resultSet = new NodeSet();
synchronized (doc)
{
while (lTokenizer.hasMoreTokens())
{
resultSet.addNode(doc.createTextNode(lTokenizer.nextToken()));
}
}
return resultSet;
}
示例26
/**
* Returns a NodeSet containing one text node for each token in the first argument.
* Delimiters are specified in the second argument.
* Tokens are determined by a call to <code>StringTokenizer</code>.
* If the first argument is an empty string or contains only delimiters, the result
* will be an empty NodeSet.
*
* Contributed to XalanJ1 by <a href="mailto:[email protected]">Benoit Cerrina</a>.
*
* @param toTokenize The string to be split into text tokens.
* @param delims The delimiters to use.
* @return a NodeSet as described above.
*/
public static NodeList tokenize(String toTokenize, String delims)
{
Document doc = getDocument();
StringTokenizer lTokenizer = new StringTokenizer(toTokenize, delims);
NodeSet resultSet = new NodeSet();
synchronized (doc)
{
while (lTokenizer.hasMoreTokens())
{
resultSet.addNode(doc.createTextNode(lTokenizer.nextToken()));
}
}
return resultSet;
}
示例27
/**
* 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;
}
示例28
/**
* 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;
}
示例29
/**
* 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;
}
示例30
/**
* 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;
}
