jakarta.el.CompositeELResolver Maven / Gradle / Ivy
/*
* Copyright (c) 1997, 2019 Oracle and/or its affiliates and others.
* All rights reserved.
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 jakarta.el;
import java.beans.FeatureDescriptor;
import java.util.Iterator;
/**
* Maintains an ordered composite list of child ELResolvers.
*
*
* Though only a single ELResolver is associated with an ELContext, there are usually multiple
* resolvers considered for any given variable or property resolution. ELResolvers are combined together
* using a CompositeELResolver, to define rich semantics for evaluating an expression.
*
*
*
* For the {@link #getValue}, {@link #getType}, {@link #setValue} and {@link #isReadOnly} methods, an
* ELResolver is not responsible for resolving all possible (base, property) pairs. In fact, most resolvers
* will only handle a base of a single type. To indicate that a resolver has successfully resolved a
* particular (base, property) pair, it must set the propertyResolved property of the
* ELContext to true. If it could not handle the given pair, it must leave this property
* alone. The caller must ignore the return value of the method if propertyResolved is false.
*
*
*
* The CompositeELResolver initializes the ELContext.propertyResolved flag to
* false, and uses it as a stop condition for iterating through its component resolvers.
*
*
*
* The ELContext.propertyResolved flag is not used for the design-time methods
* {@link #getFeatureDescriptors} and {@link #getCommonPropertyType}. Instead, results are collected and combined from
* all child ELResolvers for these methods.
*
*
* @see ELContext
* @see ELResolver
* @since Jakarta Server Pages 2.1
*/
public class CompositeELResolver extends ELResolver {
public CompositeELResolver() {
this.size = 0;
this.elResolvers = new ELResolver[16];
}
/**
* Adds the given resolver to the list of component resolvers.
*
*
* Resolvers are consulted in the order in which they are added.
*
*
* @param elResolver The component resolver to add.
* @throws NullPointerException If the provided resolver is null.
*/
public void add(ELResolver elResolver) {
if (elResolver == null) {
throw new NullPointerException();
}
if (size >= elResolvers.length) {
ELResolver[] newResolvers = new ELResolver[size * 2];
System.arraycopy(elResolvers, 0, newResolvers, 0, size);
elResolvers = newResolvers;
}
elResolvers[size++] = elResolver;
}
/**
* Attempts to resolve the given property object on the given base object by querying all
* component resolvers.
*
*
* If this resolver handles the given (base, property) pair, the propertyResolved property of the
* ELContext object must be set to true by the resolver, before returning. If this property is
* not true after this method is called, the caller should ignore the return value.
*
*
* First, propertyResolved is set to false on the provided ELContext.
*
*
* Next, for each component resolver in this composite:
*
* - The
getValue() method is called, passing in the provided context, base and
* property.
* - If the
ELContext's propertyResolved flag is false then iteration
* continues.
* - Otherwise, iteration stops and no more component resolvers are considered. The value returned by
*
getValue() is returned by this method.
*
*
*
* If none of the component resolvers were able to perform this operation, the value null is returned and
* the propertyResolved flag remains set to false.
*
*
* Any exception thrown by component resolvers during the iteration is propagated to the caller of this method.
*
* @param context The context of this evaluation.
* @param base The base object whose property value is to be returned, or null to resolve a top-level
* variable.
* @param property The property or variable to be resolved.
* @return If the propertyResolved property of ELContext was set to true, then
* the result of the variable or property resolution; otherwise undefined.
* @throws NullPointerException if context is null
* @throws PropertyNotFoundException if the given (base, property) pair is handled by this ELResolver but
* the specified variable or property does not exist or is not readable.
* @throws ELException if an exception was thrown while performing the property or variable resolution. The thrown
* exception must be included as the cause property of this exception, if available.
*/
@Override
public Object getValue(ELContext context, Object base, Object property) {
context.setPropertyResolved(false);
Object value = null;
for (int i = 0; i < size; i++) {
value = elResolvers[i].getValue(context, base, property);
if (context.isPropertyResolved()) {
return value;
}
}
return null;
}
/**
* Attempts to resolve and invoke the given method on the given base object by querying all
* component resolvers.
*
*
* If this resolver handles the given (base, method) pair, the propertyResolved property of the
* ELContext object must be set to true by the resolver, before returning. If this property is
* not true after this method is called, the caller should ignore the return value.
*
*
*
* First, propertyResolved is set to false on the provided ELContext.
*
*
*
* Next, for each component resolver in this composite:
*
* - The
invoke() method is called, passing in the provided context, base,
* method, paramTypes, and params.
* - If the
ELContext's propertyResolved flag is false then iteration
* continues.
* - Otherwise, iteration stops and no more component resolvers are considered. The value returned by
*
getValue() is returned by this method.
*
*
*
* If none of the component resolvers were able to perform this operation, the value null is returned and
* the propertyResolved flag remains set to false
*
* .
*
*
* Any exception thrown by component resolvers during the iteration is propagated to the caller of this method.
*
*
* @param context The context of this evaluation.
* @param base The bean on which to invoke the method
* @param method The simple name of the method to invoke. Will be coerced to a String.
* @param paramTypes An array of Class objects identifying the method's formal parameter types, in declared order. Use
* an empty array if the method has no parameters. Can be null, in which case the method's formal parameter
* types are assumed to be unknown.
* @param params The parameters to pass to the method, or null if no parameters.
*
* @return The result of the method invocation (null if the method has a void return type).
*
* @since Jakarta Expression Language 2.2
*/
@Override
public Object invoke(ELContext context, Object base, Object method, Class[] paramTypes, Object[] params) {
context.setPropertyResolved(false);
Object value;
for (int i = 0; i < size; i++) {
value = elResolvers[i].invoke(context, base, method, paramTypes, params);
if (context.isPropertyResolved()) {
return value;
}
}
return null;
}
/**
* For a given base and property, attempts to identify the most general type that is
* acceptable for an object to be passed as the value parameter in a future call to the {@link #setValue}
* method. The result is obtained by querying all component resolvers.
*
*
* If this resolver handles the given (base, property) pair, the propertyResolved property of the
* ELContext object must be set to true by the resolver, before returning. If this property is
* not true after this method is called, the caller should ignore the return value.
*
*
*
* First, propertyResolved is set to false on the provided ELContext.
*
*
*
* Next, for each component resolver in this composite:
*
* - The
getType() method is called, passing in the provided context, base and
* property.
* - If the
ELContext's propertyResolved flag is false then iteration
* continues.
* - Otherwise, iteration stops and no more component resolvers are considered. The value returned by
*
getType() is returned by this method.
*
*
*
* If none of the component resolvers were able to perform this operation, the value null is returned and
* the propertyResolved flag remains set to false.
*
*
*
*
* Any exception thrown by component resolvers during the iteration is propagated to the caller of this method.
*
*
* @param context The context of this evaluation.
* @param base The base object whose property value is to be analyzed, or null to analyze a top-level
* variable.
* @param property The property or variable to return the acceptable type for.
* @return If the propertyResolved property of ELContext was set to true, then
* the most general acceptable type; otherwise undefined.
* @throws NullPointerException if context is null
* @throws PropertyNotFoundException if the given (base, property) pair is handled by this ELResolver but
* the specified variable or property does not exist or is not readable.
* @throws ELException if an exception was thrown while performing the property or variable resolution. The thrown
* exception must be included as the cause property of this exception, if available.
*/
@Override
public Class getType(ELContext context, Object base, Object property) {
context.setPropertyResolved(false);
Class type;
for (int i = 0; i < size; i++) {
type = elResolvers[i].getType(context, base, property);
if (context.isPropertyResolved()) {
return type;
}
}
return null;
}
/**
* Attempts to set the value of the given property object on the given base object. All
* component resolvers are asked to attempt to set the value.
*
*
* If this resolver handles the given (base, property) pair, the propertyResolved property of the
* ELContext object must be set to true by the resolver, before returning. If this property is
* not true after this method is called, the caller can safely assume no value has been set.
*
*
* First, propertyResolved is set to false on the provided ELContext.
*
*
* Next, for each component resolver in this composite:
*
* - The
setValue() method is called, passing in the provided context, base,
* property and value.
* - If the
ELContext's propertyResolved flag is false then iteration
* continues.
* - Otherwise, iteration stops and no more component resolvers are considered.
*
*
*
* If none of the component resolvers were able to perform this operation, the propertyResolved flag
* remains set to false.
*
*
* Any exception thrown by component resolvers during the iteration is propagated to the caller of this method.
*
* @param context The context of this evaluation.
* @param base The base object whose property value is to be set, or null to set a top-level variable.
* @param property The property or variable to be set.
* @param val The value to set the property or variable to.
* @throws NullPointerException if context is null
* @throws PropertyNotFoundException if the given (base, property) pair is handled by this ELResolver but
* the specified variable or property does not exist.
* @throws PropertyNotWritableException if the given (base, property) pair is handled by this ELResolver
* but the specified variable or property is not writable.
* @throws 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.
*/
@Override
public void setValue(ELContext context, Object base, Object property, Object val) {
context.setPropertyResolved(false);
for (int i = 0; i < size; i++) {
elResolvers[i].setValue(context, base, property, val);
if (context.isPropertyResolved()) {
return;
}
}
}
/**
* For a given base and property, attempts to determine whether a call to {@link #setValue}
* will always fail. The result is obtained by querying all component resolvers.
*
*
* If this resolver handles the given (base, property) pair, the propertyResolved property of the
* ELContext object must be set to true by the resolver, before returning. If this property is
* not true after this method is called, the caller should ignore the return value.
*
*
*
* First, propertyResolved is set to false on the provided ELContext.
*
*
*
* Next, for each component resolver in this composite:
*
* - The
isReadOnly() method is called, passing in the provided context, base
* and property.
* - If the
ELContext's propertyResolved flag is false then iteration
* continues.
* - Otherwise, iteration stops and no more component resolvers are considered. The value returned by
*
isReadOnly() is returned by this method.
*
*
*
* If none of the component resolvers were able to perform this operation, the value false is returned and
* the propertyResolved flag remains set to false
*
* .
*
*
* Any exception thrown by component resolvers during the iteration is propagated to the caller of this method.
*
*
* @param context The context of this evaluation.
* @param base The base object whose property value is to be analyzed, or null to analyze a top-level
* variable.
* @param property The property or variable to return the read-only status for.
* @return If the propertyResolved property of ELContext was set to true, then
* true if the property is read-only or false if not; otherwise undefined.
* @throws NullPointerException if context is null
* @throws PropertyNotFoundException if the given (base, property) pair is handled by this ELResolver but
* the specified variable or property does not exist.
* @throws ELException if an exception was thrown while performing the property or variable resolution. The thrown
* exception must be included as the cause property of this exception, if available.
*/
@Override
public boolean isReadOnly(ELContext context, Object base, Object property) {
context.setPropertyResolved(false);
boolean readOnly;
for (int i = 0; i < size; i++) {
readOnly = elResolvers[i].isReadOnly(context, base, property);
if (context.isPropertyResolved()) {
return readOnly;
}
}
return false; // Does not matter
}
/**
* Returns information about the set of variables or properties that can be resolved for the given base
* object. One use for this method is to assist tools in auto-completion. The results are collected from all component
* resolvers.
*
*
* The propertyResolved property of the ELContext is not relevant to this method. The results
* of all ELResolvers are concatenated.
*
*
*
* The Iterator returned is an iterator over the collection of FeatureDescriptor objects
* returned by the iterators returned by each component resolver's getFeatureDescriptors method. If
* null is returned by a resolver, it is skipped.
*
*
* @param context The context of this evaluation.
* @param base The base object whose set of valid properties is to be enumerated, or null to enumerate the
* set of top-level variables that this resolver can evaluate.
* @return An Iterator containing zero or more (possibly infinitely more) FeatureDescriptor
* objects, or null if this resolver does not handle the given base object or that the results
* are too complex to represent with this method
*/
@Override
public Iterator getFeatureDescriptors(ELContext context, Object base) {
return new CompositeIterator(elResolvers, size, context, base);
}
/**
* Returns the most general type that this resolver accepts for the property argument, given a
* base object. One use for this method is to assist tools in auto-completion. The result is obtained by
* querying all component resolvers.
*
*
* The Class returned is the most specific class that is a common superclass of all the classes returned by
* each component resolver's getCommonPropertyType method. If null is returned by a resolver,
* it is skipped.
*
* @param context The context of this evaluation.
* @param base The base object to return the most general property type for, or null to enumerate the set
* of top-level variables that this resolver can evaluate.
*
* @return null if this ELResolver does not know how to handle the given base
* object; otherwise Object.class if any type of property is accepted; otherwise the most
* general property type accepted for the given base.
*/
@Override
public Class getCommonPropertyType(ELContext context, Object base) {
Class commonPropertyType = null;
for (int i = 0; i < size; i++) {
Class type = elResolvers[i].getCommonPropertyType(context, base);
if (type == null) {
// skip this Jakarta Expression Language Resolver
continue;
} else if (commonPropertyType == null) {
commonPropertyType = type;
} else if (commonPropertyType.isAssignableFrom(type)) {
continue;
} else if (type.isAssignableFrom(commonPropertyType)) {
commonPropertyType = type;
} else {
// Don't have a commonPropertyType
return null;
}
}
return commonPropertyType;
}
/**
* Converts an object to a specific type.
*
*
* An ELException is thrown if an error occurs during the conversion.
*
*
* @param context The context of this evaluation.
* @param obj The object to convert.
* @param targetType The target type for the convertion.
*
* @throws ELException thrown if errors occur.
*
* @since Jakarta Expression Language 3.0
*/
@Override
public Object convertToType(ELContext context, Object obj, Class targetType) {
context.setPropertyResolved(false);
Object value = null;
for (int i = 0; i < size; i++) {
value = elResolvers[i].convertToType(context, obj, targetType);
if (context.isPropertyResolved()) {
return value;
}
}
return null;
}
private ELResolver[] elResolvers;
private int size;
private static class CompositeIterator implements Iterator {
ELResolver[] resolvers;
int size;
int index = 0;
Iterator propertyIter = null;
ELContext context;
Object base;
CompositeIterator(ELResolver[] resolvers, int size, ELContext context, Object base) {
this.resolvers = resolvers;
this.size = size;
this.context = context;
this.base = base;
}
@Override
public boolean hasNext() {
if (propertyIter == null || !propertyIter.hasNext()) {
while (index < size) {
ELResolver elResolver = resolvers[index++];
propertyIter = elResolver.getFeatureDescriptors(context, base);
if (propertyIter != null) {
return propertyIter.hasNext();
}
}
return false;
}
return propertyIter.hasNext();
}
@Override
public FeatureDescriptor next() {
if (propertyIter == null || !propertyIter.hasNext()) {
while (index < size) {
ELResolver elResolver = resolvers[index++];
propertyIter = elResolver.getFeatureDescriptors(context, base);
if (propertyIter != null) {
return propertyIter.next();
}
}
return null;
}
return propertyIter.next();
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
}