BeanDescriptor.java

package com.dragome.forms.bindings.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.HashMap;

import com.dragome.forms.bindings.client.bean.AbstractPropertyDescriptor;
import com.dragome.forms.bindings.client.bean.NotCollectionPropertyException;
import com.dragome.forms.bindings.client.bean.Path;
import com.dragome.forms.bindings.client.bean.PropertyDescriptor;
import com.dragome.forms.bindings.client.bean.ReadOnlyPropertyException;
import com.dragome.forms.bindings.client.bean.TargetBeanIsNullException;
import com.dragome.forms.bindings.client.bean.UnknownPropertyException;

/**
 * Created by IntelliJ IDEA.
 * User: andrew
 * Date: Jun 1, 2010
 * Time: 11:34:01 AM
 * To change this template use File | Settings | File Templates.
 */
class BeanDescriptor
{
	private Class beanClass;
	private HashMap<String, PropertyDescriptor> descriptors= new HashMap<String, PropertyDescriptor>();
	private HashMap<Class<?>, Class<?>> primitives= new HashMap<Class<?>, Class<?>>();

	public BeanDescriptor(Class beanClass)
	{
		this.beanClass= beanClass;
		primitives.put(boolean.class, Boolean.class);
		primitives.put(char.class, Character.class);
		primitives.put(byte.class, Byte.class);
		primitives.put(short.class, Short.class);
		primitives.put(int.class, Integer.class);
		primitives.put(long.class, Long.class);
		primitives.put(float.class, Float.class);
		primitives.put(double.class, Double.class);
	}

	public PropertyDescriptor getPropertyDescriptor(Path path)
	{
		PropertyDescriptor descriptor= descriptors.get(path.getPropertyName());

		if (descriptor == null)
		{
			ensurePropertyExists(path);
			descriptor= new PropertyDescriptorImpl(path, beanClass, isMutable(path));
			descriptors.put(path.getPropertyName(), descriptor);
		}

		return descriptor;
	}

	private boolean isMutable(Path path)
	{
		// the getter exists...
		getGetter(path);

		try
		{
			// oh so hacky...
			getSetter(path);
			return true;
		}
		catch (ReadOnlyPropertyException e)
		{
			return false;
		}
	}

	public Object readProperty(Object bean, Path path) throws UnknownPropertyException
	{
		if (bean == null)
		{
			return null;
		}

		try
		{
			return getGetter(path).invoke(bean);
		}
		catch (IllegalAccessException e)
		{
			throw new UnknownPropertyException(path);
		}
		catch (InvocationTargetException e)
		{
			throw new UnknownPropertyException(path);
		}
	}

	public void writeProperty(Object bean, Path path, Object value) throws UnknownPropertyException, ReadOnlyPropertyException, TargetBeanIsNullException
	{
		if (bean == null)
		{
			throw new TargetBeanIsNullException(path, beanClass);
		}

		Method setter= getSetter(path);

		try
		{
			setter.invoke(bean, value);
		}
		catch (IllegalAccessException e)
		{
			throw new UnknownPropertyException(path);
		}
		catch (InvocationTargetException e)
		{
			throw new UnknownPropertyException(path);
		}
	}

	private void ensurePropertyExists(Path path)
	{
		// oh so hacky...
		getGetter(path);
	}

	private Method findMethod(String methodName, Class... parameterTypes) throws NoSuchMethodException
	{
		Class theClass= this.beanClass;
		while (true)
		{
			//System.out.println("hola mundo");
			int a= 1;
			try
			{
				return theClass.getMethod(methodName, parameterTypes);
			}
			catch (NoSuchMethodException e)
			{
				theClass= theClass.getSuperclass();
				if (theClass == null)
				{
					throw new NoSuchMethodException();
				}
			}
		}
	}

	private Method getGetter(Path path) throws UnknownPropertyException
	{
		try
		{
			return findMethod("get" + capitalise(path.getPropertyName()));
		}
		catch (NoSuchMethodException e)
		{
			try
			{
				// should really test it's return type is boolean...
				return findMethod("is" + capitalise(path.getPropertyName()));
			}
			catch (NoSuchMethodException e1)
			{
				throw new UnknownPropertyException(path);
			}
		}
	}

	private Method getSetter(Path path) throws ReadOnlyPropertyException
	{
		try
		{
			return beanClass.getMethod("set" + capitalise(path.getPropertyName()), getRawPropertyType(path));
		}
		catch (NoSuchMethodException e)
		{
			throw new ReadOnlyPropertyException(path);
		}
	}

	public Class getPropertyType(Path path)
	{
		Class<?> type= getRawPropertyType(path);
		return type.isPrimitive() ? primitives.get(type) : type;
	}

	private Class<?> getRawPropertyType(Path path)
	{
		return getGetter(path).getReturnType();
	}

	public Class getElementType(Path path)
	{
		Method method= getGetter(path);
		Class<?> type= method.getReturnType();

		if (!Collection.class.isAssignableFrom(type))
		{
			throw new NotCollectionPropertyException(path, type);
		}

		Type returnType= method.getGenericReturnType();

		if (returnType instanceof ParameterizedType)
		{
			Type[] typeArgs= ((ParameterizedType) returnType).getActualTypeArguments();
			return typeArgs.length == 1 ? (Class) typeArgs[0] : Object.class;
		}
		else
		{
			return Object.class;
		}
	}

	private String capitalise(String property)
	{
		return property.substring(0, 1).toUpperCase() + property.substring(1);
	}

	private class PropertyDescriptorImpl extends AbstractPropertyDescriptor
	{
		public PropertyDescriptorImpl(Path path, Class beanClass, boolean mutable)
		{
			super(path.getFullPath(), path.getParentPath(), path.getPropertyName(), beanClass, mutable);
		}

		public Class getValueType()
		{
			return getPropertyType(this);
		}

		public Class getElementType() throws NotCollectionPropertyException
		{
			return BeanDescriptor.this.getElementType(this);
		}

		public boolean isCollection()
		{
			return Collection.class.isAssignableFrom(getValueType());
		}

		public Object readProperty(Object bean)
		{
			return BeanDescriptor.this.readProperty(bean, this);
		}

		public void writeProperty(Object bean, Object value) throws ReadOnlyPropertyException, TargetBeanIsNullException
		{
			BeanDescriptor.this.writeProperty(bean, this, value);
		}
	}
}