## com.icl.saxon.expr
Class Expression

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

Direct Known Subclasses:
  AttributeValueTemplate, ErrorExpression, Function, IsLastExpression, NodeSetComparison, NodeSetExpression, SingletonComparison, Value, VariableReference

public abstract class Expression
extends java.lang.Object

This class serves two purposes: it is an abstract superclass for different kinds of XPath expression, and it contains a static method to invoke the expression parser

Field Summary
`protected StaticContext` `staticContext`

Constructor Summary
`Expression()`

Method Summary
`boolean` `containsReferences()` Determine whether the expression contains any references to variables
`abstract void` `display(int level)` Diagnostic print of expression structure
`NodeEnumeration` `enumerate(Context context, boolean sorted)` Return an enumeration of nodes in a nodeset.
`abstract Value` `evaluate(Context context)` Evaluate an expression.
`boolean` `evaluateAsBoolean(Context context)` Evaluate an expression as a Boolean. The result of x.evaluateAsBoolean(c) must be equivalent to x.evaluate(c).asBoolean(); but optimisations are possible when it is known that a boolean result is required, especially in the case of a NodeSet.
`NodeSetValue` `evaluateAsNodeSet(Context context)` Evaluate an expression as a NodeSet.
`double` `evaluateAsNumber(Context context)` Evaluate an expression as a Number. The result of x.evaluateAsNumber(c) must be equivalent to x.evaluate(c).asNumber(); but optimisations are possible when it is known that a numeric result is required, especially in the case of a NodeSet.
`java.lang.String` `evaluateAsString(Context context)` Evaluate an expression as a String. The result of x.evaluateAsString(c) must be equivalent to x.evaluate(c).asString(); but optimisations are possible when it is known that a string result is required, especially in the case of a NodeSet.
`abstract int` `getDataType()` Determine the data type of the expression, if possible
`abstract int` `getDependencies()` Determine which aspects of the context the expression depends on.
`StaticContext` `getStaticContext()` Determine the static context used when the expression was parsed
`protected static java.lang.String` `indent(int level)` Construct indent string, for diagnostic output
`boolean` `isContextDocumentNodeSet()` Determine, in the case of an expression whose data type is Value.NODESET, whether all the nodes in the node-set are guaranteed to come from the same document as the context node.
`static Expression` `make(java.lang.String expression, StaticContext env)` Parse an expression
`void` `outputStringValue(Outputter out, Context context)` Evaluate an expression as a String and write the result to the specified outputter.
`abstract Expression` `reduce(int dependencies, Context context)` Perform a partial evaluation of the expression, by eliminating specified dependencies on the context.
`void` `setStaticContext(StaticContext sc)` Set the static context used when the expression was parsed
`Expression` `simplify()` Simplify an expression.
`boolean` `usesCurrent()` Determine whether the expression uses the current() function.

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

Field Detail

### staticContext

    protected StaticContext staticContext

Constructor Detail

### Expression

    public Expression()

Method Detail

### make

    public static Expression make(java.lang.String expression,
                                  StaticContext env)
                           throws XPathException

  Parse an expression

  Parameters:
    `expression` - The expression (as a character string)
    `env` - An object giving information about the compile-time context of the expression
  Returns:
    an object of type Expression
  Throws:
    `XPathException`

### simplify

    public Expression simplify()
                        throws XPathException

  Simplify an expression. Default implementation does nothing.

  Returns:
    the simplified expression
  Throws:
    `XPathException`

### setStaticContext

    public final void setStaticContext(StaticContext sc)

  Set the static context used when the expression was parsed

### getStaticContext

    public final StaticContext getStaticContext()

  Determine the static context used when the expression was parsed

### containsReferences

    public boolean containsReferences()
                               throws XPathException

  Determine whether the expression contains any references to variables

  Returns:
    true if so
  Throws:
    `XPathException`

### evaluate

    public abstract Value evaluate(Context context)
                            throws XPathException

  Evaluate an 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`

### evaluateAsBoolean

    public boolean evaluateAsBoolean(Context context)
                              throws XPathException

  Evaluate an expression as a Boolean.
  The result of x.evaluateAsBoolean(c) must be equivalent to x.evaluate(c).asBoolean(); but optimisations are possible when it is known that a boolean result is required, especially in the case of a NodeSet.

  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`

### evaluateAsNumber

    public double evaluateAsNumber(Context context)
                            throws XPathException

  Evaluate an expression as a Number.
  The result of x.evaluateAsNumber(c) must be equivalent to x.evaluate(c).asNumber(); but optimisations are possible when it is known that a numeric result is required, especially in the case of a NodeSet.

  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`

### evaluateAsString

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

  Evaluate an expression as a String.
  The result of x.evaluateAsString(c) must be equivalent to x.evaluate(c).asString(); but optimisations are possible when it is known that a string result is required, especially in the case of a NodeSet.

  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`

### outputStringValue

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

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

  Parameters:
    `out` - The required outputter
    `context` - The context in which the expression is to be evaluated
  Throws:
    `TransformerException`

### evaluateAsNodeSet

    public NodeSetValue evaluateAsNodeSet(Context context)
                                   throws XPathException

  Evaluate an expression as a NodeSet.

  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the value of the expression, evaluated in the current context. Note that the result is not necessarily in document order; to get it into document order, call sort() on the result.
  Throws:
    `XPathException` - when the expression does not return a nodeset.

### enumerate

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

  Return an enumeration of nodes in a nodeset.

  Parameters:
    `context` - The context in which the expression is to be evaluated
    `sorted` - Indicates whether the nodes are required in document order. If this is false, they may come in any order, but there will be no duplicates.
  Throws:
    `XPathException` - when the expression does not return a nodeset.

### getDataType

    public abstract int getDataType()

  Determine the data type of the expression, if possible

  Returns:
    one of the values Value.STRING, Value.BOOLEAN, Value.NUMBER, Value.NODESET, Value.FRAGMENT, or Value.ANY (meaning not known in advance)

### isContextDocumentNodeSet

    public boolean isContextDocumentNodeSet()

  Determine, in the case of an expression whose data type is Value.NODESET, whether all the nodes in the node-set are guaranteed to come from the same document as the context node. Used for optimization.

### usesCurrent

    public boolean usesCurrent()

  Determine whether the expression uses the current() function. This is an error if the expression is within a pattern

### getDependencies

    public abstract int getDependencies()

  Determine which aspects of the context the expression depends on. The result is a bitwise-or'ed value composed from constants such as Context.VARIABLES and Context.CURRENT_NODE

### reduce

    public abstract Expression reduce(int dependencies,
                                      Context context)
                               throws XPathException

  Perform a partial evaluation of the expression, by eliminating specified dependencies on the context.

  Parameters:
    `dependencies` - The dependencies to be removed, e.g. Context.VARIABLES
    `context` - The context to be used for the partial evaluation
  Returns:
    a new expression (or Value) that does not have any of the specified dependencies
  Throws:
    `XPathException`

### display

    public abstract void display(int level)

  Diagnostic print of expression structure

### indent

    protected static java.lang.String indent(int level)

  Construct indent string, for diagnostic output