org.apache.el.ValueExpressionImpl Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.el;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import javax.el.ELContext;
import javax.el.ELException;
import javax.el.FunctionMapper;
import javax.el.PropertyNotFoundException;
import javax.el.PropertyNotWritableException;
import javax.el.ValueExpression;
import javax.el.ValueReference;
import javax.el.VariableMapper;
import org.apache.el.lang.EvaluationContext;
import org.apache.el.lang.ExpressionBuilder;
import org.apache.el.parser.AstLiteralExpression;
import org.apache.el.parser.Node;
import org.apache.el.util.ReflectionUtil;
/**
* 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 javax.el.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 javax.el.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 javax.el.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 javax.el.ELResolver#getValue}, {@link javax.el.ELResolver#setValue},
* {@link javax.el.ELResolver#isReadOnly} or {@link javax.el.ELResolver#getType}
* method, depending on which was called on the ValueExpression.
*
*
* See the notes about comparison, serialization and immutability in
* the {@link javax.el.Expression} javadocs.
*
* @see javax.el.ELResolver
* @see javax.el.Expression
* @see javax.el.ExpressionFactory
* @see javax.el.ValueExpression
*
* @author Jacob Hookom [[email protected]]
*/
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() {
super();
}
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;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof ValueExpressionImpl)) {
return false;
}
if (obj.hashCode() != this.hashCode()) {
return false;
}
return this.getNode().equals(((ValueExpressionImpl) obj).getNode());
}
@Override
public Class getExpectedType() {
return this.expectedType;
}
/**
* 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()
*/
@Override
public String getExpressionString() {
return this.expr;
}
private Node getNode() throws ELException {
if (this.node == null) {
this.node = ExpressionBuilder.createNode(this.expr);
}
return this.node;
}
@Override
public Class getType(ELContext context) throws PropertyNotFoundException,
ELException {
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper);
context.notifyBeforeEvaluation(getExpressionString());
Class result = this.getNode().getType(ctx);
context.notifyAfterEvaluation(getExpressionString());
return result;
}
@Override
public Object getValue(ELContext context) throws PropertyNotFoundException,
ELException {
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper);
context.notifyBeforeEvaluation(getExpressionString());
Object value = this.getNode().getValue(ctx);
if (this.expectedType != null) {
value = context.convertToType(value, this.expectedType);
}
context.notifyAfterEvaluation(getExpressionString());
return value;
}
@Override
public int hashCode() {
return this.getNode().hashCode();
}
@Override
public boolean isLiteralText() {
try {
return this.getNode() instanceof AstLiteralExpression;
} catch (ELException ele) {
return false;
}
}
@Override
public boolean isReadOnly(ELContext context)
throws PropertyNotFoundException, ELException {
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper);
context.notifyBeforeEvaluation(getExpressionString());
boolean result = this.getNode().isReadOnly(ctx);
context.notifyAfterEvaluation(getExpressionString());
return result;
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
this.expr = in.readUTF();
String type = in.readUTF();
if (!type.isEmpty()) {
this.expectedType = ReflectionUtil.forName(type);
}
this.fnMapper = (FunctionMapper) in.readObject();
this.varMapper = (VariableMapper) in.readObject();
}
@Override
public void setValue(ELContext context, Object value)
throws PropertyNotFoundException, PropertyNotWritableException,
ELException {
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper);
context.notifyBeforeEvaluation(getExpressionString());
this.getNode().setValue(ctx, value);
context.notifyAfterEvaluation(getExpressionString());
}
@Override
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);
}
@Override
public String toString() {
return "ValueExpression["+this.expr+"]";
}
@Override
public ValueReference getValueReference(ELContext context) {
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper);
context.notifyBeforeEvaluation(getExpressionString());
ValueReference result = this.getNode().getValueReference(ctx);
context.notifyAfterEvaluation(getExpressionString());
return result;
}
}