Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.sun.el
Class ValueExpressionImpl

    java.lang.Object
      javax.el.Expression
          javax.el.ValueExpression
              com.sun.el.ValueExpressionImpl

All Implemented Interfaces:
  Externalizable, Serializable

    public final class ValueExpressionImpl

extends ValueExpression
implements Externalizable

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.

Version:
  $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author: tcfujii $
Author:
  Jacob Hookom [jacob@hookom.net]
See Also:
  `ELResolver`, `Expression`, `ExpressionFactory`, `ValueExpression`, Serialized Form

Constructor Summary
`ValueExpressionImpl()`
`ValueExpressionImpl(String expr, Node node, FunctionMapper fnMapper, VariableMapper varMapper, Class expectedType)`

Method Summary
`boolean` | `equals(Object obj)` Determines whether the specified object is equal to this `Expression`.
`Class` | `getExpectedType()` Returns the type the result of the expression will be coerced to after evaluation.
`String` | `getExpressionString()` Returns the type the result of the expression will be coerced to after evaluation.
`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 `ValueExpression.setValue(javax.el.ELContext, java.lang.Object)` method.
`Object` | `getValue(ELContext context)` Evaluates the expression relative to the provided context, and returns the resulting value.
`int` | `hashCode()` Returns the hash code for this `Expression`.
`boolean` | `isLiteralText()` Returns whether this expression was created from only literal text.
`boolean` | `isReadOnly(ELContext context)` Evaluates the expression relative to the provided context, and returns `true` if a call to `ValueExpression.setValue(javax.el.ELContext, java.lang.Object)` will always fail.
`void` | `readExternal(ObjectInput in)`
`void` | `setValue(ELContext context, Object value)` Evaluates the expression relative to the provided context, and sets the result to the provided value.
`String` | `toString()`
`void` | `writeExternal(ObjectOutput out)`

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

Constructor Detail

### ValueExpressionImpl

    public ValueExpressionImpl()

### ValueExpressionImpl

    public ValueExpressionImpl(String expr,
                               Node node,
                               FunctionMapper fnMapper,
                               VariableMapper varMapper,
                               Class expectedType)

Method Detail

### equals

    public boolean equals(Object obj)

  Description copied from class: `Expression`
  Determines whether the specified object is equal to this `Expression`.

  The result is `true` if and only if the argument is not `null`, is an `Expression` object that is the of the same type (`ValueExpression` or `MethodExpression`), and has an identical parsed representation.

  Note that two expressions can be equal if their expression Strings are different. For example, `${fn1:foo()}` and `${fn2:foo()}` are equal if their corresponding `FunctionMapper`s mapped `fn1:foo` and `fn2:foo` to the same method.

  Specified by:
    `equals` in class `Expression`
  Parameters:
    `obj` - the `Object` to test for equality.
  Returns:
    `true` if `obj` equals this `Expression`; `false` otherwise.
  See Also:
    `Hashtable`, `Object.equals(java.lang.Object)`

### getExpectedType

    public Class getExpectedType()

  Description copied from class: `ValueExpression`
  Returns the type the result of the expression will be coerced to after evaluation.

  Specified by:
    `getExpectedType` in class `ValueExpression`
  Returns:
    the `expectedType` passed to the `ExpressionFactory.createValueExpression` method that created this `ValueExpression`.

### getExpressionString

    public String getExpressionString()

  Returns the type the result of the expression will be coerced to after evaluation.

  Specified by:
    `getExpressionString` in class `Expression`
  Returns:
    the `expectedType` passed to the `ExpressionFactory.createValueExpression` method that created this `ValueExpression`.
  See Also:
    `Expression.getExpressionString()`

### getType

    public Class getType(ELContext context)
                  throws PropertyNotFoundException,
                         ELException

  Description copied from class: `ValueExpression`
  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 `ValueExpression.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.

  Specified by:
    `getType` in class `ValueExpression`
  Parameters:
    `context` - The context of this evaluation.
  Returns:
    the most general acceptable type; otherwise undefined.
  Throws:
    `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.

### getValue

    public Object getValue(ELContext context)
                    throws PropertyNotFoundException,
                           ELException

  Description copied from class: `ValueExpression`
  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.

  Specified by:
    `getValue` in class `ValueExpression`
  Parameters:
    `context` - The context of this evaluation.
  Returns:
    The result of the expression evaluation.
  Throws:
    `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.

### hashCode

    public int hashCode()

  Description copied from class: `Expression`
  Returns the hash code for this `Expression`.

  See the note in the `Expression.equals(java.lang.Object)` method on how two expressions can be equal if their expression Strings are different. Recall that if two objects are equal according to the `equals(Object)` method, then calling the `hashCode` method on each of the two objects must produce the same integer result. Implementations must take special note and implement `hashCode` correctly.

  Specified by:
    `hashCode` in class `Expression`
  Returns:
    The hash code for this `Expression`.
  See Also:
    `Expression.equals(java.lang.Object)`, `Hashtable`, `Object.hashCode()`

### isLiteralText

    public boolean isLiteralText()

  Description copied from class: `Expression`
  Returns whether this expression was created from only literal text.

  This method must return `true` if and only if the expression string this expression was created from contained no unescaped EL delimeters (`${...}` or `#{...}`).

  Specified by:
    `isLiteralText` in class `Expression`
  Returns:
    `true` if this expression was created from only literal text; `false` otherwise.

### isReadOnly

    public boolean isReadOnly(ELContext context)
                       throws PropertyNotFoundException,
                              ELException

  Description copied from class: `ValueExpression`
  Evaluates the expression relative to the provided context, and returns `true` if a call to `ValueExpression.setValue(javax.el.ELContext, java.lang.Object)` will always fail.

  Specified by:
    `isReadOnly` in class `ValueExpression`
  Parameters:
    `context` - The context of this evaluation.
  Returns:
    `true` if the expression is read-only or `false` if not.
  Throws:
    `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`

### readExternal

    public void readExternal(ObjectInput in)
                      throws IOException,
                             ClassNotFoundException

  Specified by:
    `readExternal` in interface `Externalizable`
  Throws:
    `IOException`
    `ClassNotFoundException`

### setValue

    public void setValue(ELContext context,
                         Object value)
                  throws PropertyNotFoundException,
                         PropertyNotWritableException,
                         ELException

  Description copied from class: `ValueExpression`
  Evaluates the expression relative to the provided context, and sets the result to the provided value.

  Specified by:
    `setValue` in class `ValueExpression`
  Parameters:
    `context` - The context of this evaluation.
    `value` - The new value to be set.
  Throws:
    `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.

### writeExternal

    public void writeExternal(ObjectOutput out)
                       throws IOException

  Specified by:
    `writeExternal` in interface `Externalizable`
  Throws:
    `IOException`

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2007 Mort Bay Consulting. All Rights Reserved.