/*
* Copyright (C) 2007 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.el.impl;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.List;
import java.util.Collections;
import org.jdesktop.el.ELContext;
import org.jdesktop.el.ELException;
import org.jdesktop.el.ELResolver;
import org.jdesktop.el.Expression;
import org.jdesktop.el.ExpressionFactory;
import org.jdesktop.el.FunctionMapper;
import org.jdesktop.el.PropertyNotFoundException;
import org.jdesktop.el.PropertyNotWritableException;
import org.jdesktop.el.ValueExpression;
import org.jdesktop.el.VariableMapper;
import org.jdesktop.el.impl.lang.ELSupport;
import org.jdesktop.el.impl.lang.EvaluationContext;
import org.jdesktop.el.impl.lang.ExpressionBuilder;
import org.jdesktop.el.impl.parser.AstLiteralExpression;
import org.jdesktop.el.impl.parser.Node;
import org.jdesktop.el.impl.util.ReflectionUtil;
/**
* An <code>Expression</code> that can get or set a value.
*
* <p>
* In previous incarnations of this API, expressions could only be read.
* <code>ValueExpression</code> 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. <code>"${1+1}"</code> or
* <code>"${firstName} ${lastName}"</code>). See the EL Specification for
* details. Expressions that cannot be used as l-values must always return
* <code>true</code> from <code>isReadOnly()</code>.
* </p>
*
* <p>
* <code>The {@link ExpressionFactory#createValueExpression} method
* can be used to parse an expression string and return a concrete instance
* of <code>ValueExpression</code> 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.</p>
*
* <p>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 <code>ELContext</code> is used to
* resolve the top-level variables and to determine the behavior of the
* <code>.</code> and <code>[]</code> 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 <code>base</code>
* object. At the last resolution, the <code>ValueExpression</code> 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 <code>ValueExpression</code>.
* </p>
*
* <p>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: kchung $
*/
public final class ValueExpressionImpl extends ValueExpression implements
Externalizable {
private Class expectedType;
private String expr;
private FunctionMapper fnMapper;
private VariableMapper varMapper;
private transient Node node;
public ValueExpressionImpl() {
}
/**
*
*/
public ValueExpressionImpl(String expr, Node node, FunctionMapper fnMapper,
VariableMapper varMapper, Class expectedType) {
this.expr = expr;
this.node = node;
this.fnMapper = fnMapper;
this.varMapper = varMapper;
this.expectedType = expectedType;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
return (obj instanceof ValueExpressionImpl && obj.hashCode() == this
.hashCode());
}
/*
* (non-Javadoc)
*
* @see javax.el.ValueExpression#getExpectedType()
*/
public Class getExpectedType() {
return this.expectedType;
}
/**
* Returns the type the result of the expression will be coerced to after
* evaluation.
*
* @return the <code>expectedType</code> passed to the
* <code>ExpressionFactory.createValueExpression</code> method
* that created this <code>ValueExpression</code>.
*
* @see javax.el.Expression#getExpressionString()
*/
public String getExpressionString() {
return this.expr;
}
/**
* @return
* @throws ELException
*/
private Node getNode() throws ELException {
if (this.node == null) {
this.node = ExpressionBuilder.createNode(this.expr);
}
return this.node;
}
/*
* (non-Javadoc)
*
* @see javax.el.ValueExpression#getType(javax.el.ELContext)
*/
public Class getType(ELContext context) throws PropertyNotFoundException,
ELException {
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper, this);
return this.getNode().getType(ctx);
}
/*
* (non-Javadoc)
*
* @see javax.el.ValueExpression#getValue(javax.el.ELContext)
*/
public Object getValue(ELContext context) throws PropertyNotFoundException,
ELException {
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper, this);
Object value = this.getNode().getValue(ctx);
if (this.expectedType != null) {
return ELSupport.coerceToType(value, this.expectedType);
}
return value;
}
public Result getResult(ELContext context, boolean trackResolvedObjects) throws PropertyNotFoundException,
ELException {
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper, this.varMapper, this, trackResolvedObjects);
Object value = this.getNode().getValue(ctx);
List<ResolvedProperty> resolvedProperties;
if (trackResolvedObjects) {
resolvedProperties = ctx.getResolvedProperties();
} else {
resolvedProperties = Collections.emptyList();
}
if (value == ELContext.UNRESOLVABLE_RESULT) {
return new Result(Result.Type.UNRESOLVABLE, null, resolvedProperties);
}
value = ELSupport.coerceToType(value, this.expectedType);
return new Result(Result.Type.VALUE, value, resolvedProperties);
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
return this.expr.hashCode();
}
/*
* (non-Javadoc)
*
* @see javax.el.ValueExpression#isLiteralText()
*/
public boolean isLiteralText() {
try {
return this.getNode() instanceof AstLiteralExpression;
} catch (ELException ele) {
return false;
}
}
/*
* (non-Javadoc)
*
* @see javax.el.ValueExpression#isReadOnly(javax.el.ELContext)
*/
public boolean isReadOnly(ELContext context)
throws PropertyNotFoundException, ELException {
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper, this);
return this.getNode().isReadOnly(ctx);
}
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
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();
}
/*
* (non-Javadoc)
*
* @see javax.el.ValueExpression#setValue(javax.el.ELContext,
* java.lang.Object)
*/
public void setValue(ELContext context, Object value)
throws PropertyNotFoundException, PropertyNotWritableException,
ELException {
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper, this);
this.getNode().setValue(ctx, value);
}
public void writeExternal(ObjectOutput out) throws IOException {
out.writeUTF(this.expr);
out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
: "");
out.writeObject(this.fnMapper);
out.writeObject(this.varMapper);
}
public String toString() {
return "ValueExpression["+this.expr+"]";
}
}