javax.el

## Class ValueExpression

- java.lang.Object
- - javax.el.Expression
  - - javax.el.ValueExpression

- All Implemented Interfaces:
    Serializable
  Direct Known Subclasses:
    IndexedValueExpression, IteratedValueExpression

      public abstract class ValueExpression
      extends Expression

  An `Expression` that can get or set a value.

  In previous incarnations of this API, expressions could only be read. `ValueExpression` objects can now be used both to retrieve a value and to set a value. Expressions that can have a value set on them are referred to as l-value expressions. Those that cannot are referred to as r-value expressions. Not all r-value expressions can be used as l-value expressions (e.g. `"${1+1}"` or `"${firstName} ${lastName}"`). See the EL Specification for details. Expressions that cannot be used as l-values must always return `true` from `isReadOnly()`.

  The ``ExpressionFactory.createValueExpression(javax.el.ELContext, java.lang.String, java.lang.Class<?>)`` method can be used to parse an expression string and return a concrete instance of `ValueExpression` that encapsulates the parsed expression. The `FunctionMapper` is used at parse time, not evaluation time, so one is not needed to evaluate an expression using this class. However, the `ELContext` is needed at evaluation time.

  The `getValue(javax.el.ELContext)`, `setValue(javax.el.ELContext, java.lang.Object)`, `isReadOnly(javax.el.ELContext)`, `getType(javax.el.ELContext)` and `getValueReference(javax.el.ELContext)` methods will evaluate the expression each time they are called. The `ELResolver` in the `ELContext` is used to resolve the top-level variables and to determine the behavior of the `.` and `[]` operators. For any of the five methods, the `ELResolver.getValue(javax.el.ELContext, java.lang.Object, java.lang.Object)` method is used to resolve all properties up to but excluding the last one. This provides the `base` object. For all methods other than the `getValueReference(javax.el.ELContext)` method, at the last resolution, the `ValueExpression` will call the corresponding `ELResolver.getValue(javax.el.ELContext, java.lang.Object, java.lang.Object)`, `ELResolver.setValue(javax.el.ELContext, java.lang.Object, java.lang.Object, java.lang.Object)`, `ELResolver.isReadOnly(javax.el.ELContext, java.lang.Object, java.lang.Object)` or `ELResolver.getType(javax.el.ELContext, java.lang.Object, java.lang.Object)` method, depending on which was called on the `ValueExpression`. For the `getValueReference(javax.el.ELContext)` method, the (base, property) is not resolved by the ELResolver, but an instance of `ValueReference` is created to encapsulate this (base ,property), and returned.

  See the notes about comparison, serialization and immutability in the `Expression` javadocs.

  Since:
    JSP 2.1
  See Also:
    `ELResolver`, `Expression`, `ExpressionFactory`, Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ValueExpression()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `abstract Class<?>` | `getExpectedType()` Returns the type the result of the expression will be coerced to after evaluation.
    `abstract Class<?>` | `getType(ELContext context)` Evaluates the expression relative to the provided context, and returns the most general type that is acceptable for an object to be passed as the `value` parameter in a future call to the `setValue(javax.el.ELContext, java.lang.Object)` method.
    `abstract Object` | `getValue(ELContext context)` Evaluates the expression relative to the provided context, and returns the resulting value.
    `ValueReference` | `getValueReference(ELContext context)` Returns a `ValueReference` for this expression instance.
    `abstract boolean` | `isReadOnly(ELContext context)` Evaluates the expression relative to the provided context, and returns `true` if a call to `setValue(javax.el.ELContext, java.lang.Object)` will always fail.
    `abstract void` | `setValue(ELContext context, Object value)` Evaluates the expression relative to the provided context, and sets the result to the provided value.

    - ### Methods inherited from class javax.el.Expression

      `equals, getExpressionString, hashCode, isLiteralText`

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

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

- - ### Constructor Detail

    - #### ValueExpression

          public ValueExpression()

  - ### Method Detail

    - #### getValue

          public abstract Object getValue(ELContext context)

      Evaluates the expression relative to the provided context, and returns the resulting value.

      The resulting value is automatically coerced to the type returned by `getExpectedType()`, which was provided to the `ExpressionFactory` when this expression was created.

      Parameters:
        `context` - The context of this evaluation.
      Returns:
        The result of the expression evaluation.
      Throws:
        `NullPointerException` - if context is `null`.
        `PropertyNotFoundException` - if one of the property resolutions failed because a specified variable or property does not exist or is not readable.
        `ELException` - if an exception was thrown while performing property or variable resolution. The thrown exception must be included as the cause property of this exception, if available.

    - #### setValue

          public abstract void setValue(ELContext context,
                      Object value)

      Evaluates the expression relative to the provided context, and sets the result to the provided value.
      Parameters:
        `context` - The context of this evaluation.
        `value` - The new value to be set.
      Throws:
        `NullPointerException` - if context is `null`.
        `PropertyNotFoundException` - if one of the property resolutions failed because a specified variable or property does not exist or is not readable.
        `PropertyNotWritableException` - if the final variable or property resolution failed because the specified variable or property is not writable.
        `ELException` - if an exception was thrown while attempting to set the property or variable. The thrown exception must be included as the cause property of this exception, if available.

    - #### isReadOnly

          public abstract boolean isReadOnly(ELContext context)

      Evaluates the expression relative to the provided context, and returns `true` if a call to `setValue(javax.el.ELContext, java.lang.Object)` will always fail.
      Parameters:
        `context` - The context of this evaluation.
      Returns:
        `true` if the expression is read-only or `false` if not.
      Throws:
        `NullPointerException` - if context is `null`.
        `PropertyNotFoundException` - if one of the property resolutions failed because a specified variable or property does not exist or is not readable.
        `ELException` - if an exception was thrown while performing property or variable resolution. The thrown exception must be included as the cause property of this exception, if available. * @throws NullPointerException if context is `null`

    - #### getType

          public abstract Class<?> getType(ELContext context)

      Evaluates the expression relative to the provided context, and returns the most general type that is acceptable for an object to be passed as the `value` parameter in a future call to the `setValue(javax.el.ELContext, java.lang.Object)` method.

      This is not always the same as `getValue().getClass()`. For example, in the case of an expression that references an array element, the `getType` method will return the element type of the array, which might be a superclass of the type of the actual element that is currently in the specified array element.

      Parameters:
        `context` - The context of this evaluation.
      Returns:
        the most general acceptable type; otherwise undefined.
      Throws:
        `NullPointerException` - if context is `null`.
        `PropertyNotFoundException` - if one of the property resolutions failed because a specified variable or property does not exist or is not readable.
        `ELException` - if an exception was thrown while performing property or variable resolution. The thrown exception must be included as the cause property of this exception, if available.

    - #### getExpectedType

          public abstract Class<?> getExpectedType()

      Returns the type the result of the expression will be coerced to after evaluation.
      Returns:
        the `expectedType` passed to the `ExpressionFactory.createValueExpression` method that created this `ValueExpression`.

    - #### getValueReference

          public ValueReference getValueReference(ELContext context)

      Returns a `ValueReference` for this expression instance.
      Parameters:
        `context` - the context of this evaluation
      Returns:
        the `ValueReference` for this `ValueExpression`, or `null` if this `ValueExpression` is not a reference to a base (null or non-null) and a property. If the base is null, and the property is a EL variable, return the `ValueReference` for the `ValueExpression` associated with this EL variable.
      Since:
        EL 2.2

Copyright © 1996-2013, Oracle and/or its affiliates. All Rights Reserved. Use is subject to license terms.