FileDocCategorySizeDatePackage
ValueExpressionImpl.javaAPI DocApache Tomcat 6.0.148922Fri Jul 20 04:20:32 BST 2007org.apache.el

ValueExpressionImpl

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 {@link ExpressionFactory#createValueExpression} method can be used to parse an expression string and return a concrete instance of ValueExpression that encapsulates the parsed expression. The {@link FunctionMapper} is used at parse time, not evaluation time, so one is not needed to evaluate an expression using this class. However, the {@link ELContext} is needed at evaluation time.

The {@link #getValue}, {@link #setValue}, {@link #isReadOnly} and {@link #getType} methods will evaluate the expression each time they are called. The {@link 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 {@link ELResolver#getValue} 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 {@link ELResolver#getValue}, {@link ELResolver#setValue}, {@link ELResolver#isReadOnly} or {@link ELResolver#getType} method, depending on which was called on the ValueExpression.

See the notes about comparison, serialization and immutability in the {@link Expression} javadocs.

see
javax.el.ELResolver
see
javax.el.Expression
see
javax.el.ExpressionFactory
see
javax.el.ValueExpression
author
Jacob Hookom [jacob@hookom.net]
version
$Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author: markt $

(Omit source code)

Fields Summary
private Class
expectedType
private String
expr
private FunctionMapper
fnMapper
private VariableMapper
varMapper
private transient org.apache.el.parser.Node
node
Constructors Summary
public ValueExpressionImpl()
public ValueExpressionImpl(String expr, org.apache.el.parser.Node node, FunctionMapper fnMapper, VariableMapper varMapper, Class expectedType)

        this.expr = expr;
        this.node = node;
        this.fnMapper = fnMapper;
        this.varMapper = varMapper;
        this.expectedType = expectedType;
Methods Summary
public booleanequals(java.lang.Object obj)

        return (obj instanceof ValueExpressionImpl && obj.hashCode() == this
                .hashCode());
public java.lang.ClassgetExpectedType()

        return this.expectedType;
public java.lang.StringgetExpressionString()
Returns the type the result of the expression will be coerced to after evaluation.

return
the expectedType passed to the ExpressionFactory.createValueExpression method that created this ValueExpression.
see
javax.el.Expression#getExpressionString()

        return this.expr;
private org.apache.el.parser.NodegetNode()

return
throws
ELException

        if (this.node == null) {
            this.node = ExpressionBuilder.createNode(this.expr);
        }
        return this.node;
public java.lang.ClassgetType(javax.el.ELContext context)

        EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
                this.varMapper);
        return this.getNode().getType(ctx);
public java.lang.ObjectgetValue(javax.el.ELContext context)

        EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
                this.varMapper);
        Object value = this.getNode().getValue(ctx);
        if (this.expectedType != null) {
            return ELSupport.coerceToType(value, this.expectedType);
        }
        return value;
public inthashCode()

        return this.expr.hashCode();
public booleanisLiteralText()

        try {
            return this.getNode() instanceof AstLiteralExpression;
        } catch (ELException ele) {
            return false;
        }
public booleanisReadOnly(javax.el.ELContext context)

        EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
                this.varMapper);
        return this.getNode().isReadOnly(ctx);
public voidreadExternal(java.io.ObjectInput in)

        this.expr = in.readUTF();
        String type = in.readUTF();
        if (!"".equals(type)) {
            this.expectedType = ReflectionUtil.forName(type);
        }
        this.fnMapper = (FunctionMapper) in.readObject();
        this.varMapper = (VariableMapper) in.readObject();
public voidsetValue(javax.el.ELContext context, java.lang.Object value)

        EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
                this.varMapper);
        this.getNode().setValue(ctx, value);
public java.lang.StringtoString()

        return "ValueExpression["+this.expr+"]";
public voidwriteExternal(java.io.ObjectOutput out)

        out.writeUTF(this.expr);
        out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
                : "");
        out.writeObject(this.fnMapper);
        out.writeObject(this.varMapper);