/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of Java-Common.
    *
    * Java-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * Java-Common 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 General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with Java-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.introspection;
  
  import java.beans.FeatureDescriptor;
  import java.beans.IntrospectionException;
  import java.beans.Introspector;
  import java.beans.MethodDescriptor;
  import java.beans.PropertyDescriptor;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Member;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  
  
  /**
   * The BeanIntrospector class helps read and write property values from a Java
   * Bean and provides methods for easier manipulation of PropertyDescriptor
   * arrays.
   *
   * @author Miha Kadunc
   * @version $id$
   */
  public class BeanIntrospector
  {
  	/**
  	 * Gets the value of the property specified by  <code>propertyName</code>
  	 * on the <code>target</code> object. Primitive types are returned in
  	 * equivalent Java objects.
  	 *
  	 * @param target the object containing the property
  	 * @param propertyName the name of the property to get
  	 *
  	 * @return Object the value of the property
  	 *
  	 * @throws java.beans.IntrospectionException if an illegal property name is
  	 *         specified or the target object is not a Java bean
  	 * @throws java.lang.reflect.InvocationTargetException when an exception is
  	 *         thrown inside the property getter
  	 * @throws IllegalAccessException when property access is restricted on the
  	 *         target object
  	 */
  	public static Object getPropertyValue(Object target, String propertyName)
  		throws java.beans.IntrospectionException, 
  			java.lang.reflect.InvocationTargetException, IllegalAccessException
  	{
  		assert (target != null);
  		assert (propertyName != null);
  
  		PropertyDescriptor pd = getPropertyDescriptor(target.getClass(),
  			    propertyName);
  		Method m = pd.getReadMethod();
  		Object[] params = new Object[0];
  
  		if (m == null) {
  			return null;
  		}
  
  		return m.invoke(target, params);
  	}
  
  	/**
  	 * Returns a Name-Value map of all the properties on a given object
  	 *
  	 * @param target Object
  	 *
  	 * @return Map
  	 *
  	 * @throws java.beans.IntrospectionException
  	 * @throws java.lang.reflect.InvocationTargetException
  	 * @throws IllegalAccessException
  	 * @throws NullPointerException DOCUMENT ME!
  	 */
  	public static Map getProperties(Object target)
  		throws java.beans.IntrospectionException, 
  			java.lang.reflect.InvocationTargetException, IllegalAccessException
  	{
  		if (target == null) {
  			throw new NullPointerException("target");
 		}
 
 		PropertyDescriptor[] pds = getPropertyDescriptors(target.getClass());
 
 		return getProperties(pds, target);
 	}
 
 	/**
 	 * Returns a Name-Value map of properties described by the array of type
 	 * <code>PropertyDescriptor</code>s; Values are retrieved from  the
 	 * <code>target</code> object.
 	 *
 	 * @param properties PropertyDescriptor[]
 	 * @param target Object
 	 *
 	 * @return Map
 	 *
 	 * @throws java.beans.IntrospectionException
 	 * @throws java.lang.reflect.InvocationTargetException
 	 * @throws IllegalAccessException
 	 */
 	public static Map getProperties(PropertyDescriptor[] properties,
 	    Object target)
 		throws java.beans.IntrospectionException, 
 			java.lang.reflect.InvocationTargetException, IllegalAccessException
 	{
 		Method m = null;
 		Object[] params = null;
 		HashMap ret = new HashMap(properties.length);
 
 		for (int i = 0; i < properties.length; i++) {
 			m = properties[i].getReadMethod();
 			params = new Object[0];
 
 			if (m != null) {
 				ret.put(properties[i].getName(), m.invoke(target, params));
 			}
 		}
 
 		return ret;
 	}
 
 	/**
 	 * Sets the value of the specified property on the <code>target</code>
 	 * object.
 	 *
 	 * @param target the object containing the property
 	 * @param propertyName name of the property
 	 * @param value the new value of the property
 	 *
 	 * @exception NoSuchMethodException if the setter does not exist
 	 * @exception InvocationTargetException reflection exception
 	 * @exception IllegalAccessException reflection exception
 	 */
 	public static void setPropertyValue(Object target, String propertyName,
 	    Object value)
 		throws NoSuchMethodException, InvocationTargetException, 
 			IllegalAccessException
 	{
 		assert target != null;
 		assert propertyName != null;
 
 		Method m = getSetterMethod(target.getClass(), propertyName);
 
 		if (m == null) {
 			throw new NoSuchMethodException("Property setter for '"
 			    + propertyName + "' does not exist on '" + target.getClass()
 			    + "'.");
 		}
 
 		Object[] args = new Object[1];
 		args[0] = value;
 		m.invoke(target, args);
 	}
 
 	/**
 	 * Gets a setter method for a property specified by propertyName
 	 *
 	 * @param inspectedBean Class
 	 * @param propertyName String
 	 *
 	 * @return Method the setter method for the property
 	 */
 	public static Method getSetterMethod(Class inspectedBean,
 	    String propertyName)
 	{
 		Method[] methods = inspectedBean.getMethods();
 
 		Method method = null;
 		Method retVal = null;
 
 		String setName = "set" + propertyName;
 
 		for (int i = 0; i < methods.length; i++) {
 			method = methods[i];
 
 			if (method.getName().equalsIgnoreCase(setName)
 			    && (method.getParameterTypes().length == 1)) {
 				if (retVal == null) {
 					retVal = method;
 				} else {
 					if (retVal.getDeclaringClass().isAssignableFrom(method
 					        .getDeclaringClass())) {
 						retVal = method;
 					}
 				}
 			}
 		}
 
 		return retVal;
 	}
 
 	/**
 	 * Retrieves the <code>FeatureDescriptor</code> for a member from an array
 	 * of <code>FeatureDescriptor</code>s. Member should be the method that is
 	 * desribed by a MethodDescriptor or the read method of a property
 	 * described by PropertyDescriptor.
 	 *
 	 * @param descriptors PropertyDescriptor[]
 	 * @param m String
 	 *
 	 * @return java.beans.PropertyDescriptor
 	 */
 	public static FeatureDescriptor getDescriptor(
 	    FeatureDescriptor[] descriptors, Member m)
 	{
 		for (int i = 0; i < descriptors.length; i++) {
 			if (descriptors[i] instanceof MethodDescriptor) {
 				MethodDescriptor md = (MethodDescriptor)descriptors[i];
 
 				if (md.getMethod().equals(m)) {
 					return md;
 				}
 			} else if (descriptors[i] instanceof PropertyDescriptor) {
 				PropertyDescriptor pd = (PropertyDescriptor)descriptors[i];
 
 				if ((pd.getReadMethod().equals(m))
 				    || (pd.getWriteMethod().equals(m))) {
 					return pd;
 				}
 			}
 		}
 
 		return null;
 	}
 
 	/**
 	 * Retrieves the <code>FeatureDescriptor</code> for a member from an array
 	 * of <code>FeatureDescriptor</code>s given the feature's name. Feature
 	 * can be a property, a method, or an event set.
 	 *
 	 * @param descriptors FeatureDescriptor[]
 	 * @param featureName String
 	 *
 	 * @return java.beans.FeatureDescriptor
 	 */
 	public static FeatureDescriptor getDescriptorByName(
 	    FeatureDescriptor[] descriptors, String featureName)
 	{
 		for (int i = 0; i < descriptors.length; i++) {
 			if (descriptors[i].getName().equals(featureName)) {
 				return descriptors[i];
 			}
 		}
 
 		return null;
 	}
 
 	/**
 	 * Returns descriptors of the properties declared in interfaces that the
 	 * current class implements, following the interface hierarchy to the
 	 * <code>superInterface</code> specified. Descriptors of properties that
 	 * are declared in the class itself or an interface, that is not a
 	 * descendant of the specified interface, are not returned.
 	 *
 	 * @param theClass Class
 	 * @param superInterface Class
 	 *
 	 * @return java.beans.PropertyDescriptor
 	 */
 	public static PropertyDescriptor[] getInterfacePropertyDescriptors(
 	    Class theClass, Class superInterface)
 	{
 		HashSet set = new HashSet();
 		internalGetInterfacePropertyDescriptors(theClass, superInterface, set);
 
 		PropertyDescriptor[] retVal = new PropertyDescriptor[set.size()];
 		set.toArray(retVal);
 
 		return retVal;
 	}
 
 	/**
 	 * Returns descriptor for the property with specified property name of bean
 	 * with <code>beanClass</code>
 	 *
 	 * @param beanClass the Class of the bean to introspect
 	 * @param propertyName the property name
 	 *
 	 * @return java.beans.PropertyDescriptor
 	 *
 	 * @throws IntrospectionException
 	 */
 	public static PropertyDescriptor getPropertyDescriptor(Class beanClass,
 	    String propertyName) throws IntrospectionException
 	{
 		return (PropertyDescriptor)getDescriptorByName(getPropertyDescriptors(
 		        beanClass), propertyName);
 	}
 
 	/**
 	 * Returns the type of the specified property on specified bean.
 	 *
 	 * @param beanClass the Class of the bean to introspect
 	 * @param propertyName the property name
 	 *
 	 * @return the property type
 	 *
 	 * @throws IntrospectionException
 	 */
 	public static Class getPropertyType(Class beanClass, String propertyName)
 		throws IntrospectionException
 	{
 		return getPropertyDescriptor(beanClass, propertyName).getPropertyType();
 	}
 
 	/**
 	 * Returns names of all the property desriptors in the given array.
 	 *
 	 * @param desc PropertyDescriptor[]
 	 *
 	 * @return java.beans.PropertyDescriptor
 	 */
 	public static String[] getPropertyNames(PropertyDescriptor[] desc)
 	{
 		String[] names = new String[desc.length];
 
 		for (int i = 0; i < desc.length; i++) {
 			names[i] = desc[i].getName();
 		}
 
 		return names;
 	}
 
 	/**
 	 * Returns types of all the property descriptors in the given array.
 	 *
 	 * @param desc PropertyDescriptor[]
 	 *
 	 * @return java.beans.PropertyDescriptor
 	 */
 	public static Class[] getPropertyTypes(PropertyDescriptor[] desc)
 	{
 		Class[] names = new Class[desc.length];
 
 		for (int i = 0; i < desc.length; i++) {
 			names[i] = desc[i].getPropertyType();
 		}
 
 		return names;
 	}
 
 	/**
 	 * Returns types of all the property descriptors in the given array.
 	 *
 	 * @param desc PropertyDescriptor[]
 	 * @param target DOCUMENT ME!
 	 *
 	 * @return java.beans.PropertyDescriptor
 	 *
 	 * @throws java.beans.IntrospectionException DOCUMENT ME!
 	 * @throws java.lang.reflect.InvocationTargetException DOCUMENT ME!
 	 * @throws IllegalAccessException DOCUMENT ME!
 	 */
 	public static Object[] getPropertyValues(PropertyDescriptor[] desc,
 	    Object target)
 		throws java.beans.IntrospectionException, 
 			java.lang.reflect.InvocationTargetException, IllegalAccessException
 	{
 		Method m = null;
 		Object[] params = new Object[0];
 		Object[] ret = new Object[desc.length];
 
 		for (int i = 0; i < desc.length; i++) {
 			m = desc[i].getReadMethod();
 
 			if (m != null) {
 				ret[i] = m.invoke(target, params);
 			}
 		}
 
 		return ret;
 	}
 
 	/**
 	 * Selects descriptors of all writable properties from an array of
 	 * descriptors.
 	 *
 	 * @param desc PropertyDescriptor[]
 	 *
 	 * @return java.beans.PropertyDescriptor
 	 */
 	public static PropertyDescriptor[] getWritable(PropertyDescriptor[] desc)
 	{
 		ArrayList list = new ArrayList();
 
 		for (int i = 0; i < desc.length; i++) {
 			if (desc[i].getWriteMethod() != null) {
 				list.add(desc[i]);
 			}
 		}
 
 		PropertyDescriptor[] ret = new PropertyDescriptor[list.size()];
 		list.toArray(ret);
 
 		return ret;
 	}
 
 	/**
 	 * Selects descriptors of all readable properties from an array of
 	 * descriptors.
 	 *
 	 * @param desc PropertyDescriptor[]
 	 *
 	 * @return java.beans.PropertyDescriptor
 	 */
 	public static PropertyDescriptor[] getReadable(PropertyDescriptor[] desc)
 	{
 		ArrayList list = new ArrayList();
 
 		for (int i = 0; i < desc.length; i++) {
 			if (desc[i].getReadMethod() != null) {
 				list.add(desc[i]);
 			}
 		}
 
 		PropertyDescriptor[] ret = new PropertyDescriptor[list.size()];
 		list.toArray(ret);
 
 		return ret;
 	}
 
 	private static void internalGetInterfacePropertyDescriptors(
 	    Class[] interfaces, Class superInterface, HashSet set)
 	{
 		try {
 			for (int i = 0; i < interfaces.length; i++) {
 				if ((superInterface.isAssignableFrom(interfaces[i]))
 				    && (interfaces[i] != superInterface)) {
 					set.addAll(java.util.Arrays.asList(
 					        java.beans.Introspector.getBeanInfo(interfaces[i])
 					        .getPropertyDescriptors()));
 					internalGetInterfacePropertyDescriptors(interfaces[i]
 					    .getInterfaces(), superInterface, set);
 				}
 			}
 		} catch (Exception e) {
 			System.out.println("Exception occured " + interfaces + " "
 			    + superInterface + " " + set);
 		}
 	}
 
 	private static void internalGetInterfacePropertyDescriptors(
 	    Class theClass, Class superInterface, HashSet set)
 	{
 		if (!superInterface.isAssignableFrom(theClass)) {
 			throw new IllegalArgumentException(DataFormatter.toString(theClass)
 			    + " does not implement "
 			    + DataFormatter.toString(superInterface));
 		}
 
 		internalGetInterfacePropertyDescriptors(theClass.getInterfaces(),
 		    superInterface, set);
 	}
 
 	/**
 	 * Returns all the property descriptors of <code>theClass</code>.
 	 *
 	 * @param theClass Class
 	 *
 	 * @return java.beans.PropertyDescriptor
 	 *
 	 * @throws IntrospectionException
 	 */
 	public static PropertyDescriptor[] getPropertyDescriptors(Class theClass)
 		throws IntrospectionException
 	{
 		return Introspector.getBeanInfo(theClass).getPropertyDescriptors();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param propertyName DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 */
 	public static String getPropertyDisplayString(String propertyName)
 	{
 		return getPropertyDisplayString(propertyName, true);
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param propertyName DOCUMENT ME!
 	 * @param titleCase DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 */
 	public static String getPropertyDisplayString(String propertyName,
 	    boolean titleCase)
 	{
 		String[] split = DataFormatter.splitStringOnCapitals(propertyName);
 		StringBuffer ret = new StringBuffer();
 
 		if (titleCase) {
 			split[0] = split[0].substring(0, 1).toUpperCase()
 				+ split[0].substring(1);
 		}
 
 		ret.append(split[0]);
 
 		for (int i = 1; i < split.length; i++) {
 			if (!titleCase) {
 				split[i] = split[i].substring(0, 1).toLowerCase()
 					+ split[i].substring(1);
 			}
 
 			ret.append(" ");
 			ret.append(split[i]);
 		}
 
 		return ret.toString();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param method DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 */
 	public static boolean isGetterMethod(Method method)
 	{
 		return ((method.getName().startsWith("get")
 		&& method.getParameterTypes().length == 0
 		&& !method.getReturnType().equals(Void.TYPE))
 		|| (method.getName().startsWith("is")
 		&& method.getParameterTypes().length == 0
 		&& method.getReturnType().equals(Boolean.TYPE)));
 	}
 }
 
 /* __oOo__ */