## com.icl.saxon.functions
Class Extensions

    java.lang.Object
      |
      +--com.icl.saxon.functions.Extensions

public class Extensions
extends java.lang.Object

This class implements functions that are supplied as standard with SAXON, but which are not defined in the XSLT or XPath specifications.

To invoke these functions, use a function call of the form prefix:name() where name is the method name, and prefix maps to a URI such as http://icl.com/saxon/com.icl.saxon.functions.Extensions (only the part of the URI after the last slash is important).

Constructor Summary
`Extensions()`

Method Summary
`static NodeSetValue` `after(Context context, NodeSetValue ns1, NodeSetValue ns2)` Find all the nodes in ns1 that are after the first node in ns2.
`static java.lang.String` `baseUri(Context c)` Return the base URI of the context node
`static NodeSetValue` `before(Context context, NodeSetValue ns1, NodeSetValue ns2)` Find all the nodes in ns1 that are before the last node in ns2.
`static NodeEnumeration` `closure(Context c, NodeEnumeration enum, Expression expr)` Evaluate the transitive closure of a node-set expression
`static NodeEnumeration` `difference(Context c, NodeEnumeration p1, NodeEnumeration p2)` Return the difference of two node-sets
`static NodeEnumeration` `distinct(Context context, NodeEnumeration in)` Given a node-set, return a subset that includes only nodes with distinct string-values
`static NodeEnumeration` `distinct(Context context, NodeEnumeration in, Expression exp)` Given a node-set, return a subset that includes only nodes with distinct string-values for the supplied expression
`static Value` `eval(Context c, Expression expr)` Evaluate the stored expression supplied in the first argument
`static Value` `evaluate(Context c, java.lang.String expr)` Evaluate the expression supplied in the first argument as a string
`static boolean` `exists(Context context, NodeEnumeration nsv, Expression expression)` Test whether node-set contains a node that satisfies a given condition
`static Value` `expression(Context c, java.lang.String expr)` Return an object representing a stored expression, from the string supplied in the first argument.
`static boolean` `forAll(Context context, NodeEnumeration nsv, Expression expression)` Test whether all nodes in a node-set satisfy a given condition
`static Context` `getContext(Context c)` Return the Context object
`static java.lang.String` `getPseudoAttribute(Context c, java.lang.String name)` Get a pseudo-attribute of a processing instruction.
`static Value` `getUserData(Context c, java.lang.String name)` Retrieve a value associated with the context node
`static boolean` `hasSameNodes(Context context, NodeEnumeration p1, NodeEnumeration p2)` Determine whether two node-sets contain the same nodes
`static NodeSetValue` `highest(Context c, NodeEnumeration nsv)` Get the node with maximum numeric value of the string-value of each of a set of nodes
`static NodeEnumeration` `highest(Context context, NodeEnumeration nsv, Expression expression)` Get the maximum numeric value of a stored expression over a set of nodes
`static Value` `IF(Value test, Value thenValue, Value elseValue)` Return the value of the second argument if the first is true, or the third argument otherwise.
`static NodeEnumeration` `intersection(Context c, NodeEnumeration p1, NodeEnumeration p2)` Return the intersection of two node-sets
`static boolean` `isNull(java.lang.Object x)` Test whether an encapsulated Java object is null
`static NodeEnumeration` `leading(Context context, NodeEnumeration in, Expression exp)` Get the nodes that satisfy the given expression, up to and excluding the first one (in document order) that doesn't
`static double` `lineNumber(Context c)` Return the line number of the context node.
`static NodeSetValue` `lowest(Context c, NodeEnumeration nsv)` Get the node with minimum numeric value of the string-value of each of a set of nodes
`static NodeEnumeration` `lowest(Context context, NodeEnumeration nsv, Expression expression)` Get the node with minimum numeric value of a stored expression over a set of nodes
`static double` `max(Context context, NodeEnumeration nsv, Expression expression)` Get the maximum numeric value of a stored expression over a set of nodes
`static double` `max(NodeEnumeration nsv)` Get the maximum numeric value of the string-value of each of a set of nodes
`static double` `min(Context context, NodeEnumeration nsv, Expression expression)` Get the minimum numeric value of a stored expression over a set of nodes
`static double` `min(NodeEnumeration nsv)` Get the minimum numeric value of the string-value of each of a set of nodes
`static NodeSetValue` `nodeset(Context c, Value frag)` Alternative spelling (allows "nodeset()")
`static NodeSetValue` `nodeSet(Context c, Value frag)` Convert a result tree fragment to a node-set.
`static java.lang.String` `path(Context c)` Return an XPath expression that identifies the current node
`static void` `pauseTracing(Context c)`
`static NodeEnumeration` `range(Context context, double start, double finish)` Return a node-set whose nodes have string-values "1", "2", ...
`static void` `resumeTracing(Context c)`
`static void` `setUserData(Context c, java.lang.String name, Value value)` Save a value associated with the context node
`static java.lang.String` `showNodeset(Context c, NodeSetValue in)` A diagnostic function to print the contents of a node-set
`static double` `sum(Context context, NodeEnumeration nsv, Expression expression)` Total a stored expression over a set of nodes
`static java.lang.String` `systemId(Context c)` Return the system identifier of the context node
`static NodeEnumeration` `tokenize(Context context, java.lang.String s)` Return a node-set by tokenizing a supplied string.
`static NodeEnumeration` `tokenize(Context context, java.lang.String s, java.lang.String delim)` Return a node-set by tokenizing a supplied string.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### Extensions

    public Extensions()

