javax.el.CompositeELResolver Maven / Gradle / Ivy
/*
* The contents of this file are subject to the terms
* of the Common Development and Distribution License
* (the "License"). You may not use this file except
* in compliance with the License.
*
* You can obtain a copy of the license at
* glassfish/bootstrap/legal/CDDLv1.0.txt or
* https://glassfish.dev.java.net/public/CDDLv1.0.html.
* See the License for the specific language governing
* permissions and limitations under the License.
*
* When distributing Covered Code, include this CDDL
* HEADER in each file and include the License file at
* glassfish/bootstrap/legal/CDDLv1.0.txt. If applicable,
* add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your
* own identifying information: Portions Copyright [yyyy]
* [name of copyright owner]
*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
*/
package javax.el;
import java.util.ArrayList;
import java.util.Iterator;
import java.beans.FeatureDescriptor;
/**
* 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 JSP 2.1
*/
public class CompositeELResolver extends ELResolver {
/**
* 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();
}
elResolvers.add(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.
*/
public Object getValue(ELContext context,
Object base,
Object property) {
context.setPropertyResolved(false);
int i = 0, len = this.elResolvers.size();
ELResolver elResolver;
Object value;
while (i < len) {
elResolver = this.elResolvers.get(i);
value = elResolver.getValue(context, base, property);
if (context.isPropertyResolved()) {
return value;
}
i++;
}
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.
*/
public Class getType(ELContext context,
Object base,
Object property) {
context.setPropertyResolved(false);
int i = 0, len = this.elResolvers.size();
ELResolver elResolver;
Class type;
while (i < len) {
elResolver = this.elResolvers.get(i);
type = elResolver.getType(context, base, property);
if (context.isPropertyResolved()) {
return type;
}
i++;
}
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.
*/
public void setValue(ELContext context,
Object base,
Object property,
Object val) {
context.setPropertyResolved(false);
int i = 0, len = this.elResolvers.size();
ELResolver elResolver;
while (i < len) {
elResolver = this.elResolvers.get(i);
elResolver.setValue(context, base, property, val);
if (context.isPropertyResolved()) {
return;
}
i++;
}
}
/**
* 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.
*/
public boolean isReadOnly(ELContext context,
Object base,
Object property) {
context.setPropertyResolved(false);
int i = 0, len = this.elResolvers.size();
ELResolver elResolver;
boolean readOnly;
while (i < len) {
elResolver = this.elResolvers.get(i);
readOnly = elResolver.isReadOnly(context, base, property);
if (context.isPropertyResolved()) {
return readOnly;
}
i++;
}
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
*/
public Iterator getFeatureDescriptors(
ELContext context,
Object base) {
return new CompositeIterator(elResolvers.iterator(), 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.
*/
public Class getCommonPropertyType(ELContext context,
Object base) {
Class commonPropertyType = null;
Iterator iter = elResolvers.iterator();
while (iter.hasNext()) {
ELResolver elResolver = iter.next();
Class type = elResolver.getCommonPropertyType(context, base);
if (type == null) {
// skip this EL 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;
}
private final ArrayList elResolvers =
new ArrayList();
private static class CompositeIterator
implements Iterator {
Iterator compositeIter;
Iterator propertyIter;
ELContext context;
Object base;
CompositeIterator(Iterator iter,
ELContext context,
Object base) {
compositeIter = iter;
this.context = context;
this.base = base;
}
public boolean hasNext() {
if (propertyIter == null || !propertyIter.hasNext()) {
while (compositeIter.hasNext()) {
ELResolver elResolver = compositeIter.next();
propertyIter = elResolver.getFeatureDescriptors(
context, base);
if (propertyIter != null) {
return propertyIter.hasNext();
}
}
return false;
}
return propertyIter.hasNext();
}
public FeatureDescriptor next() {
if (propertyIter == null || !propertyIter.hasNext()) {
while (compositeIter.hasNext()) {
ELResolver elResolver = compositeIter.next();
propertyIter = elResolver.getFeatureDescriptors(
context, base);
if (propertyIter != null) {
return propertyIter.next();
}
}
return null;
}
return propertyIter.next();
}
public void remove() {
throw new UnsupportedOperationException();
}
}
}