/*
* JBoss, Home of Professional Open Source
* Copyright 2007, Red Hat Middleware LLC, 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.jboss.managed.plugins.factory;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import org.jboss.beans.info.spi.BeanInfo;
import org.jboss.beans.info.spi.PropertyInfo;
import org.jboss.config.plugins.property.PropertyConfiguration;
import org.jboss.config.spi.Configuration;
import org.jboss.managed.api.ManagedObject;
import org.jboss.managed.api.ManagedProperty;
import org.jboss.managed.api.MutableManagedObject;
import org.jboss.managed.api.annotation.ManagementObjectRef;
import org.jboss.managed.api.annotation.ManagementRuntimeRef;
import org.jboss.managed.api.factory.ManagedObjectFactory;
import org.jboss.managed.spi.factory.InstanceClassFactory;
import org.jboss.managed.spi.factory.RuntimeComponentNameTransformer;
import org.jboss.metadata.spi.MetaData;
import org.jboss.metatype.api.types.ArrayMetaType;
import org.jboss.metatype.api.types.CollectionMetaType;
import org.jboss.metatype.api.types.MetaType;
import org.jboss.metatype.api.values.ArrayValueSupport;
import org.jboss.metatype.api.values.CollectionValueSupport;
import org.jboss.metatype.api.values.GenericValue;
import org.jboss.metatype.api.values.GenericValueSupport;
import org.jboss.metatype.api.values.MetaValue;
import org.jboss.metatype.api.values.MetaValueFactory;
import org.jboss.metatype.plugins.values.DefaultMetaValueFactory;
import org.jboss.metatype.spi.values.MetaMapper;
import org.jboss.reflect.spi.TypeInfo;
import org.jboss.util.NotImplementedException;
/**
* A base InstanceClassFactory implementation that uses jboss reflection to
* get/set values on the underlying property object.
*
* Runtime component names are handled via a mapping from TypeInfo to
* {@linkplain RuntimeComponentNameTransformer} using property ManagementRuntimeRef
* information.
*
* @param <T> the instance type
* @author Scott.Stark@jboss.org
* @version $Revision: 81571 $
*/
public abstract class AbstractInstanceClassFactory<T>
implements InstanceClassFactory<T>
{
/** The configuration */
private Configuration configuration = new PropertyConfiguration();
/** The meta value factory */
private MetaValueFactory metaValueFactory = MetaValueFactory.getInstance();
/** The instance to name transformers */
private Map<TypeInfo, RuntimeComponentNameTransformer> transformers = new WeakHashMap<TypeInfo, RuntimeComponentNameTransformer>();
/** The ManagedObjectFactory used in getValue for MANAGED_OBJECT_META_TYPEs */
private ManagedObjectFactory mof;
public AbstractInstanceClassFactory()
{
this(null);
}
/**
* Create an AbstractInstanceClassFactory with a ManagedObjectFactory. The
* ManagedObjectFactory is neede for GenericValue creation.
* @param mof - the ManagedObjectFactory delegated to for GenericValue handling.
* @see #getManagedObjectValue(BeanInfo, ManagedProperty, Object)
* @see #getManagedObjectArray(BeanInfo, ManagedProperty, Object)
*/
public AbstractInstanceClassFactory(ManagedObjectFactory mof)
{
this.mof = mof;
}
public Map<TypeInfo, RuntimeComponentNameTransformer> getTransformers()
{
return transformers;
}
public void setTransformers(Map<TypeInfo, RuntimeComponentNameTransformer> transformers)
{
this.transformers = transformers;
}
public void setNameTransformers(Class<?> clazz, RuntimeComponentNameTransformer transformer)
{
TypeInfo type = configuration.getTypeInfo(clazz);
setNameTransformers(type, transformer);
}
public void setNameTransformers(TypeInfo type, RuntimeComponentNameTransformer transformer)
{
synchronized (transformers)
{
if (transformer == null)
transformers.remove(type);
else
transformers.put(type, transformer);
}
}
public Configuration getConfiguration()
{
return configuration;
}
public void setConfiguration(Configuration configuration)
{
this.configuration = configuration;
}
public MetaValueFactory getMetaValueFactory()
{
return metaValueFactory;
}
public void setMetaValueFactory(MetaValueFactory metaValueFactory)
{
this.metaValueFactory = metaValueFactory;
}
public ManagedObjectFactory getMof()
{
return mof;
}
public void setMof(ManagedObjectFactory mof)
{
this.mof = mof;
}
/**
* Default InstanceClassFactory implementation simply returns the
* attachment class.
*/
public Class<?> getManagedObjectClass(T attachment)
throws ClassNotFoundException
{
return attachment.getClass();
}
public Object getComponentName(BeanInfo beanInfo, ManagedProperty property,
T attachment, MetaValue value)
{
if (beanInfo != null && property != null && value != null)
{
String name = getPropertyName(property);
PropertyInfo propertyInfo = beanInfo.getProperty(name);
ManagementRuntimeRef componentRef = propertyInfo.getUnderlyingAnnotation(ManagementRuntimeRef.class);
if (componentRef != null)
{
Object original = this.unwrapValue(beanInfo, property, value);
try
{
Class<? extends RuntimeComponentNameTransformer> tClass = componentRef.transformer();
RuntimeComponentNameTransformer transformer;
if (tClass != ManagementRuntimeRef.DEFAULT_NAME_TRANSFORMER.class)
transformer = getComponentNameTransformer(configuration.getTypeInfo(tClass));
else
transformer = getComponentNameTransformer(propertyInfo.getType());
return (transformer != null) ? transformer.transform(original) : original;
}
catch (Throwable t)
{
throw new UndeclaredThrowableException(t);
}
}
}
return null;
}
public MetaValue getValue(BeanInfo beanInfo, ManagedProperty property,
MetaData metaData, T object)
{
String name = getPropertyName(property);
PropertyInfo propertyInfo = beanInfo.getProperty(name);
Object value;
try
{
value = propertyInfo.get(object);
}
catch (RuntimeException e)
{
throw e;
}
catch (Error e)
{
throw e;
}
catch (Throwable t)
{
throw new RuntimeException("Error getting property " + name + " for " + object.getClass().getName(), t);
}
if (value == null)
return null;
MetaType propertyType = property.getMetaType();
// Look for a MetaMapper
MetaMapper metaMapper = property.getTransientAttachment(MetaMapper.class);
if(metaMapper != null)
{
MetaValue mvalue = metaMapper.createMetaValue(propertyType, value);
return mvalue;
}
// Otherwise use the MetaValueFactory
if (AbstractManagedObjectFactory.MANAGED_OBJECT_META_TYPE == propertyType)
{
return getManagedObjectValue(beanInfo, property, metaData, value);
}
else if (propertyType.isArray())
{
ArrayMetaType arrayType = ArrayMetaType.class.cast(propertyType);
if (AbstractManagedObjectFactory.MANAGED_OBJECT_META_TYPE == arrayType.getElementType())
{
ArrayMetaType moType = new ArrayMetaType(1, AbstractManagedObjectFactory.MANAGED_OBJECT_META_TYPE);
ArrayValueSupport moArrayValue = new ArrayValueSupport(moType);
List<GenericValue> tmp = getManagedObjectArray(beanInfo, property, metaData, value);
GenericValue[] mos = new GenericValue[tmp.size()];
moArrayValue.setValue(tmp.toArray(mos));
return moArrayValue;
}
}
else if (propertyType.isCollection())
{
CollectionMetaType collectionType = CollectionMetaType.class.cast(propertyType);
if (AbstractManagedObjectFactory.MANAGED_OBJECT_META_TYPE == collectionType.getElementType())
{
List<GenericValue> tmp = getManagedObjectArray(beanInfo, property, metaData, value);
GenericValue[] mos = new GenericValue[tmp.size()];
CollectionMetaType moType = new CollectionMetaType(propertyType.getClassName(), AbstractManagedObjectFactory.MANAGED_OBJECT_META_TYPE);
tmp.toArray(mos);
return new CollectionValueSupport(moType, mos);
}
}
return getNonManagedObjectValue(beanInfo, property, propertyInfo, value);
}
/**
* Set a value
*
* @param beanInfo the bean info
* @param property the property
* @param object the object
* @param value the meta value
*/
public void setValue(BeanInfo beanInfo, ManagedProperty property, T object, MetaValue value)
{
String name = getPropertyName(property);
PropertyInfo propertyInfo = beanInfo.getProperty(name);
Object unwrapValue = unwrapValue(beanInfo, property, value);
try
{
if(unwrapValue instanceof ManagedObject)
{
ManagedObject mo = (ManagedObject) unwrapValue;
setManagedObject(beanInfo, propertyInfo, object, mo);
}
else
setValue(beanInfo, propertyInfo, object, unwrapValue);
}
catch(Throwable t)
{
throw new UndeclaredThrowableException(t);
}
}
public GenericValue getManagedObjectValue(ManagedProperty property,
ManagedObject value)
{
return getManagedObjectValue(null, property, null, value);
}
public GenericValue getManagedObjectValue(ManagedProperty property, MetaData metaData,
ManagedObject value)
{
return getManagedObjectValue(null, property, metaData, value);
}
protected GenericValue getManagedObjectValue(BeanInfo beanInfo, ManagedProperty property,
MetaData metaData, Object value)
{
// Look for a ManagementObjectRef
ManagementObjectRef ref = (ManagementObjectRef) property.getAnnotations().get(ManagementObjectRef.class.getName());
String moName = (ref != null ? ref.name() : value.getClass().getName());
String moNameType = (ref != null ? ref.type() : "");
ManagedObject mo;
if(value instanceof ManagedObject)
mo = ManagedObject.class.cast(value);
else
mo = mof.initManagedObject(value, null, metaData, moName, moNameType);
ManagedObject parentMO = property.getManagedObject();
if(parentMO != null && mo instanceof MutableManagedObject)
{
MutableManagedObject mmo = (MutableManagedObject) mo;
mmo.setParent(parentMO);
}
return new GenericValueSupport(AbstractManagedObjectFactory.MANAGED_OBJECT_META_TYPE, mo);
}
protected List<GenericValue> getManagedObjectArray(BeanInfo beanInfo, ManagedProperty property,
MetaData metaData, Object value)
{
Collection<?> cvalue = getAsCollection(value);
List<GenericValue> tmp = new ArrayList<GenericValue>();
for(Object element : cvalue)
{
GenericValue gv = getManagedObjectValue(beanInfo, property, metaData, element);
tmp.add(gv);
}
return tmp;
}
protected MetaValue getNonManagedObjectValue(BeanInfo beanInfo, ManagedProperty property,
PropertyInfo propertyInfo, Object value)
{
return metaValueFactory.create(value, propertyInfo.getType());
}
/**
* Currently just a stub method subclasses have to override to avoid
* the NotImplementedException.
*
* TODO: how to map the managed properties onto the corresponding attachment
* object, create another ManagedObject?
*
* @param beanInfo
* @param propertyInfo
* @param object
* @param mo
*/
protected void setManagedObject(BeanInfo beanInfo, PropertyInfo propertyInfo,
T object, ManagedObject mo)
{
throw new NotImplementedException("Use a custom InstanceClassFactory, property="+propertyInfo);
}
/**
* Get component name transformer.
*
* @param type the type info
* @return transformer instance
* @throws Throwable for any error
*/
protected RuntimeComponentNameTransformer getComponentNameTransformer(TypeInfo type) throws Throwable
{
synchronized(transformers)
{
RuntimeComponentNameTransformer transformer = transformers.get(type);
if (transformer != null)
return transformer;
TypeInfo rcntType = configuration.getTypeInfo(RuntimeComponentNameTransformer.class);
if (rcntType.isAssignableFrom(type))
{
BeanInfo beanInfo = configuration.getBeanInfo(type);
RuntimeComponentNameTransformer newTransformer = (RuntimeComponentNameTransformer)beanInfo.newInstance();
transformers.put(type, newTransformer);
return newTransformer;
}
return null;
}
}
protected Object unwrapValue(BeanInfo beanInfo, ManagedProperty property, MetaValue value)
{
String name = getPropertyName(property);
PropertyInfo propertyInfo = beanInfo.getProperty(name);
// Look for a property MetaMapper
MetaMapper metaMapper = property.getTransientAttachment(MetaMapper.class);
if(metaMapper != null)
{
return metaMapper.unwrapMetaValue(value);
}
return metaValueFactory.unwrap(value, propertyInfo.getType());
}
protected void setValue(BeanInfo beanInfo, PropertyInfo propertyInfo, Object object, Object unwrapValue)
throws Throwable
{
if(unwrapValue == null && propertyInfo.getType().isPrimitive())
{
unwrapValue = DefaultMetaValueFactory.mapNullToPrimitive(propertyInfo.getType());
}
propertyInfo.set(object, unwrapValue);
}
protected Collection<?> getAsCollection(Object value)
{
if( value.getClass().isArray() )
return Arrays.asList(value);
else if (value instanceof Collection)
return Collection.class.cast(value);
return null;
}
/**
* Get the property name.
*
* @param property managed property
* @return property name
*/
protected String getPropertyName(ManagedProperty property)
{
// First look to the mapped name
String name = property.getMappedName();
if (name == null)
property.getName();
return name;
}
}