This is an automated email from the ASF dual-hosted git repository.
markt pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tomcat.git
commit 809618a540b002e82d7c58567b058f6acda406e6
Author: Mark Thomas <ma...@apache.org>
AuthorDate: Fri Aug 9 15:21:16 2024 +0100
Code clean-up - formatting. No functional change.
---
java/org/apache/el/ExpressionFactoryImpl.java | 20 +--
java/org/apache/el/MethodExpressionImpl.java | 212 ++++++++++--------------
java/org/apache/el/MethodExpressionLiteral.java | 9 +-
java/org/apache/el/ValueExpressionImpl.java | 105 +++++-------
java/org/apache/el/ValueExpressionLiteral.java | 19 +--
5 files changed, 143 insertions(+), 222 deletions(-)
diff --git a/java/org/apache/el/ExpressionFactoryImpl.java
b/java/org/apache/el/ExpressionFactoryImpl.java
index 82f5cf123b..4a13adb591 100644
--- a/java/org/apache/el/ExpressionFactoryImpl.java
+++ b/java/org/apache/el/ExpressionFactoryImpl.java
@@ -34,7 +34,7 @@ import org.apache.el.util.MessageFactory;
*
* @author Jacob Hookom [ja...@hookom.net]
*/
-@aQute.bnd.annotation.spi.ServiceProvider(value=ExpressionFactory.class)
+@aQute.bnd.annotation.spi.ServiceProvider(value = ExpressionFactory.class)
public class ExpressionFactoryImpl extends ExpressionFactory {
static {
@@ -47,31 +47,25 @@ public class ExpressionFactoryImpl extends
ExpressionFactory {
}
@Override
- public MethodExpression createMethodExpression(ELContext context,
- String expression, Class<?> expectedReturnType,
+ public MethodExpression createMethodExpression(ELContext context, String
expression, Class<?> expectedReturnType,
Class<?>[] expectedParamTypes) {
ExpressionBuilder builder = new ExpressionBuilder(expression, context);
- return builder.createMethodExpression(expectedReturnType,
- expectedParamTypes);
+ return builder.createMethodExpression(expectedReturnType,
expectedParamTypes);
}
@Override
- public ValueExpression createValueExpression(ELContext context,
- String expression, Class<?> expectedType) {
+ public ValueExpression createValueExpression(ELContext context, String
expression, Class<?> expectedType) {
if (expectedType == null) {
- throw new NullPointerException(MessageFactory
- .get("error.value.expectedType"));
+ throw new
NullPointerException(MessageFactory.get("error.value.expectedType"));
}
ExpressionBuilder builder = new ExpressionBuilder(expression, context);
return builder.createValueExpression(expectedType);
}
@Override
- public ValueExpression createValueExpression(Object instance,
- Class<?> expectedType) {
+ public ValueExpression createValueExpression(Object instance, Class<?>
expectedType) {
if (expectedType == null) {
- throw new NullPointerException(MessageFactory
- .get("error.value.expectedType"));
+ throw new
NullPointerException(MessageFactory.get("error.value.expectedType"));
}
return new ValueExpressionLiteral(instance, expectedType);
}
diff --git a/java/org/apache/el/MethodExpressionImpl.java
b/java/org/apache/el/MethodExpressionImpl.java
index 5981465348..c9174d5796 100644
--- a/java/org/apache/el/MethodExpressionImpl.java
+++ b/java/org/apache/el/MethodExpressionImpl.java
@@ -39,32 +39,25 @@ import org.apache.el.util.ReflectionUtil;
/**
* An <code>Expression</code> that refers to a method on an object.
- *
* <p>
- * The {@link jakarta.el.ExpressionFactory#createMethodExpression} method
- * can be used to parse an expression string and return a concrete instance
- * of <code>MethodExpression</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 #getMethodInfo} and {@link #invoke} methods will evaluate the
- * expression each time they are called. The {@link jakarta.el.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 two methods, the
- * {@link jakarta.el.ELResolver#getValue} method is used to resolve all
properties
- * up to but excluding the last one. This provides the <code>base</code> object
- * on which the method appears. If the <code>base</code> object is null, a
- * <code>NullPointerException</code> must be thrown. At the last resolution,
- * the final <code>property</code> is then coerced to a <code>String</code>,
- * which provides the name of the method to be found. A method matching the
- * name and expected parameters provided at parse time is found and it is
- * either queried or invoked (depending on the method called on this
- * <code>MethodExpression</code>).</p>
- *
- * <p>See the notes about comparison, serialization and immutability in
- * the {@link jakarta.el.Expression} javadocs.
+ * The {@link jakarta.el.ExpressionFactory#createMethodExpression} method can
be used to parse an expression string and
+ * return a concrete instance of <code>MethodExpression</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 #getMethodInfo} and {@link #invoke} methods will evaluate the
expression each time they are called. The
+ * {@link jakarta.el.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 two methods, the
+ * {@link jakarta.el.ELResolver#getValue} method is used to resolve all
properties up to but excluding the last one.
+ * This provides the <code>base</code> object on which the method appears. If
the <code>base</code> object is null, a
+ * <code>NullPointerException</code> must be thrown. At the last resolution,
the final <code>property</code> is then
+ * coerced to a <code>String</code>, which provides the name of the method to
be found. A method matching the name and
+ * expected parameters provided at parse time is found and it is either
queried or invoked (depending on the method
+ * called on this <code>MethodExpression</code>).
+ * </p>
+ * <p>
+ * See the notes about comparison, serialization and immutability in the
{@link jakarta.el.Expression} javadocs.
*
* @see jakarta.el.ELResolver
* @see jakarta.el.Expression
@@ -73,8 +66,7 @@ import org.apache.el.util.ReflectionUtil;
*
* @author Jacob Hookom [ja...@hookom.net]
*/
-public final class MethodExpressionImpl extends MethodExpression implements
- Externalizable {
+public final class MethodExpressionImpl extends MethodExpression implements
Externalizable {
private Class<?> expectedType;
@@ -92,8 +84,7 @@ public final class MethodExpressionImpl extends
MethodExpression implements
super();
}
- public MethodExpressionImpl(String expr, Node node,
- FunctionMapper fnMapper, VariableMapper varMapper,
+ public MethodExpressionImpl(String expr, Node node, FunctionMapper
fnMapper, VariableMapper varMapper,
Class<?> expectedType, Class<?>[] paramTypes) {
super();
this.expr = expr;
@@ -105,53 +96,40 @@ public final class MethodExpressionImpl extends
MethodExpression implements
}
/**
- * Determines whether the specified object is equal to this
- * <code>Expression</code>.
- *
+ * Determines whether the specified object is equal to this
<code>Expression</code>.
* <p>
- * The result is <code>true</code> if and only if the argument is not
- * <code>null</code>, is an <code>Expression</code> object that is the
- * of the same type (<code>ValueExpression</code> or
- * <code>MethodExpression</code>), and has an identical parsed
- * representation.
+ * The result is <code>true</code> if and only if the argument is not
<code>null</code>, is an
+ * <code>Expression</code> object that is the of the same type
(<code>ValueExpression</code> or
+ * <code>MethodExpression</code>), and has an identical parsed
representation.
* </p>
- *
* <p>
- * Note that two expressions can be equal if their expression Strings are
- * different. For example, <code>${fn1:foo()}</code> and
- * <code>${fn2:foo()}</code> are equal if their corresponding
- * <code>FunctionMapper</code>s mapped <code>fn1:foo</code> and
- * <code>fn2:foo</code> to the same method.
+ * Note that two expressions can be equal if their expression Strings are
different. For example,
+ * <code>${fn1:foo()}</code> and <code>${fn2:foo()}</code> are equal if
their corresponding
+ * <code>FunctionMapper</code>s mapped <code>fn1:foo</code> and
<code>fn2:foo</code> to the same method.
* </p>
*
- * @param obj
- * the <code>Object</code> to test for equality.
- * @return <code>true</code> if <code>obj</code> equals this
- * <code>Expression</code>; <code>false</code> otherwise.
+ * @param obj the <code>Object</code> to test for equality.
+ *
+ * @return <code>true</code> if <code>obj</code> equals this
<code>Expression</code>; <code>false</code> otherwise.
+ *
* @see java.util.Hashtable
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
- return (obj instanceof MethodExpressionImpl && obj.hashCode() == this
- .hashCode());
+ return (obj instanceof MethodExpressionImpl && obj.hashCode() ==
this.hashCode());
}
/**
- * Returns the original String used to create this <code>Expression</code>,
- * unmodified.
- *
+ * Returns the original String used to create this
<code>Expression</code>, unmodified.
* <p>
- * This is used for debugging purposes but also for the purposes of
- * comparison (e.g. to ensure the expression in a configuration file has
not
- * changed).
+ * This is used for debugging purposes but also for the purposes of
comparison (e.g. to ensure the expression in a
+ * configuration file has not changed).
* </p>
- *
* <p>
- * This method does not provide sufficient information to re-create an
- * expression. Two different expressions can have exactly the same
- * expression string but different function mappings. Serialization should
- * be used to save and restore the state of an <code>Expression</code>.
+ * This method does not provide sufficient information to re-create an
expression. Two different expressions can
+ * have exactly the same expression string but different function
mappings. Serialization should be used to save and
+ * restore the state of an <code>Expression</code>.
* </p>
*
* @return The original expression String.
@@ -164,34 +142,30 @@ public final class MethodExpressionImpl extends
MethodExpression implements
}
/**
- * Evaluates the expression relative to the provided context, and returns
- * information about the actual referenced method.
+ * Evaluates the expression relative to the provided context, and returns
information about the actual referenced
+ * method.
+ *
+ * @param context The context of this evaluation
+ *
+ * @return an instance of <code>MethodInfo</code> containing information
about the method the expression evaluated
+ * to.
+ *
+ * @throws NullPointerException if context is <code>null</code> or
the base object is <code>null</code> on the
+ * last resolution.
+ * @throws PropertyNotFoundException if one of the property resolutions
failed because a specified variable or
+ * property does not exist or is not
readable.
+ * @throws MethodNotFoundException if no suitable method can be found.
+ * @throws 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.
*
- * @param context
- * The context of this evaluation
- * @return an instance of <code>MethodInfo</code> containing information
- * about the method the expression evaluated to.
- * @throws NullPointerException
- * if context is <code>null</code> or the base object is
- * <code>null</code> on the last resolution.
- * @throws PropertyNotFoundException
- * if one of the property resolutions failed because a
specified
- * variable or property does not exist or is not readable.
- * @throws MethodNotFoundException
- * if no suitable method can be found.
- * @throws 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.
* @see jakarta.el.MethodExpression#getMethodInfo(jakarta.el.ELContext)
*/
@Override
public MethodInfo getMethodInfo(ELContext context)
- throws PropertyNotFoundException, MethodNotFoundException,
- ELException {
+ throws PropertyNotFoundException, MethodNotFoundException,
ELException {
Node n = this.getNode();
- EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
- this.varMapper);
+ EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper);
ctx.notifyBeforeEvaluation(getExpressionString());
MethodInfo result = n.getMethodInfo(ctx, this.paramTypes);
ctx.notifyAfterEvaluation(getExpressionString());
@@ -207,17 +181,15 @@ public final class MethodExpressionImpl extends
MethodExpression implements
/**
* Returns the hash code for this <code>Expression</code>.
- *
* <p>
- * See the note in the {@link #equals} method on how two expressions can be
- * equal if their expression Strings are different. Recall that if two
- * objects are equal according to the <code>equals(Object)</code> method,
- * then calling the <code>hashCode</code> method on each of the two
- * objects must produce the same integer result. Implementations must take
- * special note and implement <code>hashCode</code> correctly.
+ * See the note in the {@link #equals} method on how two expressions can
be equal if their expression Strings are
+ * different. Recall that if two objects are equal according to the
<code>equals(Object)</code> method, then calling
+ * the <code>hashCode</code> method on each of the two objects must
produce the same integer result. Implementations
+ * must take special note and implement <code>hashCode</code> correctly.
* </p>
*
* @return The hash code for this <code>Expression</code>.
+ *
* @see #equals
* @see java.util.Hashtable
* @see java.lang.Object#hashCode()
@@ -228,41 +200,32 @@ public final class MethodExpressionImpl extends
MethodExpression implements
}
/**
- * Evaluates the expression relative to the provided context, invokes the
- * method that was found using the supplied parameters, and returns the
- * result of the method invocation.
+ * Evaluates the expression relative to the provided context, invokes the
method that was found using the supplied
+ * parameters, and returns the result of the method invocation.
+ *
+ * @param context The context of this evaluation.
+ * @param params The parameters to pass to the method, or
<code>null</code> if no parameters.
+ *
+ * @return the result of the method invocation (<code>null</code> if the
method has a <code>void</code> return
+ * type).
*
- * @param context
- * The context of this evaluation.
- * @param params
- * The parameters to pass to the method, or <code>null</code>
- * if no parameters.
- * @return the result of the method invocation (<code>null</code> if the
- * method has a <code>void</code> return type).
- * @throws NullPointerException
- * if context is <code>null</code> or the base object is
- * <code>null</code> on the last resolution.
- * @throws PropertyNotFoundException
- * if one of the property resolutions failed because a
specified
- * variable or property does not exist or is not readable.
- * @throws MethodNotFoundException
- * if no suitable method can be found.
- * @throws 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. If the
- * exception thrown is an
<code>InvocationTargetException</code>,
- * extract its <code>cause</code> and pass it to the
- * <code>ELException</code> constructor.
- * @see jakarta.el.MethodExpression#invoke(jakarta.el.ELContext,
- * java.lang.Object[])
+ * @throws NullPointerException if context is <code>null</code> or
the base object is <code>null</code> on the
+ * last resolution.
+ * @throws PropertyNotFoundException if one of the property resolutions
failed because a specified variable or
+ * property does not exist or is not
readable.
+ * @throws MethodNotFoundException if no suitable method can be found.
+ * @throws 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. If the
exception thrown is an
+ *
<code>InvocationTargetException</code>, extract its <code>cause</code> and
+ * pass it to the
<code>ELException</code> constructor.
+ *
+ * @see jakarta.el.MethodExpression#invoke(jakarta.el.ELContext,
java.lang.Object[])
*/
@Override
public Object invoke(ELContext context, Object[] params)
- throws PropertyNotFoundException, MethodNotFoundException,
- ELException {
- EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
- this.varMapper);
+ throws PropertyNotFoundException, MethodNotFoundException,
ELException {
+ EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper);
ctx.notifyBeforeEvaluation(getExpressionString());
Object result = this.getNode().invoke(ctx, this.paramTypes, params);
ctx.notifyAfterEvaluation(getExpressionString());
@@ -270,15 +233,13 @@ public final class MethodExpressionImpl extends
MethodExpression implements
}
@Override
- public void readExternal(ObjectInput in) throws IOException,
- ClassNotFoundException {
+ 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.paramTypes = ReflectionUtil.toTypeArray(((String[]) in
- .readObject()));
+ this.paramTypes = ReflectionUtil.toTypeArray(((String[])
in.readObject()));
this.fnMapper = (FunctionMapper) in.readObject();
this.varMapper = (VariableMapper) in.readObject();
}
@@ -286,8 +247,7 @@ public final class MethodExpressionImpl extends
MethodExpression implements
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeUTF(this.expr);
- out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
- : "");
+ out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
: "");
out.writeObject(ReflectionUtil.toTypeNameArray(this.paramTypes));
out.writeObject(this.fnMapper);
out.writeObject(this.varMapper);
diff --git a/java/org/apache/el/MethodExpressionLiteral.java
b/java/org/apache/el/MethodExpressionLiteral.java
index 9fd0046b19..eeec431a47 100644
--- a/java/org/apache/el/MethodExpressionLiteral.java
+++ b/java/org/apache/el/MethodExpressionLiteral.java
@@ -47,8 +47,7 @@ public class MethodExpressionLiteral extends MethodExpression
implements Externa
// do nothing
}
- public MethodExpressionLiteral(String expr, Class<?> expectedType,
- Class<?>[] paramTypes) {
+ public MethodExpressionLiteral(String expr, Class<?> expectedType,
Class<?>[] paramTypes) {
this.expr = expr;
this.expectedType = expectedType;
this.paramTypes = paramTypes;
@@ -120,15 +119,13 @@ public class MethodExpressionLiteral extends
MethodExpression implements Externa
if (!type.isEmpty()) {
this.expectedType = ReflectionUtil.forName(type);
}
- this.paramTypes = ReflectionUtil.toTypeArray(((String[]) in
- .readObject()));
+ this.paramTypes = ReflectionUtil.toTypeArray(((String[])
in.readObject()));
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeUTF(this.expr);
- out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
- : "");
+ out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
: "");
out.writeObject(ReflectionUtil.toTypeNameArray(this.paramTypes));
}
}
diff --git a/java/org/apache/el/ValueExpressionImpl.java
b/java/org/apache/el/ValueExpressionImpl.java
index 563ec6c7c6..097b924dc7 100644
--- a/java/org/apache/el/ValueExpressionImpl.java
+++ b/java/org/apache/el/ValueExpressionImpl.java
@@ -39,43 +39,32 @@ import org.apache.el.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>.
+ * 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>
- * The {@link jakarta.el.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 jakarta.el.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 jakarta.el.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 jakarta.el.ELResolver#getValue}, {@link
jakarta.el.ELResolver#setValue},
- * {@link jakarta.el.ELResolver#isReadOnly} or {@link
jakarta.el.ELResolver#getType}
- * method, depending on which was called on the <code>ValueExpression</code>.
+ * The {@link jakarta.el.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>See the notes about comparison, serialization and immutability in
- * the {@link jakarta.el.Expression} javadocs.
+ * <p>
+ * The {@link #getValue}, {@link #setValue}, {@link #isReadOnly} and {@link
#getType} methods will evaluate the
+ * expression each time they are called. The {@link jakarta.el.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 jakarta.el.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
jakarta.el.ELResolver#getValue},
+ * {@link jakarta.el.ELResolver#setValue}, {@link
jakarta.el.ELResolver#isReadOnly} or
+ * {@link jakarta.el.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 jakarta.el.Expression} javadocs.
*
* @see jakarta.el.ELResolver
* @see jakarta.el.Expression
@@ -84,8 +73,7 @@ import org.apache.el.util.ReflectionUtil;
*
* @author Jacob Hookom [ja...@hookom.net]
*/
-public final class ValueExpressionImpl extends ValueExpression implements
- Externalizable {
+public final class ValueExpressionImpl extends ValueExpression implements
Externalizable {
private Class<?> expectedType;
@@ -101,8 +89,8 @@ public final class ValueExpressionImpl extends
ValueExpression implements
super();
}
- public ValueExpressionImpl(String expr, Node node, FunctionMapper fnMapper,
- VariableMapper varMapper, Class<?> expectedType) {
+ public ValueExpressionImpl(String expr, Node node, FunctionMapper
fnMapper, VariableMapper varMapper,
+ Class<?> expectedType) {
this.expr = expr;
this.node = node;
this.fnMapper = fnMapper;
@@ -128,12 +116,10 @@ public final class ValueExpressionImpl extends
ValueExpression implements
}
/**
- * Returns the type the result of the expression will be coerced to after
- * evaluation.
+ * 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>.
+ * @return the <code>expectedType</code> passed to the
<code>ExpressionFactory.createValueExpression</code> method
+ * that created this <code>ValueExpression</code>.
*
* @see jakarta.el.Expression#getExpressionString()
*/
@@ -150,10 +136,8 @@ public final class ValueExpressionImpl extends
ValueExpression implements
}
@Override
- public Class<?> getType(ELContext context) throws
PropertyNotFoundException,
- ELException {
- EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
- this.varMapper);
+ 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());
@@ -162,10 +146,8 @@ public final class ValueExpressionImpl extends
ValueExpression implements
@SuppressWarnings("unchecked")
@Override
- public <T> T getValue(ELContext context) throws PropertyNotFoundException,
- ELException {
- EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
- this.varMapper);
+ public <T> T 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) {
@@ -190,10 +172,8 @@ public final class ValueExpressionImpl extends
ValueExpression implements
}
@Override
- public boolean isReadOnly(ELContext context)
- throws PropertyNotFoundException, ELException {
- EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
- this.varMapper);
+ 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());
@@ -201,8 +181,7 @@ public final class ValueExpressionImpl extends
ValueExpression implements
}
@Override
- public void readExternal(ObjectInput in) throws IOException,
- ClassNotFoundException {
+ public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
this.expr = in.readUTF();
String type = in.readUTF();
if (!type.isEmpty()) {
@@ -214,10 +193,8 @@ public final class ValueExpressionImpl extends
ValueExpression implements
@Override
public void setValue(ELContext context, Object value)
- throws PropertyNotFoundException, PropertyNotWritableException,
- ELException {
- EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
- this.varMapper);
+ throws PropertyNotFoundException, PropertyNotWritableException,
ELException {
+ EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper);
context.notifyBeforeEvaluation(getExpressionString());
this.getNode().setValue(ctx, value);
context.notifyAfterEvaluation(getExpressionString());
@@ -226,21 +203,19 @@ public final class ValueExpressionImpl extends
ValueExpression implements
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeUTF(this.expr);
- out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
- : "");
+ out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
: "");
out.writeObject(this.fnMapper);
out.writeObject(this.varMapper);
}
@Override
public String toString() {
- return "ValueExpression["+this.expr+"]";
+ return "ValueExpression[" + this.expr + "]";
}
@Override
public ValueReference getValueReference(ELContext context) {
- EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
- this.varMapper);
+ EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
this.varMapper);
context.notifyBeforeEvaluation(getExpressionString());
ValueReference result = this.getNode().getValueReference(ctx);
context.notifyAfterEvaluation(getExpressionString());
diff --git a/java/org/apache/el/ValueExpressionLiteral.java
b/java/org/apache/el/ValueExpressionLiteral.java
index 2ecfe8d4b0..ab6d0c18dc 100644
--- a/java/org/apache/el/ValueExpressionLiteral.java
+++ b/java/org/apache/el/ValueExpressionLiteral.java
@@ -29,8 +29,7 @@ import org.apache.el.util.MessageFactory;
import org.apache.el.util.ReflectionUtil;
-public final class ValueExpressionLiteral extends ValueExpression implements
- Externalizable {
+public final class ValueExpressionLiteral extends ValueExpression implements
Externalizable {
private static final long serialVersionUID = 1L;
@@ -65,8 +64,7 @@ public final class ValueExpressionLiteral extends
ValueExpression implements
@Override
public void setValue(ELContext context, Object value) {
context.notifyBeforeEvaluation(getExpressionString());
- throw new PropertyNotWritableException(MessageFactory.get(
- "error.value.literal.write", this.value));
+ throw new
PropertyNotWritableException(MessageFactory.get("error.value.literal.write",
this.value));
}
@Override
@@ -99,13 +97,12 @@ public final class ValueExpressionLiteral extends
ValueExpression implements
@Override
public boolean equals(Object obj) {
- return (obj instanceof ValueExpressionLiteral && this
- .equals((ValueExpressionLiteral) obj));
+ return (obj instanceof ValueExpressionLiteral &&
this.equals((ValueExpressionLiteral) obj));
}
public boolean equals(ValueExpressionLiteral ve) {
- return (ve != null && (this.value != null && ve.value != null &&
(this.value == ve.value || this.value
- .equals(ve.value))));
+ return (ve != null &&
+ (this.value != null && ve.value != null && (this.value ==
ve.value || this.value.equals(ve.value))));
}
@Override
@@ -121,13 +118,11 @@ public final class ValueExpressionLiteral extends
ValueExpression implements
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(this.value);
- out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
- : "");
+ out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
: "");
}
@Override
- public void readExternal(ObjectInput in) throws IOException,
- ClassNotFoundException {
+ public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
this.value = in.readObject();
String type = in.readUTF();
if (!type.isEmpty()) {
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@tomcat.apache.org
For additional commands, e-mail: dev-h...@tomcat.apache.org