Method Detail

### pauseTracing

    public static void pauseTracing(Context c)

### resumeTracing

    public static void resumeTracing(Context c)

### nodeSet

    public static NodeSetValue nodeSet(Context c,
                                       Value frag)
                                throws XPathException

  Convert a result tree fragment to a node-set. This simply marks a result tree fragment as being available for general use.

    `XPathException`

### nodeset

    public static NodeSetValue nodeset(Context c,
                                       Value frag)
                                throws XPathException

  Alternative spelling (allows "nodeset()")

    `XPathException`

### systemId

    public static java.lang.String systemId(Context c)
                                     throws XPathException

  Return the system identifier of the context node

    `XPathException`

### lineNumber

    public static double lineNumber(Context c)
                             throws XPathException

  Return the line number of the context node. This must be returned as a double to meet the calling requirements for extension functions.

    `XPathException`

### baseUri

    public static java.lang.String baseUri(Context c)
                                    throws XPathException

  Return the base URI of the context node

    `XPathException`

### intersection

    public static NodeEnumeration intersection(Context c,
                                               NodeEnumeration p1,
                                               NodeEnumeration p2)
                                        throws XPathException

  Return the intersection of two node-sets

  Parameters:
    `p1` - The first node-set
    `p2` - The second node-set
  Returns:
    A node-set containing all nodes that are in both p1 and p2
    `XPathException`

### difference

    public static NodeEnumeration difference(Context c,
                                             NodeEnumeration p1,
                                             NodeEnumeration p2)
                                      throws XPathException

  Return the difference of two node-sets

  Parameters:
    `p1` - The first node-set
    `p2` - The second node-set
  Returns:
    A node-set containing all nodes that are in p1 and not in p2
    `XPathException`

### hasSameNodes

    public static boolean hasSameNodes(Context context,
                                       NodeEnumeration p1,
                                       NodeEnumeration p2)
                                throws XPathException

  Determine whether two node-sets contain the same nodes

  Parameters:
    `p1` - The first node-set
    `p2` - The second node-set
  Returns:
    true if p1 and p2 contain the same set of nodes
    `XPathException`

### IF

    public static Value IF(Value test,
                           Value thenValue,
                           Value elseValue)
                    throws XPathException

  Return the value of the second argument if the first is true, or the third argument otherwise. Note that all three arguments are evaluated.

  Parameters:
    `test` - A value treated as a boolean
    `thenValue` - Any value
    `elseValue` - Any value
  Returns:
    (test ? thenValue : elseValue)
    `XPathException`

### evaluate

    public static Value evaluate(Context c,
                                 java.lang.String expr)
                          throws XPathException

  Evaluate the expression supplied in the first argument as a string

    `XPathException`

### eval

    public static Value eval(Context c,
                             Expression expr)
                      throws XPathException

  Evaluate the stored expression supplied in the first argument

    `XPathException`

### expression

    public static Value expression(Context c,
                                   java.lang.String expr)
                            throws XPathException

  Return an object representing a stored expression, from the string supplied in the first argument.

    `XPathException`

### sum

    public static double sum(Context context,
                             NodeEnumeration nsv,
                             Expression expression)
                      throws XPathException

  Total a stored expression over a set of nodes

    `XPathException`

### max

    public static double max(NodeEnumeration nsv)
                      throws XPathException

  Get the maximum numeric value of the string-value of each of a set of nodes

    `XPathException`

### max

    public static double max(Context context,
                             NodeEnumeration nsv,
                             Expression expression)
                      throws XPathException

  Get the maximum numeric value of a stored expression over a set of nodes

    `XPathException`

### min

    public static double min(NodeEnumeration nsv)
                      throws XPathException

  Get the minimum numeric value of the string-value of each of a set of nodes

    `XPathException`

### min

    public static double min(Context context,
                             NodeEnumeration nsv,
                             Expression expression)
                      throws XPathException

  Get the minimum numeric value of a stored expression over a set of nodes

    `XPathException`

