## com.icl.saxon.expr
Class NodeSetExpression

    java.lang.Object
      com.icl.saxon.expr.Expression
          com.icl.saxon.expr.NodeSetExpression

Direct Known Subclasses:
  NodeListExpression, PathExpression, SingletonExpression, SortedSelection

public abstract class NodeSetExpression
extends Expression

A NodeSetExpression is any expression denoting a set of nodes.
This is an abstract class, the methods are defaults which may be overridden in subclasses

Field Summary

Fields inherited from class com.icl.saxon.expr.Expression
`staticContext`

Constructor Summary
`NodeSetExpression()`

Method Summary
`abstract NodeEnumeration` `enumerate(Context context, boolean sorted)` Return a node enumeration.
`Value` `evaluate(Context context)` Evaluate this node-set.
`boolean` `evaluateAsBoolean(Context context)` Evaluate as a boolean.
`NodeSetValue` `evaluateAsNodeSet(Context context)` Evaluate an expression as a NodeSet.
`java.lang.String` `evaluateAsString(Context context)` Evaluate as a string.
`int` `getDataType()` Determine the data type of the exprssion, if possible
`void` `outputStringValue(Outputter out, Context context)` Evaluate an expression as a String and write the result to the specified outputter.
`NodeInfo` `selectFirst(Context context)` Return the first node selected by this Expression when evaluated in the current context

Methods inherited from class com.icl.saxon.expr.Expression
`containsReferences, display, evaluateAsNumber, getDependencies, getStaticContext, indent, isContextDocumentNodeSet, make, reduce, setStaticContext, simplify, usesCurrent`

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

Constructor Detail

### NodeSetExpression

    public NodeSetExpression()

Method Detail

### enumerate

    public abstract NodeEnumeration enumerate(Context context,
                                              boolean sorted)
                                       throws XPathException

  Return a node enumeration. All NodeSetExpressions must implement this method: the evaluate() function is defined in terms of it. (But note that some expressions that return node-sets are not NodeSetExpressions: for example functions such as key(), id(), and document() are not, and neither are variable references).

  Overrides:
    `enumerate` in class `Expression`
  Parameters:
    `context` - The evaluation context
    `sorted` - True if the nodes must be returned in document order
  Throws:
    `XPathException` - when the expression does not return a nodeset.

### evaluate

    public Value evaluate(Context context)
                   throws XPathException

  Evaluate this node-set. This doesn't actually retrieve all the nodes: it returns a wrapper around a node-set expression in which all context dependencies have been eliminated.

  Specified by:
    `evaluate` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the value of the expression, evaluated in the current context
  Throws:
    `XPathException`

### selectFirst

    public NodeInfo selectFirst(Context context)
                         throws XPathException

  Return the first node selected by this Expression when evaluated in the current context

  Parameters:
    `context` - The context for the evaluation
  Returns:
    the NodeInfo of the first node in document order, or null if the node-set is empty.
  Throws:
    `XPathException`

### evaluateAsString

    public java.lang.String evaluateAsString(Context context)
                                      throws XPathException

  Evaluate as a string. Returns the string value of the first node selected by the NodeSetExpression

  Overrides:
    `evaluateAsString` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the value of the NodeSetExpression, evaluated in the current context
  Throws:
    `XPathException`

### outputStringValue

    public void outputStringValue(Outputter out,
                                  Context context)
                           throws TransformerException

  Evaluate an expression as a String and write the result to the specified outputter.

  Overrides:
    `outputStringValue` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
    `out` - The required outputter
  Returns:
    the value of the expression, evaluated in the current context
  Throws:
    `TransformerException`

### evaluateAsBoolean

    public boolean evaluateAsBoolean(Context context)
                              throws XPathException

  Evaluate as a boolean. Returns true if there are any nodes selected by the NodeSetExpression

  Overrides:
    `evaluateAsBoolean` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    true if there are any nodes selected by the NodeSetExpression
  Throws:
    `XPathException`

### evaluateAsNodeSet

    public NodeSetValue evaluateAsNodeSet(Context context)
                                   throws XPathException

  Evaluate an expression as a NodeSet.

  Overrides:
    `evaluateAsNodeSet` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the value of the expression, evaluated in the current context
  Throws:
    `XPathException` - when the expression does not return a nodeset.

### getDataType

    public int getDataType()

  Determine the data type of the exprssion, if possible

  Specified by:
    `getDataType` in class `Expression`
  Returns:
    Value.NODESET