/*
* JBoss, Home of Professional Open Source
* Copyright 2013, Red Hat, Inc. and individual contributors
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.richfaces.el;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.concurrent.ExecutionException;
import javax.el.ELContext;
import javax.el.ValueExpression;
import javax.faces.FacesException;
import javax.faces.context.FacesContext;
import com.google.common.base.Function;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
/**
* @author Nick Belaevski
*
*/
public class GenericsIntrospectionServiceImpl implements GenericsIntrospectionService {
private static final class GenericsCacheEntry {
private Class<?> beanClass;
private LoadingCache<String, Class<?>> containerClassesMap = CacheBuilder.newBuilder().initialCapacity(2)
.build(CacheLoader.from(new Function<String, Class<?>>() {
public Class<?> apply(String input) {
PropertyDescriptor propertyDescriptor = getPropertyDescriptor(input);
return getGenericContainerClass(propertyDescriptor);
}
}));
public GenericsCacheEntry(Class<?> beanClass) {
this.beanClass = beanClass;
}
private Class<?> resolveType(Type type) {
Class<?> result = Object.class;
if (type instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) type;
Type[] types = parameterizedType.getActualTypeArguments();
if (types != null && types.length != 0) {
Type actualType = types[0];
if (actualType instanceof Class) {
result = (Class<?>) actualType;
}
}
}
return result;
}
private Class<?> getGenericContainerClass(PropertyDescriptor pd) {
if (pd == null) {
return null;
}
Method readMethod = pd.getReadMethod();
if (readMethod == null) {
return null;
}
return resolveType(readMethod.getGenericReturnType());
}
private PropertyDescriptor getPropertyDescriptor(String propertyName) {
BeanInfo beanInfo = null;
try {
beanInfo = Introspector.getBeanInfo(beanClass);
} catch (IntrospectionException e) {
throw new FacesException(e.getMessage(), e);
} finally {
Introspector.flushFromCaches(beanClass);
}
if (beanInfo == null) {
return null;
}
PropertyDescriptor[] propertyDescriptorsArray = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor pd : propertyDescriptorsArray) {
if (propertyName.equals(pd.getName())) {
return pd;
}
}
return null;
}
public Class<?> getContainerClass(String propertyName) throws ExecutionException {
return containerClassesMap.get(propertyName);
}
}
private final LoadingCache<Class<?>, GenericsCacheEntry> cache = CacheBuilder.newBuilder().weakKeys().softValues()
.build(CacheLoader.from(new Function<Class<?>, GenericsCacheEntry>() {
public GenericsCacheEntry apply(java.lang.Class<?> input) {
return new GenericsCacheEntry(input);
}
}));
private Class<?> getGenericCollectionType(FacesContext context, Object base, String propertyName) {
Class<?> genericPropertyClass = null;
if ((base != null) && (propertyName != null)) {
Class<? extends Object> beanClass = base.getClass();
// Map and ResourceBundle have special resolvers that we doesn't support
if (!Map.class.isAssignableFrom(beanClass) && !ResourceBundle.class.isAssignableFrom(beanClass)) {
try {
return cache.get(beanClass).getContainerClass(propertyName);
} catch (ExecutionException e) {
throw new FacesException(String.format("Can't resolve the beanClass '%s' from propertyName '%s'", beanClass, propertyName), e);
}
}
}
return genericPropertyClass;
}
public Class<?> getContainerClass(FacesContext facesContext, ValueExpression expression) {
ELContext initialELContext = facesContext.getELContext();
CapturingELResolver capturingELResolver = new CapturingELResolver(initialELContext.getELResolver());
Class<?> type = expression.getType(new ELContextWrapper(initialELContext, capturingELResolver));
Class<?> containerType = type.getComponentType();
if ((containerType == null) && (type != null)) {
if (Collection.class.isAssignableFrom(type)) {
Object base = capturingELResolver.getBase();
Object property = capturingELResolver.getProperty();
if ((base != null) && (property != null)) {
containerType = getGenericCollectionType(facesContext, base, property.toString());
}
}
}
return containerType;
}
}