com.icl.saxon.expr

## Class Value

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

- Direct Known Subclasses:
    BooleanValue, NodeSetValue, NumericValue, ObjectValue, StringValue

      public abstract class Value
      extends Expression

  A value is the result of an expression but it is also an expression in its own right

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `ANY`
    `static int` | `BOOLEAN` Constants denoting the data types of an expression or value
    `static int` | `NODESET`
    `static int` | `NUMBER`
    `static int` | `OBJECT`
    `static int` | `STRING`

    - ### Fields inherited from class com.icl.saxon.expr.Expression

      `staticContext`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Value()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `abstract boolean` | `asBoolean()` Convert the value to a Boolean
    `abstract double` | `asNumber()` Convert the value to a Number
    `abstract java.lang.String` | `asString()` Convert the value to a String value
    `boolean` | `compare(int operator, Value other)` Test how a Value compares to another Value under a relational comparison.
    `abstract int` | `conversionPreference(java.lang.Class required)` Get conversion preference for this value to a Java class.
    `abstract java.lang.Object` | `convertToJava(java.lang.Class target)` Convert to Java object (for passing to external functions)
    `boolean` | `equals(Value other)` Test whether two values are equal.
    `Value` | `evaluate(Context context)` Evaluate the Value.
    `int` | `getDependencies()` Determine which aspects of the context the expression depends on.
    `protected static int` | `inverse(int operator)` Return the inverse of a relational operator, so that "a op b" can be rewritten as "b inverse(op) a"
    `boolean` | `notEquals(Value other)` Test whether two values are not-equal.
    `protected boolean` | `numericCompare(int operator, double x, double y)`
    `Expression` | `reduce(int dependencies, Context context)` Perform a partial evaluation of the expression, by eliminating specified dependencies on the context.
    `Expression` | `simplify()` Simplify an expression
    `static double` | `stringToNumber(java.lang.String s)` Static method to convert strings to numbers.

    - ### Methods inherited from class com.icl.saxon.expr.Expression

      `containsReferences, display, enumerate, evaluateAsBoolean, evaluateAsNodeSet, evaluateAsNumber, evaluateAsString, getDataType, getStaticContext, indent, isContextDocumentNodeSet, make, outputStringValue, setStaticContext, usesCurrent`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### BOOLEAN

          public static final int BOOLEAN

      Constants denoting the data types of an expression or value
      See Also:
        Constant Field Values

    - #### NUMBER

          public static final int NUMBER

      See Also:
        Constant Field Values

    - #### STRING

          public static final int STRING

      See Also:
        Constant Field Values

    - #### NODESET

          public static final int NODESET

      See Also:
        Constant Field Values

    - #### OBJECT

          public static final int OBJECT

      See Also:
        Constant Field Values

    - #### ANY

          public static final int ANY

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### Value

          public Value()

  - ### Method Detail

    - #### stringToNumber

          public static double stringToNumber(java.lang.String s)

      Static method to convert strings to numbers. Might as well go here as anywhere else.
      Parameters:
        `s` - the String to be converted
      Returns:
        a double representing the value of the String; if it cannot be converted, return NaN (as required by the XSL specification)

    - #### evaluate

          public Value evaluate(Context context)
                         throws XPathException

      Evaluate the Value. Null operation, because it has already been evaluated
      Specified by:
        `evaluate` in class `Expression`
      Parameters:
        `context` - The context (not used)
      Returns:
        the value, unchanged
      Throws:
        `XPathException`

    - #### simplify

          public Expression simplify()

      Simplify an expression
      Overrides:
        `simplify` in class `Expression`
      Returns:
        the simplified expression

    - #### getDependencies

          public 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
      Specified by:
        `getDependencies` in class `Expression`

    - #### asString

          public abstract java.lang.String asString()
                                             throws XPathException

      Convert the value to a String value
      Returns:
        the value converted to a String
      Throws:
        `XPathException`

    - #### asNumber

          public abstract double asNumber()
                                   throws XPathException

      Convert the value to a Number
      Returns:
        the value converted to a String
      Throws:
        `XPathException`

    - #### asBoolean

          public abstract boolean asBoolean()
                                     throws XPathException

      Convert the value to a Boolean
      Returns:
        the value converted to a Boolean
      Throws:
        `XPathException`

    - #### equals

          public boolean equals(Value other)
                         throws XPathException

      Test whether two values are equal. See the XSL specification: if either operand is a nodeset, they are compared as nodesets; else if either is a boolean, they are compared as booleans; else if either operand is a number, they are compared as numbers; else they are compared as strings.
      Returns:
        a boolean giving the value of the expression, evaluated in the current context
      Throws:
        `XPathException`

    - #### notEquals

          public boolean notEquals(Value other)
                            throws XPathException

      Test whether two values are not-equal. Note that a!=b means the same as !(a=b) except where either a or b is a nodeset.
      Returns:
        a boolean giving the value of the expression, evaluated in the current context
      Throws:
        `XPathException`

    - #### compare

          public boolean compare(int operator,
                        Value other)
                          throws XPathException

      Test how a Value compares to another Value under a relational comparison. Note that the method is overridden for NodeSetValue
      Parameters:
        `operator` - The comparison operator, one of Tokenizer.LE, Tokenizer.LT, Tokenizer.GE, Tokenizer.GT, Tokenizer.EQUALS, Tokenizer.NE.
      Throws:
        `XPathException`

    - #### inverse

          protected static final int inverse(int operator)

      Return the inverse of a relational operator, so that "a op b" can be rewritten as "b inverse(op) a"

    - #### numericCompare

          protected final boolean numericCompare(int operator,
                               double x,
                               double y)

    - #### reduce

          public Expression reduce(int dependencies,
                          Context context)

      Perform a partial evaluation of the expression, by eliminating specified dependencies on the context.
      Specified by:
        `reduce` in class `Expression`
      Parameters:
        `dependencies` - The dependencies to be removed
        `context` - The context to be used for the partial evaluation
      Returns:
        a new expression that does not have any of the specified dependencies

    - #### convertToJava

          public abstract java.lang.Object convertToJava(java.lang.Class target)
                                                  throws XPathException

      Convert to Java object (for passing to external functions)
      Parameters:
        `target` - The class required by the external function
      Returns:
        an object of the target class
      Throws:
        `XPathException`

    - #### conversionPreference

          public abstract int conversionPreference(java.lang.Class required)

      Get conversion preference for this value to a Java class. A low result indicates higher preference.