## javax.el
Class ValueExpression

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

All Implemented Interfaces:
  Serializable

Direct Known Subclasses:
  IndexedValueExpression, IteratedValueExpression, ValueExpressionImpl, ValueExpressionLiteral

    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)` and `getType(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 four 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. 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`.

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
`ValueExpression()`

Method Summary
`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.
`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`.

Copyright © 2008 Mort Bay Consulting. All Rights Reserved.