/*
* Copyright 2010 Google Inc.
*
* 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 com.google.web.bindery.autobean.vm.impl;
import com.google.gwt.core.client.impl.WeakMapping;
import com.google.web.bindery.autobean.shared.AutoBean;
import com.google.web.bindery.autobean.shared.AutoBeanFactory;
import com.google.web.bindery.autobean.shared.AutoBeanUtils;
import com.google.web.bindery.autobean.shared.AutoBeanVisitor;
import com.google.web.bindery.autobean.shared.impl.AbstractAutoBean;
import com.google.web.bindery.autobean.vm.Configuration;
import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
/**
* An implementation of an AutoBean that uses reflection.
*
* @param <T> the type of interface being wrapped
*/
public class ProxyAutoBean<T> extends AbstractAutoBean<T> {
private static class Data {
final Class<?> elementType;
final Type genericType;
final Method getter;
final Class<?> keyType;
final PropertyType propertyType;
Method setter;
final Class<?> type;
final Class<?> valueType;
Data(Method getter, Type genericType, Class<?> type, PropertyType propertyType) {
this.getter = getter;
this.genericType = genericType;
this.type = type;
this.propertyType = propertyType;
if (propertyType == PropertyType.COLLECTION) {
elementType =
TypeUtils.ensureBaseType(TypeUtils.getSingleParameterization(Collection.class,
genericType, type));
keyType = valueType = null;
} else if (propertyType == PropertyType.MAP) {
elementType = null;
Type[] types = TypeUtils.getParameterization(Map.class, genericType, type);
keyType = TypeUtils.ensureBaseType(types[0]);
valueType = TypeUtils.ensureBaseType(types[1]);
} else {
elementType = keyType = valueType = null;
}
}
}
private enum PropertyType {
VALUE, REFERENCE, COLLECTION, MAP;
}
private static final Map<Class<?>, Map<String, Data>> cache =
new WeakHashMap<Class<?>, Map<String, Data>>();
/**
* Utility method to crete a new {@link Proxy} instance.
*
* @param <T> the interface type to be implemented by the Proxy
* @param intf the Class representing the interface type
* @param handler the implementation of the interface
* @param extraInterfaces additional interface types the Proxy should
* implement
* @return a Proxy instance
*/
public static <T> T makeProxy(Class<T> intf, InvocationHandler handler,
Class<?>... extraInterfaces) {
Class<?>[] intfs;
if (extraInterfaces == null) {
intfs = new Class<?>[] {intf};
} else {
intfs = new Class<?>[extraInterfaces.length + 1];
intfs[0] = intf;
System.arraycopy(extraInterfaces, 0, intfs, 1, extraInterfaces.length);
}
return intf.cast(Proxy.newProxyInstance(intf.getClassLoader(), intfs, handler));
}
private static Map<String, Data> calculateData(Class<?> beanType) {
Map<String, Data> toReturn;
synchronized (cache) {
toReturn = cache.get(beanType);
if (toReturn == null) {
Map<String, Data> getters = new HashMap<String, Data>();
List<Method> setters = new ArrayList<Method>();
for (Method method : beanType.getMethods()) {
if (BeanMethod.GET.matches(method)) {
// match methods on their name for now, to find the most specific
// override
String name = method.getName();
Type genericReturnType = TypeUtils.resolveGenerics(beanType, method.getGenericReturnType());
Class<?> returnType = TypeUtils.ensureBaseType(genericReturnType);
Data data = getters.get(name);
if (data == null || data.type.isAssignableFrom(returnType)) {
// no getter seen yet for the property, or a less specific one
PropertyType propertyType;
if (TypeUtils.isValueType(returnType)) {
propertyType = PropertyType.VALUE;
} else if (Collection.class.isAssignableFrom(returnType)) {
propertyType = PropertyType.COLLECTION;
} else if (Map.class.isAssignableFrom(returnType)) {
propertyType = PropertyType.MAP;
} else {
propertyType = PropertyType.REFERENCE;
}
data = new Data(method, genericReturnType, returnType, propertyType);
getters.put(name, data);
}
} else if (BeanMethod.SET.matches(method) || BeanMethod.SET_BUILDER.matches(method)) {
setters.add(method);
}
}
toReturn = new HashMap<String, Data>(getters.size());
// Now take @PropertyName into account
for (Map.Entry<String, Data> entry : getters.entrySet()) {
Data data = entry.getValue();
toReturn.put(BeanMethod.GET.inferName(data.getter), data);
}
// Associate setters to getters
for (Method setter : setters) {
String name = BeanMethod.SET.inferName(setter);
Data data = toReturn.get(name);
if (data != null && data.setter == null
&& data.getter.getReturnType().isAssignableFrom(setter.getParameterTypes()[0])) {
data.setter = setter;
}
}
cache.put(beanType, toReturn);
}
}
return toReturn;
}
private final Class<T> beanType;
private final Configuration configuration;
private final Map<String, Data> propertyData;
/**
* Because the shim and the ProxyAutoBean are related through WeakMapping, we
* need to ensure that the ProxyAutoBean doesn't artificially extend the
* lifetime of the shim. If there are no external references to the shim, it's
* ok if it's deallocated, since it has no interesting state.
*
* <pre>
* _________________ ______________
* | ProxyAutoBean | | Shim |
* | | <----------+-bean |
* | shim-+---X------> | |
* |_______________| |____________|
* ^ ^ ^
* X X |
* |__value__WeakMapping__key__| |
* ^ |
* | |
* GC Roots -> Owner____|
* </pre>
* <p>
* In the case of a wrapped object (for example, an ArrayList), the weak
* reference from WeakMapping to the ProxyAutoBean may cause the AutoBean to
* be prematurely collected if neither the bean nor the shim are referenced
* elsewhere. The alternative is a massive memory leak.
*/
private WeakReference<T> shim;
// These constructors mirror the generated constructors.
@SuppressWarnings("unchecked")
public ProxyAutoBean(AutoBeanFactory factory, Class<?> beanType, Configuration configuration) {
super(factory);
this.beanType = (Class<T>) beanType;
this.configuration = configuration;
this.propertyData = calculateData(beanType);
}
@SuppressWarnings("unchecked")
public ProxyAutoBean(AutoBeanFactory factory, Class<?> beanType, Configuration configuration,
T toWrap) {
super(toWrap, factory);
this.beanType = (Class<T>) beanType;
this.configuration = configuration;
this.propertyData = calculateData(beanType);
}
@Override
public T as() {
T toReturn = shim == null ? null : shim.get();
if (toReturn == null) {
toReturn = createShim();
shim = new WeakReference<T>(toReturn);
}
return toReturn;
}
public Configuration getConfiguration() {
return configuration;
}
public Class<T> getType() {
return beanType;
}
/**
* Allow access by {@link ShimHandler}.
*/
@Override
protected void call(String method, Object returned, Object... parameters) {
super.call(method, returned, parameters);
}
/**
* Allow access by {@link ShimHandler}.
*/
@Override
protected void checkFrozen() {
super.checkFrozen();
}
/**
* Allow access by {@link ShimHandler}.
*/
@Override
protected void checkWrapped() {
super.checkWrapped();
}
/**
* Not used in this implementation. Instead, the simple implementation is
* created lazily in {@link #getWrapped()}.
*/
@Override
protected T createSimplePeer() {
return null;
}
/**
* Allow access by {@link ShimHandler}.
*/
@Override
protected <V> V get(String method, V toReturn) {
return super.get(method, toReturn);
}
/**
* Allow access by BeanMethod.
*/
@Override
protected <V> V getOrReify(String propertyName) {
return super.<V> getOrReify(propertyName);
}
/**
* Allow access by {@link ShimHandler}.
*/
@Override
protected T getWrapped() {
if (wrapped == null && isUsingSimplePeer()) {
wrapped = ProxyAutoBean.<T> makeProxy(beanType, new SimpleBeanHandler<T>(this));
}
return super.getWrapped();
}
/**
* Allow access by {@link ShimHandler}.
*/
@Override
protected void set(String method, Object value) {
super.set(method, value);
}
@Override
protected void setProperty(String propertyName, Object value) {
super.setProperty(propertyName, value);
}
// TODO: Port to model-based when class-based TypeOracle is available.
@Override
protected void traverseProperties(AutoBeanVisitor visitor, OneShotContext ctx) {
for (Map.Entry<String, Data> entry : propertyData.entrySet()) {
String name = entry.getKey();
Data data = entry.getValue();
Method getter = data.getter;
PropertyType propertyType = data.propertyType;
// Use the shim to handle automatic wrapping
Object value;
try {
getter.setAccessible(true);
value = getter.invoke(as());
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e.getCause());
}
// Create the context used for the property visitation
MethodPropertyContext x;
if (isUsingSimplePeer()) {
x =
new BeanPropertyContext(this, name, data.genericType, data.type, data.elementType,
data.keyType, data.valueType);
} else {
x =
new GetterPropertyContext(this, getter, data.genericType, data.type, data.elementType,
data.keyType, data.valueType);
}
switch (propertyType) {
case VALUE: {
if (visitor.visitValueProperty(name, value, x)) {
}
visitor.endVisitValueProperty(name, value, x);
break;
}
case COLLECTION: {
// Workaround for generics bug in mac javac 1.6.0_22
@SuppressWarnings("rawtypes")
AutoBean temp = AutoBeanUtils.getAutoBean((Collection) value);
@SuppressWarnings("unchecked")
AutoBean<Collection<?>> bean = (AutoBean<Collection<?>>) temp;
if (visitor.visitCollectionProperty(name, bean, x)) {
if (value != null) {
((ProxyAutoBean<?>) bean).traverse(visitor, ctx);
}
}
visitor.endVisitCollectionProperty(name, bean, x);
break;
}
case MAP: {
// Workaround for generics bug in mac javac 1.6.0_22
@SuppressWarnings("rawtypes")
AutoBean temp = AutoBeanUtils.getAutoBean((Map) value);
@SuppressWarnings("unchecked")
AutoBean<Map<?, ?>> bean = (AutoBean<Map<?, ?>>) temp;
if (visitor.visitMapProperty(name, bean, x)) {
if (value != null) {
((ProxyAutoBean<?>) bean).traverse(visitor, ctx);
}
}
visitor.endVisitMapProperty(name, bean, x);
break;
}
case REFERENCE: {
ProxyAutoBean<?> bean = (ProxyAutoBean<?>) AutoBeanUtils.getAutoBean(value);
if (visitor.visitReferenceProperty(name, bean, x)) {
if (value != null) {
bean.traverse(visitor, ctx);
}
}
visitor.endVisitReferenceProperty(name, bean, x);
break;
}
}
}
}
private T createShim() {
T toReturn = ProxyAutoBean.makeProxy(beanType, new ShimHandler<T>(this, getWrapped()));
WeakMapping.setWeak(toReturn, AutoBean.class.getName(), this);
return toReturn;
}
}