jsf/plugins/org.eclipse.jst.jsf.facesconfig.ui/src/org/eclipse/jst/jsf/facesconfig/ui/util/JavaBeanUtils.java - jsf/webtools.jsf - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004, 2005 Sybase, Inc. and others.
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     Sybase, Inc. - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.jsf.facesconfig.ui.util;

 import java.beans.Introspector;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.ITypeHierarchy;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jst.jsf.common.ui.internal.utils.JavaModelUtil;

 /**
  * This utility class is used to access java bean class, e.g., get java bean's
  * property
  *
  * @author xgzhang
  * @version
  */
 public final class JavaBeanUtils {
 	/**
 	 * fully qualified name of a List
 	 */
 	private static final String JAVA_UTIL_LIST = "java.util.List"; //$NON-NLS-1$

 	/**
 	 * fully qualifed name of a Map
 	 */
 	private static final String JAVA_UTIL_MAP = "java.util.Map"; //$NON-NLS-1$

 	/**
 	 *
 	 */
 	private JavaBeanUtils() {
 		super();
 	}

 	/**
 	 * get the getter method according to property name
 	 *
 	 * @param type
 	 * @param propertyName
 	 * @return - can be <b>null</b>, if not found
 	 * @throws JavaModelException
 	 * @throws JavaModelException
 	 */
 	private static IMethod getPropertyGetterMethod(IType type,
 			String propertyName)  {
 		if (type == null || !type.exists() || propertyName == null) {
 			return null;
 		}
 		IMethod getterMethod = null;

 		String methodBaseName = null;
 		// Uppercase 1st letter
 		if (propertyName.length() == 1) {
 			methodBaseName = propertyName.substring(0, 1).toUpperCase();
 		} else {
 			methodBaseName = propertyName.substring(0, 1).toUpperCase()
 					+ propertyName.substring(1);
 		}

 		String getterMethodName = "get" + methodBaseName; //$NON-NLS-1$

 		getterMethod = type.getMethod(getterMethodName, null);
 		if (getterMethod == null || !getterMethod.exists()
 				|| !JavaClassUtils.isPublicMethod(getterMethod)) {
 			getterMethodName = "is" + methodBaseName; //$NON-NLS-1$
 			getterMethod = type.getMethod(getterMethodName, null);

 			if (getterMethod == null || !getterMethod.exists()
 					|| !JavaClassUtils.isPublicMethod(getterMethod)) {
 				getterMethod = null;
 			}
 		}
 		return getterMethod;
 	}

 	/**
 	 * get the getter method in the type hierarchy according to property name
 	 *
 	 * @param type
 	 * @param propertyName
 	 * @return - can be <b>null</b>, if not found
 	 * @throws JavaModelException
 	 * @throws JavaModelException
 	 */
 	private static IMethod getPropertyGetterMethodInTypeHierarchy(IType type,
 			String propertyName) throws JavaModelException {
 		if (type == null || !type.exists() || propertyName == null) {
 			return null;
 		}
 		IMethod getterMethod = null;

 		getterMethod = getPropertyGetterMethod(type, propertyName);

 		if (getterMethod == null) {
 			ITypeHierarchy typeHierarchy = null;
 			typeHierarchy = type.newSupertypeHierarchy(null);

 			if (typeHierarchy == null) {
 				return null;
 			}

 			IType[] superTypes = typeHierarchy.getAllSuperclasses(type);

 			if (superTypes == null || superTypes.length == 0) {
 				return null;
 			}
 			for (int i = 0; i < superTypes.length; i++) {
 				if (!superTypes[i].getFullyQualifiedName().equals(
 						"java.lang.Object")) { //$NON-NLS-1$
 					getterMethod = getPropertyGetterMethod(superTypes[i],
 							propertyName);
 					if (getterMethod != null) {
 						break;
 					}
 				}
 			}
 		}
 		return getterMethod;
 	}

 	/**
 	 * get the setter method in the type hierarchy according to property name
 	 *
 	 * @param type
 	 * @param propertyName
 	 * @return - can be <b>null</b>, if not found
 	 * @throws JavaModelException
 	 */
 	private static IMethod getPropertySetterMethodInTypeHierarchy(IType type,
 			String propertyName) throws JavaModelException {
 		if (type == null || !type.exists() || propertyName == null) {
 			return null;
 		}
 		IMethod setterMethod = null;

 		setterMethod = getPropertySetterMethod(type, propertyName);

 		if (setterMethod == null) {
 			ITypeHierarchy typeHierarchy = null;
 			typeHierarchy = type.newSupertypeHierarchy(null);

 			if (typeHierarchy == null) {
 				return null;
 			}

 			IType[] superTypes = typeHierarchy.getAllSuperclasses(type);

 			if (superTypes == null || superTypes.length == 0) {
 				return null;
 			}
 			for (int i = 0; i < superTypes.length; i++) {
 				if (!superTypes[i].getFullyQualifiedName().equals(
 						"java.lang.Object")) { //$NON-NLS-1$
 					setterMethod = getPropertySetterMethod(superTypes[i],
 							propertyName);
 					if (setterMethod != null) {
 						break;
 					}
 				}
 			}
 		}

 		return setterMethod;
 	}

 	/**
 	 * get the setter method according to property name
 	 *
 	 * @param type
 	 * @param propertyName
 	 * @return - can be <b>null</b>, if not found
 	 * @throws JavaModelException
 	 */
 	private static IMethod getPropertySetterMethod(IType type,
 			String propertyName) throws JavaModelException {
 		if (type == null || !type.exists() || propertyName == null) {
 			return null;
 		}
 		IMethod setterMethod = null;

 		String methodBaseName = null;
 		// Uppercase 1st letter
 		if (propertyName.length() == 1) {
 			methodBaseName = propertyName.substring(0, 1).toUpperCase();
 		} else {
 			methodBaseName = propertyName.substring(0, 1).toUpperCase()
 					+ propertyName.substring(1);
 		}

 		String setterMethodName = "set" + methodBaseName; //$NON-NLS-1$

 		IMethod[] methods = null;

 		methods = type.getMethods();

 		if (methods == null || methods.length == 0) {
 			return null;
 		}

 		for (int i = 0; i < methods.length; i++) {
 			if (methods[i].getElementName().equals(setterMethodName)) {
 				if (methods[i] == null || !methods[i].exists()
 						|| !JavaClassUtils.isPublicMethod(methods[i])) {
 					continue;
 				}

 				// Method must return void
 				String returnType = methods[i].getReturnType();
 				if (!returnType.equals(Signature.SIG_VOID)) {
 					continue;
 				}

 				String params[] = methods[i].getParameterTypes();
 				// method must have only one argument
 				if (params.length != 1) {
 					continue;
 				}
 				setterMethod = methods[i];
 			}
 		}

 		return setterMethod;
 	}

 	/**
 	 * Check whether the propertyName is bean's property or not.
 	 *
 	 * @param baseType
 	 * @param propertyName
 	 *
 	 * @return - True means the property name is valid bean's property,
 	 *         otherwise, not.
 	 *
 	 */
 	public static boolean isBeanProperty(IType baseType, String propertyName)
     {
 		if (baseType == null || !baseType.exists() || propertyName == null) {
 			return false;
 		}

 		return (getBeanPropertyType(baseType, propertyName) != null);
 	}

 	/**
 	 * get the bean's property type
 	 *
 	 * @param baseType
 	 * @param propertyName
 	 * @return - can be <b>null</b>, if not found
 	 *
 	 */
 	public static IType getBeanPropertyType(IType baseType, String propertyName) {
 		if (baseType == null || !baseType.exists() || propertyName == null) {
 			return null;
 		}

 		String typeSignature = null;
 		IMethod getterMethod = null;
 		IMethod setterMethod = null;

 		IType declaredType = baseType;
 		try {
 			getterMethod = getPropertyGetterMethodInTypeHierarchy(baseType,
 					propertyName);
 			setterMethod = getPropertySetterMethodInTypeHierarchy(baseType,
 					propertyName);
 		} catch (JavaModelException e1) {
 			// Need not any error handling.
 		}

 		if (getterMethod != null && setterMethod == null) {
 			declaredType = getterMethod.getDeclaringType();
 			try {
 				typeSignature = getterMethod.getReturnType();
 			} catch (JavaModelException e2) {
 				// Need not any error handling.
 			}
 		} else if (setterMethod != null && getterMethod == null) {
 			declaredType = setterMethod.getDeclaringType();
 			typeSignature = setterMethod.getParameterTypes()[0];
 		} else if (setterMethod != null && getterMethod != null) {
 			declaredType = getterMethod.getDeclaringType();
 			try {
 				// FIXME: should check the type hierachy
 				if (getterMethod.getReturnType().equals(
 						setterMethod.getParameterTypes()[0])) {
 					typeSignature = getterMethod.getReturnType();
 				}
 			} catch (JavaModelException e2) {
 				// Need not any error handling.
 			}
 		}

 		if (typeSignature == null) {
 			return null;
 		}

 		IType type = null;

 		try {
 			String typeName = JavaModelUtil.getResolvedTypeName(typeSignature,
 					declaredType);
 			if (typeName != null) {
 				type = baseType.getJavaProject().findType(typeName);
 			}
 		} catch (JavaModelException e) {
 			// Need not any error handling.
 		}
 		return type;
 	}

 	/**
 	 * get the bean's property's getter and setter methods.
 	 *
 	 * @param baseType
 	 * @param propertyName
 	 * @return - IMethod[], the first is getter and the second is setter method,
 	 *         however, both of them can be null.
 	 */
 	public static IMethod[] getBeanPropertyMethods(IType baseType,
 			String propertyName) {
 		if (baseType == null || !baseType.exists() || propertyName == null) {
 			return null;
 		}

 		IMethod[] methods = new IMethod[2];

 		IMethod getterMethod = null;
 		IMethod setterMethod = null;
 		try {
 			getterMethod = getPropertyGetterMethodInTypeHierarchy(baseType,
 					propertyName);

 			setterMethod = getPropertySetterMethodInTypeHierarchy(baseType,
 					propertyName);
 		} catch (JavaModelException e) {
 			// Need not any error handling.
 		}

 		if (getterMethod != null && setterMethod == null) {
 			methods[0] = getterMethod;
 		} else if (setterMethod != null && getterMethod == null) {
 			methods[1] = setterMethod;
 		} else if (setterMethod != null && getterMethod != null) {
 			try {
 				// FIXME: should check the type hierachy
 				if (getterMethod.getReturnType().equals(
 						setterMethod.getParameterTypes()[0])) {
 					methods[0] = getterMethod;
 					methods[1] = setterMethod;
 				}
 			} catch (JavaModelException e1) {
 				// Need not any error handling.
 			}
 		}

 		return methods;
 	}

 	/**
 	 * check whether the type implements <code>java.util.List</code>
 	 *
 	 * @param type
 	 * @return - True if the type is the sub class of
 	 *         <code>java.util.List</code>, otherwise, not.
 	 */
 	public static boolean isListType(IType type) {
 		if (type == null) {
 			return false;
 		}
 		if (type.getFullyQualifiedName().equalsIgnoreCase(JAVA_UTIL_LIST)) {
 			return true;
 		}

 		return JavaClassUtils.isSubClassOf(type.getJavaProject(), type
 				.getFullyQualifiedName(), JAVA_UTIL_LIST);
 	}

 	/**
 	 * check whether the type implements <code>java.util.Map</code>
 	 *
 	 * @param type
 	 * @return - True if the type is the sub class of <code>java.uitl.Map</code>,
 	 *         otherwise, not.
 	 */
 	public static boolean isMapType(IType type) {
 		if (type == null) {
 			return false;
 		}
 		if (type.getFullyQualifiedName().equalsIgnoreCase(JAVA_UTIL_MAP)) {
 			return true;
 		}

 		return JavaClassUtils.isSubClassOf(type.getJavaProject(), type
 				.getFullyQualifiedName(), JAVA_UTIL_MAP);
 	}

 	/**
 	 * Test for method inclusion in bindings list.
 	 * <p>
 	 * This test has the following conditions:
 	 * </p>
 	 * <ul>
 	 * <li>method starts with <code>get</code></li>
 	 * <li>method has no arguments</li>
 	 * <li>method does not return void</li>
 	 * </ul>
 	 *
 	 * @param method -
 	 *            the IMethod to examine
 	 * @return boolean - true, if method satisfies the condition test
 	 */
 	public static boolean isGetterMethod(IMethod method) {
 		try {
 			if (!JavaClassUtils.isPublicMethod(method)) {
 				return false;
 			}
 			String params[] = method.getParameterTypes();
 			// Has no arguments
 			if (params.length > 0) {
 				return false;
 			}

 			// Starts with "get"
 			if (!(method.getElementName().startsWith("get") || method.getElementName().startsWith("is"))) //$NON-NLS-1$ //$NON-NLS-2$
 			{
 				return false;
 			}
 			// Does not return void
 			String rtn = method.getReturnType();
 			if (!rtn.equals(Signature.SIG_VOID)) {
 				return true;
 			}
 		} catch (JavaModelException e) {
 			// Need not any error handling.
 		}
 		return false;
 	}

 	/**
 	 * Test for method inclusion in bindings list.
 	 * <p>
 	 * This test has the following conditions:
 	 * </p>
 	 * <ul>
 	 * <li>method starts with <code>set</code></li>
 	 * <li>method returns void</li>
 	 * </ul>
 	 *
 	 * @param method -
 	 *            the IMethod to examine
 	 * @return boolean - true, if method satisfies the condition test
 	 */
 	public static boolean isSetterMethod(IMethod method) {
 		try {
 			if (!JavaClassUtils.isPublicMethod(method)) {
 				return false;
 			}
 			// Starts with "set"
 			if (!method.getElementName().startsWith("set")) //$NON-NLS-1$
 			{
 				return false;
 			}

 			// the parameter's number should be one.
 			if (method.getParameterTypes().length != 1) {
 				return false;
 			}
 			// Returns void
 			String rtn = method.getReturnType();
 			if (rtn.equals(Signature.SIG_VOID)) {
 				return true;
 			}
 		} catch (JavaModelException e) {
 			// Need not any error handling.
 		}
 		return false;
 	}

 	/**
 	 * set the first character into low case.
 	 *
 	 * @param str
 	 * @return str with the first char lower cased
 	 */
 	public static String toLowCaseFirstChar(String str) {
 		// change the first alphabet to lowcase.
 		if (str != null && str.length() > 0) {
 			if (str.length() == 1) {
 				str = str.toLowerCase();
 			} else {
 				str = str.substring(0, 1).toLowerCase() + str.substring(1);
 			}
 		}
 		return str;
 	}

 	/**
 	 * set the first character into low case.
 	 *
 	 * @param str
 	 * @return str with the first char upper-cased
 	 */
 	public static String toUpperCaseFirstChar(String str) {
 		// change the first alphabet to lowcase.
 		if (str != null && str.length() > 0) {
 			if (str.length() == 1) {
 				str = str.toUpperCase();
 			} else {
 				str = str.substring(0, 1).toUpperCase() + str.substring(1);
 			}
 		}
 		return str;
 	}

 	/**
 	 * get property name from getter method.
 	 *
 	 * @param method
 	 * @return - can be <b>null</b>, if the method is not a valid getter method
 	 */
 	public static String getPropertyNameFromGetterMethod(IMethod method) {
 		if (!isGetterMethod(method)) {
 			return null;
 		}
 		String methodName = method.getElementName();
 		String propertyName = null;
 		// Starts with "get"
 		if (methodName.startsWith("get") && methodName.length() > 3) { //$NON-NLS-1$
 			propertyName = methodName.substring(3);
 		} else if (methodName.startsWith("is") && methodName.length() > 2) // Starts //$NON-NLS-1$
 		// with
 		// "is"
 		{
 			propertyName = methodName.substring(2);
 		}
 		propertyName = Introspector.decapitalize(propertyName);
 		return propertyName;
 	}

 	/**
 	 * get property name from setter class.
 	 *
 	 * @param method
 	 * @return - can be <b>null</b>, if the method is not a valid setter method
 	 */
 	public static String getPropertyNameFromSetterMethod(IMethod method) {
 		if (!isSetterMethod(method)) {
 			return null;
 		}
 		String methodName = method.getElementName();
 		String propertyName = null;
 		// Starts with "get"
 		if (methodName.startsWith("set") && methodName.length() > 3) { //$NON-NLS-1$
 			propertyName = methodName.substring(3);
 		}
 		propertyName = Introspector.decapitalize(propertyName);
 		return propertyName;
 	}

 	/**
 	 * get the method with the same parameters
 	 *
 	 * @param methods
 	 * @param visitedMethods
 	 * @param foundMethod
 	 * @param foundMethodName
 	 * @param foundParamTypes
 	 * @return
 	 */
 	private static IMethod getMethodWithSameParamters(IMethod[] methods,
 			Map visitedMethods, IMethod foundMethod, String foundMethodName,
 			String[] foundParamTypes) {
 		// get all qualified type name for the found method's parameters.
 		String[] foundParamQulifiedTypeNames = null;
 		if (foundParamTypes != null && foundParamTypes.length > 0) {
 			foundParamQulifiedTypeNames = new String[foundParamTypes.length];
 			for (int i = 0; i < foundParamTypes.length; i++) {
 				foundParamQulifiedTypeNames[i] = JavaClassUtils
 						.getQualifiedTypeNameInTypeHierarchy(foundMethod
 								.getDeclaringType(), foundParamTypes[i]);
 			}
 		}
 		for (int i = 0; i < methods.length; i++) {
 			if (visitedMethods.get(methods[i]) != null) {
 				continue;
 			}

 			if (!methods[i].getElementName().equals(foundMethodName)) {
 				continue;
 			}
 			if (methods[i].getParameterTypes() == null
 					&& foundParamTypes == null) {
 				return methods[i];
 			} else if (methods[i].getParameterTypes() != null
 					&& foundParamTypes != null
 					&& foundParamTypes.length == methods[i].getParameterTypes().length) {
 				boolean bSameParams = true;
 				String[] methodParamTypes = methods[i].getParameterTypes();
 				for (int j = 0; j < foundParamQulifiedTypeNames.length; j++) {
 					String methodParamQualifiedTypeName = JavaClassUtils
 							.getQualifiedTypeNameInTypeHierarchy(methods[i]
 									.getDeclaringType(), methodParamTypes[j]);
 					// if the qualified type name is not same or not subclass or
 					// supper class between each other.
 					if (!methodParamQualifiedTypeName
 							.equals(foundParamQulifiedTypeNames[j])
 							&& !JavaClassUtils.isSubClassOf(methods[i]
 									.getJavaProject(),
 									methodParamQualifiedTypeName,
 									foundParamQulifiedTypeNames[j])
 							&& !JavaClassUtils.isSubClassOf(methods[i]
 									.getJavaProject(),
 									foundParamQulifiedTypeNames[j],
 									methodParamQualifiedTypeName)) {
 						bSameParams = false;
 						break;
 					}
 				}
 				if (bSameParams) {
 					return methods[i];
 				}
 			}
 		}
 		return null;
 	}

 	/**
 	 * Creates an array of bean properties
 	 *
 	 *
 	 * @param classType
 	 * @return it can be <b>null</b>, if property is not found.
 	 */
 	public static JavaBeanProperty[] getBeanProperties(IType classType) {
 		IMethod[] methods;
 		try {
 			methods = JavaClassUtils.getMethods(classType);
 		} catch (JavaModelException e2) {
 			return null;
 		}

 		return getBeanProperties(classType, methods);
 	}

 	/**
 	 * Creates an array of bean properties
 	 *
 	 * @param type
 	 * @param methods
 	 *
 	 * @return - the array of java bean properties.
 	 */
 	public static JavaBeanProperty[] getBeanProperties(IType type,
 			IMethod[] methods) {
 		if (methods == null || methods.length == 0) {
 			return null;
 		}

 		List properties = new ArrayList();
 		Map visitedMethods = new HashMap();
 		for (int m = 0; m < methods.length; m++) {
 			String propertyName = null;
 			// if a property's getter method or setter method already visited,
 			// just skip it.
 			if (visitedMethods.get(methods[m]) != null) {
 				continue;
 			}

 			visitedMethods.put(methods[m], methods[m]);

 			// Check getter firstly
 			propertyName = JavaBeanUtils
 					.getPropertyNameFromGetterMethod(methods[m]);

 			if (propertyName != null && propertyName.length() > 0)
 			{
 				String setterMethodName = "set" //$NON-NLS-1$
 						+ JavaBeanUtils.toUpperCaseFirstChar(propertyName);

 				String getterReturnType = null;
 				try {
 					getterReturnType = methods[m].getReturnType();
 				} catch (JavaModelException e1) {
 					continue;
 				}
 				IMethod setterMethod = getMethodWithSameParamters(methods,
 						visitedMethods, methods[m], setterMethodName,
 						new String[] { getterReturnType });
 				if (setterMethod != null && setterMethod.exists()) {
 					visitedMethods.put(setterMethod, setterMethod);
 				}

 				properties.add(new JavaBeanProperty(propertyName,
 						getterReturnType, methods[m], setterMethod));
 				continue;
 			}

 			// Check setter secondly.
 			propertyName = JavaBeanUtils
 					.getPropertyNameFromSetterMethod(methods[m]);

 			if (propertyName != null && propertyName.length() > 0)
 			{
 				// first form of getter method, "get..."
 				String getterMethodName = "get" //$NON-NLS-1$
 						+ JavaBeanUtils.toUpperCaseFirstChar(propertyName);
 				IMethod getterMethod = getMethodWithSameParamters(methods,
 						visitedMethods, methods[m], getterMethodName, null);

 				if (getterMethod != null && getterMethod.exists()) {
 					try {
 						if (getterMethod.getReturnType().equals(
 								methods[m].getParameterTypes()[0])) {
 							visitedMethods.put(getterMethod, getterMethod);
 						}
 					} catch (JavaModelException e) {
 						// need not error logging
 					}
 				} else {
 					// another form of getter method, "is...".
 					getterMethodName = "is" //$NON-NLS-1$
 							+ JavaBeanUtils.toUpperCaseFirstChar(propertyName);
 					getterMethod = getMethodWithSameParamters(methods,
 							visitedMethods, methods[m], getterMethodName, null);
 					try {
 						if (getterMethod != null
 								&& getterMethod.exists()
 								&& getterMethod.getReturnType().equals(
 										methods[m].getParameterTypes()[0])) {
 							visitedMethods.put(getterMethod, getterMethod);
 						}
 					} catch (JavaModelException e) {
 						// need not error logging
 					}
 				}

 				properties.add(new JavaBeanProperty(propertyName, methods[m]
 						.getParameterTypes()[0], getterMethod, methods[m]));
 				continue;
 			}
 		}

 		JavaBeanProperty[] propertyArray = (JavaBeanProperty[]) properties
 				.toArray(new JavaBeanProperty[properties.size()]);

 		Arrays.sort(propertyArray, new Comparator() {
 			public int compare(Object o1, Object o2) {
 				String name1 = ((JavaBeanProperty) o1).getName();
 				String name2 = ((JavaBeanProperty) o2).getName();
 				return name1.compareTo(name2);
 			}
 		});
 		return propertyArray;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2004, 2005 Sybase, Inc. and others.
	*
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Sybase, Inc. - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jst.jsf.facesconfig.ui.util;

	import java.beans.Introspector;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.jdt.core.IMethod;
	import org.eclipse.jdt.core.IType;
	import org.eclipse.jdt.core.ITypeHierarchy;
	import org.eclipse.jdt.core.JavaModelException;
	import org.eclipse.jdt.core.Signature;
	import org.eclipse.jst.jsf.common.ui.internal.utils.JavaModelUtil;

	/**
	* This utility class is used to access java bean class, e.g., get java bean's
	* property
	*
	* @author xgzhang
	* @version
	*/
	public final class JavaBeanUtils {
	/**
	* fully qualified name of a List
	*/
	private static final String JAVA_UTIL_LIST = "java.util.List"; //$NON-NLS-1$

	/**
	* fully qualifed name of a Map
	*/
	private static final String JAVA_UTIL_MAP = "java.util.Map"; //$NON-NLS-1$

	/**
	*
	*/
	private JavaBeanUtils() {
	super();
	}

	/**
	* get the getter method according to property name
	*
	* @param type
	* @param propertyName
	* @return - can be <b>null</b>, if not found
	* @throws JavaModelException
	* @throws JavaModelException
	*/
	private static IMethod getPropertyGetterMethod(IType type,
	String propertyName) {
	if (type == null \|\| !type.exists() \|\| propertyName == null) {
	return null;
	}
	IMethod getterMethod = null;

	String methodBaseName = null;
	// Uppercase 1st letter
	if (propertyName.length() == 1) {
	methodBaseName = propertyName.substring(0, 1).toUpperCase();
	} else {
	methodBaseName = propertyName.substring(0, 1).toUpperCase()
	+ propertyName.substring(1);
	}

	String getterMethodName = "get" + methodBaseName; //$NON-NLS-1$

	getterMethod = type.getMethod(getterMethodName, null);
	if (getterMethod == null \|\| !getterMethod.exists()
	\|\| !JavaClassUtils.isPublicMethod(getterMethod)) {
	getterMethodName = "is" + methodBaseName; //$NON-NLS-1$
	getterMethod = type.getMethod(getterMethodName, null);

	if (getterMethod == null \|\| !getterMethod.exists()
	\|\| !JavaClassUtils.isPublicMethod(getterMethod)) {
	getterMethod = null;
	}
	}
	return getterMethod;
	}

	/**
	* get the getter method in the type hierarchy according to property name
	*
	* @param type
	* @param propertyName
	* @return - can be <b>null</b>, if not found
	* @throws JavaModelException
	* @throws JavaModelException
	*/
	private static IMethod getPropertyGetterMethodInTypeHierarchy(IType type,
	String propertyName) throws JavaModelException {
	if (type == null \|\| !type.exists() \|\| propertyName == null) {
	return null;
	}
	IMethod getterMethod = null;

	getterMethod = getPropertyGetterMethod(type, propertyName);

	if (getterMethod == null) {
	ITypeHierarchy typeHierarchy = null;
	typeHierarchy = type.newSupertypeHierarchy(null);

	if (typeHierarchy == null) {
	return null;
	}

	IType[] superTypes = typeHierarchy.getAllSuperclasses(type);

	if (superTypes == null \|\| superTypes.length == 0) {
	return null;
	}
	for (int i = 0; i < superTypes.length; i++) {
	if (!superTypes[i].getFullyQualifiedName().equals(
	"java.lang.Object")) { //$NON-NLS-1$
	getterMethod = getPropertyGetterMethod(superTypes[i],
	propertyName);
	if (getterMethod != null) {
	break;
	}
	}
	}
	}
	return getterMethod;
	}

	/**
	* get the setter method in the type hierarchy according to property name
	*
	* @param type
	* @param propertyName
	* @return - can be <b>null</b>, if not found
	* @throws JavaModelException
	*/
	private static IMethod getPropertySetterMethodInTypeHierarchy(IType type,
	String propertyName) throws JavaModelException {
	if (type == null \|\| !type.exists() \|\| propertyName == null) {
	return null;
	}
	IMethod setterMethod = null;

	setterMethod = getPropertySetterMethod(type, propertyName);

	if (setterMethod == null) {
	ITypeHierarchy typeHierarchy = null;
	typeHierarchy = type.newSupertypeHierarchy(null);

	if (typeHierarchy == null) {
	return null;
	}

	IType[] superTypes = typeHierarchy.getAllSuperclasses(type);

	if (superTypes == null \|\| superTypes.length == 0) {
	return null;
	}
	for (int i = 0; i < superTypes.length; i++) {
	if (!superTypes[i].getFullyQualifiedName().equals(
	"java.lang.Object")) { //$NON-NLS-1$
	setterMethod = getPropertySetterMethod(superTypes[i],
	propertyName);
	if (setterMethod != null) {
	break;
	}
	}
	}
	}

	return setterMethod;
	}

	/**
	* get the setter method according to property name
	*
	* @param type
	* @param propertyName
	* @return - can be <b>null</b>, if not found
	* @throws JavaModelException
	*/
	private static IMethod getPropertySetterMethod(IType type,
	String propertyName) throws JavaModelException {
	if (type == null \|\| !type.exists() \|\| propertyName == null) {
	return null;
	}
	IMethod setterMethod = null;

	String methodBaseName = null;
	// Uppercase 1st letter
	if (propertyName.length() == 1) {
	methodBaseName = propertyName.substring(0, 1).toUpperCase();
	} else {
	methodBaseName = propertyName.substring(0, 1).toUpperCase()
	+ propertyName.substring(1);
	}

	String setterMethodName = "set" + methodBaseName; //$NON-NLS-1$

	IMethod[] methods = null;

	methods = type.getMethods();

	if (methods == null \|\| methods.length == 0) {
	return null;
	}

	for (int i = 0; i < methods.length; i++) {
	if (methods[i].getElementName().equals(setterMethodName)) {
	if (methods[i] == null \|\| !methods[i].exists()
	\|\| !JavaClassUtils.isPublicMethod(methods[i])) {
	continue;
	}

	// Method must return void
	String returnType = methods[i].getReturnType();
	if (!returnType.equals(Signature.SIG_VOID)) {
	continue;
	}

	String params[] = methods[i].getParameterTypes();
	// method must have only one argument
	if (params.length != 1) {
	continue;
	}
	setterMethod = methods[i];
	}
	}

	return setterMethod;
	}

	/**
	* Check whether the propertyName is bean's property or not.
	*
	* @param baseType
	* @param propertyName
	*
	* @return - True means the property name is valid bean's property,
	* otherwise, not.
	*
	*/
	public static boolean isBeanProperty(IType baseType, String propertyName)
	{
	if (baseType == null \|\| !baseType.exists() \|\| propertyName == null) {
	return false;
	}

	return (getBeanPropertyType(baseType, propertyName) != null);
	}

	/**
	* get the bean's property type
	*
	* @param baseType
	* @param propertyName
	* @return - can be <b>null</b>, if not found
	*
	*/
	public static IType getBeanPropertyType(IType baseType, String propertyName) {
	if (baseType == null \|\| !baseType.exists() \|\| propertyName == null) {
	return null;
	}

	String typeSignature = null;
	IMethod getterMethod = null;
	IMethod setterMethod = null;

	IType declaredType = baseType;
	try {
	getterMethod = getPropertyGetterMethodInTypeHierarchy(baseType,
	propertyName);
	setterMethod = getPropertySetterMethodInTypeHierarchy(baseType,
	propertyName);
	} catch (JavaModelException e1) {
	// Need not any error handling.
	}

	if (getterMethod != null && setterMethod == null) {
	declaredType = getterMethod.getDeclaringType();
	try {
	typeSignature = getterMethod.getReturnType();
	} catch (JavaModelException e2) {
	// Need not any error handling.
	}
	} else if (setterMethod != null && getterMethod == null) {
	declaredType = setterMethod.getDeclaringType();
	typeSignature = setterMethod.getParameterTypes()[0];
	} else if (setterMethod != null && getterMethod != null) {
	declaredType = getterMethod.getDeclaringType();
	try {
	// FIXME: should check the type hierachy
	if (getterMethod.getReturnType().equals(
	setterMethod.getParameterTypes()[0])) {
	typeSignature = getterMethod.getReturnType();
	}
	} catch (JavaModelException e2) {
	// Need not any error handling.
	}
	}

	if (typeSignature == null) {
	return null;
	}

	IType type = null;

	try {
	String typeName = JavaModelUtil.getResolvedTypeName(typeSignature,
	declaredType);
	if (typeName != null) {
	type = baseType.getJavaProject().findType(typeName);
	}
	} catch (JavaModelException e) {
	// Need not any error handling.
	}
	return type;
	}

	/**
	* get the bean's property's getter and setter methods.
	*
	* @param baseType
	* @param propertyName
	* @return - IMethod[], the first is getter and the second is setter method,
	* however, both of them can be null.
	*/
	public static IMethod[] getBeanPropertyMethods(IType baseType,
	String propertyName) {
	if (baseType == null \|\| !baseType.exists() \|\| propertyName == null) {
	return null;
	}

	IMethod[] methods = new IMethod[2];

	IMethod getterMethod = null;
	IMethod setterMethod = null;
	try {
	getterMethod = getPropertyGetterMethodInTypeHierarchy(baseType,
	propertyName);

	setterMethod = getPropertySetterMethodInTypeHierarchy(baseType,
	propertyName);
	} catch (JavaModelException e) {
	// Need not any error handling.
	}

	if (getterMethod != null && setterMethod == null) {
	methods[0] = getterMethod;
	} else if (setterMethod != null && getterMethod == null) {
	methods[1] = setterMethod;
	} else if (setterMethod != null && getterMethod != null) {
	try {
	// FIXME: should check the type hierachy
	if (getterMethod.getReturnType().equals(
	setterMethod.getParameterTypes()[0])) {
	methods[0] = getterMethod;
	methods[1] = setterMethod;
	}
	} catch (JavaModelException e1) {
	// Need not any error handling.
	}
	}

	return methods;
	}

	/**
	* check whether the type implements <code>java.util.List</code>
	*
	* @param type
	* @return - True if the type is the sub class of
	* <code>java.util.List</code>, otherwise, not.
	*/
	public static boolean isListType(IType type) {
	if (type == null) {
	return false;
	}
	if (type.getFullyQualifiedName().equalsIgnoreCase(JAVA_UTIL_LIST)) {
	return true;
	}

	return JavaClassUtils.isSubClassOf(type.getJavaProject(), type
	.getFullyQualifiedName(), JAVA_UTIL_LIST);
	}

	/**
	* check whether the type implements <code>java.util.Map</code>
	*
	* @param type
	* @return - True if the type is the sub class of <code>java.uitl.Map</code>,
	* otherwise, not.
	*/
	public static boolean isMapType(IType type) {
	if (type == null) {
	return false;
	}
	if (type.getFullyQualifiedName().equalsIgnoreCase(JAVA_UTIL_MAP)) {
	return true;
	}

	return JavaClassUtils.isSubClassOf(type.getJavaProject(), type
	.getFullyQualifiedName(), JAVA_UTIL_MAP);
	}

	/**
	* Test for method inclusion in bindings list.
	* <p>
	* This test has the following conditions:
	* </p>
	* <ul>
	* <li>method starts with <code>get</code></li>
	* <li>method has no arguments</li>
	* <li>method does not return void</li>
	* </ul>
	*
	* @param method -
	* the IMethod to examine
	* @return boolean - true, if method satisfies the condition test
	*/
	public static boolean isGetterMethod(IMethod method) {
	try {
	if (!JavaClassUtils.isPublicMethod(method)) {
	return false;
	}
	String params[] = method.getParameterTypes();
	// Has no arguments
	if (params.length > 0) {
	return false;
	}

	// Starts with "get"
	if (!(method.getElementName().startsWith("get") \|\| method.getElementName().startsWith("is"))) //$NON-NLS-1$ //$NON-NLS-2$
	{
	return false;
	}
	// Does not return void
	String rtn = method.getReturnType();
	if (!rtn.equals(Signature.SIG_VOID)) {
	return true;
	}
	} catch (JavaModelException e) {
	// Need not any error handling.
	}
	return false;
	}

	/**
	* Test for method inclusion in bindings list.
	* <p>
	* This test has the following conditions:
	* </p>
	* <ul>
	* <li>method starts with <code>set</code></li>
	* <li>method returns void</li>
	* </ul>
	*
	* @param method -
	* the IMethod to examine
	* @return boolean - true, if method satisfies the condition test
	*/
	public static boolean isSetterMethod(IMethod method) {
	try {
	if (!JavaClassUtils.isPublicMethod(method)) {
	return false;
	}
	// Starts with "set"
	if (!method.getElementName().startsWith("set")) //$NON-NLS-1$
	{
	return false;
	}

	// the parameter's number should be one.
	if (method.getParameterTypes().length != 1) {
	return false;
	}
	// Returns void
	String rtn = method.getReturnType();
	if (rtn.equals(Signature.SIG_VOID)) {
	return true;
	}
	} catch (JavaModelException e) {
	// Need not any error handling.
	}
	return false;
	}

	/**
	* set the first character into low case.
	*
	* @param str
	* @return str with the first char lower cased
	*/
	public static String toLowCaseFirstChar(String str) {
	// change the first alphabet to lowcase.
	if (str != null && str.length() > 0) {
	if (str.length() == 1) {
	str = str.toLowerCase();
	} else {
	str = str.substring(0, 1).toLowerCase() + str.substring(1);
	}
	}
	return str;
	}

	/**
	* set the first character into low case.
	*
	* @param str
	* @return str with the first char upper-cased
	*/
	public static String toUpperCaseFirstChar(String str) {
	// change the first alphabet to lowcase.
	if (str != null && str.length() > 0) {
	if (str.length() == 1) {
	str = str.toUpperCase();
	} else {
	str = str.substring(0, 1).toUpperCase() + str.substring(1);
	}
	}
	return str;
	}

	/**
	* get property name from getter method.
	*
	* @param method
	* @return - can be <b>null</b>, if the method is not a valid getter method
	*/
	public static String getPropertyNameFromGetterMethod(IMethod method) {
	if (!isGetterMethod(method)) {
	return null;
	}
	String methodName = method.getElementName();
	String propertyName = null;
	// Starts with "get"
	if (methodName.startsWith("get") && methodName.length() > 3) { //$NON-NLS-1$
	propertyName = methodName.substring(3);
	} else if (methodName.startsWith("is") && methodName.length() > 2) // Starts //$NON-NLS-1$
	// with
	// "is"
	{
	propertyName = methodName.substring(2);
	}
	propertyName = Introspector.decapitalize(propertyName);
	return propertyName;
	}

	/**
	* get property name from setter class.
	*
	* @param method
	* @return - can be <b>null</b>, if the method is not a valid setter method
	*/
	public static String getPropertyNameFromSetterMethod(IMethod method) {
	if (!isSetterMethod(method)) {
	return null;
	}
	String methodName = method.getElementName();
	String propertyName = null;
	// Starts with "get"
	if (methodName.startsWith("set") && methodName.length() > 3) { //$NON-NLS-1$
	propertyName = methodName.substring(3);
	}
	propertyName = Introspector.decapitalize(propertyName);
	return propertyName;
	}

	/**
	* get the method with the same parameters
	*
	* @param methods
	* @param visitedMethods
	* @param foundMethod
	* @param foundMethodName
	* @param foundParamTypes
	* @return
	*/
	private static IMethod getMethodWithSameParamters(IMethod[] methods,
	Map visitedMethods, IMethod foundMethod, String foundMethodName,
	String[] foundParamTypes) {
	// get all qualified type name for the found method's parameters.
	String[] foundParamQulifiedTypeNames = null;
	if (foundParamTypes != null && foundParamTypes.length > 0) {
	foundParamQulifiedTypeNames = new String[foundParamTypes.length];
	for (int i = 0; i < foundParamTypes.length; i++) {
	foundParamQulifiedTypeNames[i] = JavaClassUtils
	.getQualifiedTypeNameInTypeHierarchy(foundMethod
	.getDeclaringType(), foundParamTypes[i]);
	}
	}
	for (int i = 0; i < methods.length; i++) {
	if (visitedMethods.get(methods[i]) != null) {
	continue;
	}

	if (!methods[i].getElementName().equals(foundMethodName)) {
	continue;
	}
	if (methods[i].getParameterTypes() == null
	&& foundParamTypes == null) {
	return methods[i];
	} else if (methods[i].getParameterTypes() != null
	&& foundParamTypes != null
	&& foundParamTypes.length == methods[i].getParameterTypes().length) {
	boolean bSameParams = true;
	String[] methodParamTypes = methods[i].getParameterTypes();
	for (int j = 0; j < foundParamQulifiedTypeNames.length; j++) {
	String methodParamQualifiedTypeName = JavaClassUtils
	.getQualifiedTypeNameInTypeHierarchy(methods[i]
	.getDeclaringType(), methodParamTypes[j]);
	// if the qualified type name is not same or not subclass or
	// supper class between each other.
	if (!methodParamQualifiedTypeName
	.equals(foundParamQulifiedTypeNames[j])
	&& !JavaClassUtils.isSubClassOf(methods[i]
	.getJavaProject(),
	methodParamQualifiedTypeName,
	foundParamQulifiedTypeNames[j])
	&& !JavaClassUtils.isSubClassOf(methods[i]
	.getJavaProject(),
	foundParamQulifiedTypeNames[j],
	methodParamQualifiedTypeName)) {
	bSameParams = false;
	break;
	}
	}
	if (bSameParams) {
	return methods[i];
	}
	}
	}
	return null;
	}

	/**
	* Creates an array of bean properties
	*
	*
	* @param classType
	* @return it can be <b>null</b>, if property is not found.
	*/
	public static JavaBeanProperty[] getBeanProperties(IType classType) {
	IMethod[] methods;
	try {
	methods = JavaClassUtils.getMethods(classType);
	} catch (JavaModelException e2) {
	return null;
	}

	return getBeanProperties(classType, methods);
	}

	/**
	* Creates an array of bean properties
	*
	* @param type
	* @param methods
	*
	* @return - the array of java bean properties.
	*/
	public static JavaBeanProperty[] getBeanProperties(IType type,
	IMethod[] methods) {
	if (methods == null \|\| methods.length == 0) {
	return null;
	}

	List properties = new ArrayList();
	Map visitedMethods = new HashMap();
	for (int m = 0; m < methods.length; m++) {
	String propertyName = null;
	// if a property's getter method or setter method already visited,
	// just skip it.
	if (visitedMethods.get(methods[m]) != null) {
	continue;
	}

	visitedMethods.put(methods[m], methods[m]);

	// Check getter firstly
	propertyName = JavaBeanUtils
	.getPropertyNameFromGetterMethod(methods[m]);

	if (propertyName != null && propertyName.length() > 0)
	{
	String setterMethodName = "set" //$NON-NLS-1$
	+ JavaBeanUtils.toUpperCaseFirstChar(propertyName);

	String getterReturnType = null;
	try {
	getterReturnType = methods[m].getReturnType();
	} catch (JavaModelException e1) {
	continue;
	}
	IMethod setterMethod = getMethodWithSameParamters(methods,
	visitedMethods, methods[m], setterMethodName,
	new String[] { getterReturnType });
	if (setterMethod != null && setterMethod.exists()) {
	visitedMethods.put(setterMethod, setterMethod);
	}

	properties.add(new JavaBeanProperty(propertyName,
	getterReturnType, methods[m], setterMethod));
	continue;
	}

	// Check setter secondly.
	propertyName = JavaBeanUtils
	.getPropertyNameFromSetterMethod(methods[m]);

	if (propertyName != null && propertyName.length() > 0)
	{
	// first form of getter method, "get..."
	String getterMethodName = "get" //$NON-NLS-1$
	+ JavaBeanUtils.toUpperCaseFirstChar(propertyName);
	IMethod getterMethod = getMethodWithSameParamters(methods,
	visitedMethods, methods[m], getterMethodName, null);

	if (getterMethod != null && getterMethod.exists()) {
	try {
	if (getterMethod.getReturnType().equals(
	methods[m].getParameterTypes()[0])) {
	visitedMethods.put(getterMethod, getterMethod);
	}
	} catch (JavaModelException e) {
	// need not error logging
	}
	} else {
	// another form of getter method, "is...".
	getterMethodName = "is" //$NON-NLS-1$
	+ JavaBeanUtils.toUpperCaseFirstChar(propertyName);
	getterMethod = getMethodWithSameParamters(methods,
	visitedMethods, methods[m], getterMethodName, null);
	try {
	if (getterMethod != null
	&& getterMethod.exists()
	&& getterMethod.getReturnType().equals(
	methods[m].getParameterTypes()[0])) {
	visitedMethods.put(getterMethod, getterMethod);
	}
	} catch (JavaModelException e) {
	// need not error logging
	}
	}

	properties.add(new JavaBeanProperty(propertyName, methods[m]
	.getParameterTypes()[0], getterMethod, methods[m]));
	continue;
	}
	}

	JavaBeanProperty[] propertyArray = (JavaBeanProperty[]) properties
	.toArray(new JavaBeanProperty[properties.size()]);

	Arrays.sort(propertyArray, new Comparator() {
	public int compare(Object o1, Object o2) {
	String name1 = ((JavaBeanProperty) o1).getName();
	String name2 = ((JavaBeanProperty) o2).getName();
	return name1.compareTo(name2);
	}
	});
	return propertyArray;
	}
	}