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

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected StaticContext` | `staticContext`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Expression()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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 javax.xml.transform.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:
        `javax.xml.transform.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