/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.shindig.social.core.util.xstream;
import com.google.common.collect.Lists;
import com.google.inject.Injector;
import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
import com.thoughtworks.xstream.core.util.OrderRetainingMap;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.WeakHashMap;
/**
*
*/
public class GuiceBeanProvider {
protected static final Object[] NO_PARAMS = new Object[0];
private final Comparator<String> propertyNameComparator;
private final transient Map<Class<?>, Map<String, PropertyDescriptor>> propertyNameCache = new WeakHashMap<Class<?>, Map<String, PropertyDescriptor>>();
private Injector injector;
public GuiceBeanProvider(Injector injector) {
this(injector, null);
}
public GuiceBeanProvider(Injector injector,
final Comparator<String> propertyNameComparator) {
this.propertyNameComparator = propertyNameComparator;
this.injector = injector;
}
public Object newInstance(Class<?> type) {
return injector.getInstance(type);
}
public void visitSerializableProperties(Object object, Visitor visitor) {
PropertyDescriptor[] propertyDescriptors = getSerializableProperties(object);
for (int i = 0; i < propertyDescriptors.length; i++) {
PropertyDescriptor property = propertyDescriptors[i];
try {
Method readMethod = property.getReadMethod();
String name = property.getName();
Class<?> definedIn = readMethod.getDeclaringClass();
if (visitor.shouldVisit(name, definedIn)) {
Object value = readMethod.invoke(object, new Object[0]);
visitor.visit(name, property.getPropertyType(), definedIn, value);
}
} catch (IllegalArgumentException e) {
throw new ObjectAccessException("Could not get property "
+ object.getClass() + "." + property.getName(), e);
} catch (IllegalAccessException e) {
throw new ObjectAccessException("Could not get property "
+ object.getClass() + "." + property.getName(), e);
} catch (InvocationTargetException e) {
throw new ObjectAccessException("Could not get property "
+ object.getClass() + "." + property.getName(), e);
}
}
}
public void writeProperty(Object object, String propertyName, Object value) {
PropertyDescriptor property = getProperty(propertyName, object.getClass());
try {
property.getWriteMethod().invoke(object, new Object[] { value });
} catch (IllegalArgumentException e) {
throw new ObjectAccessException("Could not set property "
+ object.getClass() + "." + property.getName(), e);
} catch (IllegalAccessException e) {
throw new ObjectAccessException("Could not set property "
+ object.getClass() + "." + property.getName(), e);
} catch (InvocationTargetException e) {
throw new ObjectAccessException("Could not set property "
+ object.getClass() + "." + property.getName(), e);
}
}
public Class<?> getPropertyType(Object object, String name) {
return getProperty(name, object.getClass()).getPropertyType();
}
public boolean propertyDefinedInClass(String name, Class<?> type) {
return getProperty(name, type) != null;
}
private PropertyDescriptor[] getSerializableProperties(Object object) {
Map<String, PropertyDescriptor> nameMap = getNameMap(object.getClass());
List<PropertyDescriptor> result = Lists.newArrayListWithExpectedSize(nameMap.size());
Set<String> names = nameMap.keySet();
if (propertyNameComparator != null) {
Set<String> sortedSet = new TreeSet<String>(propertyNameComparator);
sortedSet.addAll(names);
names = sortedSet;
}
for (final String name : names) {
final PropertyDescriptor descriptor = nameMap.get(name);
if (canStreamProperty(descriptor)) {
result.add(descriptor);
}
}
return result.toArray(new PropertyDescriptor[result.size()]);
}
protected boolean canStreamProperty(PropertyDescriptor descriptor) {
return descriptor.getReadMethod() != null
&& descriptor.getWriteMethod() != null;
}
public boolean propertyWriteable(String name, Class<?> type) {
PropertyDescriptor property = getProperty(name, type);
return property.getWriteMethod() != null;
}
private PropertyDescriptor getProperty(String name, Class<?> type) {
return (PropertyDescriptor) getNameMap(type).get(name);
}
private Map<String, PropertyDescriptor> getNameMap(Class<?> type) {
Map<String, PropertyDescriptor> nameMap = propertyNameCache.get(type);
if (nameMap == null) {
BeanInfo beanInfo;
try {
beanInfo = Introspector.getBeanInfo(type, Object.class);
} catch (IntrospectionException e) {
throw new ObjectAccessException("Cannot get BeanInfo of type "
+ type.getName(), e);
}
nameMap = new OrderRetainingMap();
propertyNameCache.put(type, nameMap);
PropertyDescriptor[] propertyDescriptors = beanInfo
.getPropertyDescriptors();
for (int i = 0; i < propertyDescriptors.length; i++) {
PropertyDescriptor descriptor = propertyDescriptors[i];
nameMap.put(descriptor.getName(), descriptor);
}
}
return nameMap;
}
interface Visitor {
boolean shouldVisit(String name, Class<?> definedIn);
void visit(String name, Class<?> type, Class<?> definedIn, Object value);
}
}