### highest

    public static NodeSetValue highest(Context c,
                                       NodeEnumeration nsv)
                                throws XPathException

  Get the node with maximum numeric value of the string-value of each of a set of nodes

    `XPathException`

### highest

    public static NodeEnumeration highest(Context context,
                                          NodeEnumeration nsv,
                                          Expression expression)
                                   throws XPathException

  Get the maximum numeric value of a stored expression over a set of nodes

    `XPathException`

### lowest

    public static NodeSetValue lowest(Context c,
                                      NodeEnumeration nsv)
                               throws XPathException

  Get the node with minimum numeric value of the string-value of each of a set of nodes

    `XPathException`

### lowest

    public static NodeEnumeration lowest(Context context,
                                         NodeEnumeration nsv,
                                         Expression expression)
                                  throws XPathException

  Get the node with minimum numeric value of a stored expression over a set of nodes

    `XPathException`

### distinct

    public static NodeEnumeration distinct(Context context,
                                           NodeEnumeration in)
                                    throws XPathException

  Given a node-set, return a subset that includes only nodes with distinct string-values

    `XPathException`

### distinct

    public static NodeEnumeration distinct(Context context,
                                           NodeEnumeration in,
                                           Expression exp)
                                    throws XPathException

  Given a node-set, return a subset that includes only nodes with distinct string-values for the supplied expression

    `XPathException`

### closure

    public static NodeEnumeration closure(Context c,
                                          NodeEnumeration enum,
                                          Expression expr)
                                   throws XPathException

  Evaluate the transitive closure of a node-set expression

    `XPathException`

### leading

    public static NodeEnumeration leading(Context context,
                                          NodeEnumeration in,
                                          Expression exp)
                                   throws XPathException

  Get the nodes that satisfy the given expression, up to and excluding the first one (in document order) that doesn't

    `XPathException`

### before

    public static NodeSetValue before(Context context,
                                      NodeSetValue ns1,
                                      NodeSetValue ns2)
                               throws XPathException

  Find all the nodes in ns1 that are before the last node in ns2. Return empty set if ns2 is empty,

    `XPathException`

### after

    public static NodeSetValue after(Context context,
                                     NodeSetValue ns1,
                                     NodeSetValue ns2)
                              throws XPathException

  Find all the nodes in ns1 that are after the first node in ns2. Return empty set if ns2 is empty,

    `XPathException`

### exists

    public static boolean exists(Context context,
                                 NodeEnumeration nsv,
                                 Expression expression)
                          throws XPathException

  Test whether node-set contains a node that satisfies a given condition

    `XPathException`

### forAll

    public static boolean forAll(Context context,
                                 NodeEnumeration nsv,
                                 Expression expression)
                          throws XPathException

  Test whether all nodes in a node-set satisfy a given condition

    `XPathException`

### range

    public static NodeEnumeration range(Context context,
                                        double start,
                                        double finish)
                                 throws XPathException

  Return a node-set whose nodes have string-values "1", "2", ... "n"

    `XPathException`

### tokenize

    public static NodeEnumeration tokenize(Context context,
                                           java.lang.String s)
                                    throws XPathException

  Return a node-set by tokenizing a supplied string. Tokens are delimited by any sequence of whitespace characters.

    `XPathException`

### tokenize

    public static NodeEnumeration tokenize(Context context,
                                           java.lang.String s,
                                           java.lang.String delim)
                                    throws XPathException

  Return a node-set by tokenizing a supplied string. The argument delim is a String, any character in this string is considered to be a delimiter character, and any sequence of delimiter characters acts as a separator between tokens.

    `XPathException`

### path

    public static java.lang.String path(Context c)
                                 throws XPathException

  Return an XPath expression that identifies the current node

    `XPathException`

### showNodeset

    public static java.lang.String showNodeset(Context c,
                                               NodeSetValue in)
                                        throws XPathException

  A diagnostic function to print the contents of a node-set

    `XPathException`

### isNull

    public static boolean isNull(java.lang.Object x)
                          throws XPathException

  Test whether an encapsulated Java object is null

    `XPathException`

### setUserData

    public static void setUserData(Context c,
                                   java.lang.String name,
                                   Value value)
                            throws XPathException

  Save a value associated with the context node

    `XPathException`

### getUserData

    public static Value getUserData(Context c,
                                    java.lang.String name)
                             throws XPathException

  Retrieve a value associated with the context node

    `XPathException`

### getContext

    public static Context getContext(Context c)

  Return the Context object

### getPseudoAttribute

    public static java.lang.String getPseudoAttribute(Context c,
                                                      java.lang.String name)

  Get a pseudo-attribute of a processing instruction. Return an empty string if the context node is not a processing instruction, or if the pseudo-attribute is not present. Character references and built-in entity references are expanded