groovy/modules/grails/src/commons/org/codehaus/groovy/grails/commons/GrailsClassUtils.java - groovy - Git at Google

 /* Copyright 2004-2005 the original author or authors.
  *
  * Licensed 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.codehaus.groovy.grails.commons;


 import groovy.lang.Closure;

 import java.beans.PropertyDescriptor;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;

 import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.BeanWrapper;
 import org.springframework.beans.BeanWrapperImpl;

 /**
  * @author Graeme Rocher
  * @since 08-Jul-2005
  *
  * Class containing utility methods for dealing with Grails class artifacts
  *
  */
 public class GrailsClassUtils {

 	private static Map beanWrapperInstances = new HashMap();

 	/**
 	 * Returns true of the specified Groovy class is a controller
 	 * @param clazz
 	 * @return
 	 */
 	public static boolean isBootstrapClass( Class clazz ) {
 		return clazz.getName().endsWith(DefaultGrailsBootstrapClass.BOOT_STRAP)  && !Closure.class.isAssignableFrom(clazz);
 	}

 	/**
 	 * Returns true of the specified Groovy class is a controller
 	 * @param clazz
 	 * @return
 	 */
 	public static boolean isControllerClass( Class clazz ) {
 		return clazz.getName().endsWith(DefaultGrailsControllerClass.CONTROLLER)  && !Closure.class.isAssignableFrom(clazz);
 	}

 	/**
 	 * <p>Returns true if the specified class is a page flow class type</p>
 	 *
 	 * @param clazz
 	 * @return
 	 */
 	public static boolean isPageFlowClass( Class clazz ) {
 		return clazz.getName().endsWith(DefaultGrailsPageFlowClass.PAGE_FLOW)  && !Closure.class.isAssignableFrom(clazz);
 	}

 	/**
 	 * <p>Returns true if the specified class is a data source.
 	 *
 	 * @param clazz
 	 * @return
 	 */
 	public static boolean isDataSource(Class clazz) {
 		return clazz.getName().endsWith(DefaultGrailsDataSource.DATA_SOURCE) && !Closure.class.isAssignableFrom(clazz);
 	}

 	/**
 	 * <p>Returns true if the specified class is a service.
 	 *
 	 * @param clazz
 	 * @return
 	 */
 	public static boolean isService(Class clazz) {
 		return clazz.getName().endsWith(DefaultGrailsServiceClass.SERVICE) && !Closure.class.isAssignableFrom(clazz);
 	}

 	/**
 	 * <p>Returns true if the specified class is a domain class. In Grails a domain class
 	 * is any class that has "id" and "version" properties</p>
 	 *
 	 * @param clazz The class to check
 	 * @return A boolean value
 	 */
 	public static boolean isDomainClass( Class clazz ) {
 		try {
 			// make sure the identify and version field exist
 			clazz.getDeclaredField( GrailsDomainClassProperty.IDENTITY );
 			clazz.getDeclaredField( GrailsDomainClassProperty.VERSION );
 			// and its not a closure
 			if(Closure.class.isAssignableFrom(clazz)) {
 				return false;
 			}
 			// passes all conditions return true
 			return true;
 		} catch (SecurityException e) {
 			return false;
 		} catch (NoSuchFieldException e) {
 			return false;
 		}
 	}

 	/**
 	 *
 	 * Returns true if the specified property in the specified class is of the specified type
 	 *
 	 * @param clazz The class which contains the property
 	 * @param propertyName The property name
 	 * @param type The type to check
 	 *
 	 * @return A boolean value
 	 */
 	public static boolean isPropertyOfType( Class clazz, String propertyName, Class type ) {
 		try {

 			Class propType = getProperyType( clazz, propertyName );
 			if(propType != null && propType.equals( type ))
 				return true;
 			else
 				return false;
 		}
 		catch(Exception e) {
 			return false;
 		}
 	}


 	/**
 	 * Returns the value of the specified property and type from an instance of the specified Grails class
 	 *
 	 * @param clazz The name of the class which contains the property
 	 * @param propertyName The property name
 	 * @param propertyType The property type
 	 *
 	 * @return The value of the property or null if none exists
 	 */
 	public static Object getPropertyValue(Class clazz, String propertyName, Class propertyType) {
 		// validate
 		if(clazz == null || StringUtils.isBlank(propertyName))
 			return null;

 		try {
 			BeanWrapper wrapper = (BeanWrapper)beanWrapperInstances.get( clazz.getName() );
 			if(wrapper == null) {
 				wrapper = new BeanWrapperImpl(clazz.newInstance());
 				beanWrapperInstances.put( clazz.getName(), wrapper );
 			}
 			Object pValue = wrapper.getPropertyValue( propertyName );
 			if(pValue == null)
 				return null;

 			if(propertyType.isAssignableFrom(pValue.getClass())) {
 				return pValue;
 			}
 			else {
 				return null;
 			}

 		} catch (Exception e) {
 			// if there are any errors in instantiating just return null
 			return null;
 		}
 	}


 	/**
 	 * Retrieves a PropertyDescriptor for the specified instance and property value
 	 *
 	 * @param instance The instance
 	 * @param propertyValue The value of the property
 	 * @return The PropertyDescriptor
 	 */
 	public static PropertyDescriptor getPropertyDescriptorForValue(Object instance, Object propertyValue) {
 		if(instance == null || propertyValue == null)
 			return null;

 		BeanWrapper wrapper = new BeanWrapperImpl(instance);
 		PropertyDescriptor[] descriptors = wrapper.getPropertyDescriptors();

 		for (int i = 0; i < descriptors.length; i++) {
 			Object value = wrapper.getPropertyValue( descriptors[i].getName() );
 			if(propertyValue.equals(value))
 				return descriptors[i];
 		}
 		return null;
 	}
 	/**
 	 * Returns the type of the given property contained within the specified class
 	 *
 	 * @param clazz The class which contains the property
 	 * @param propertyName The name of the property
 	 *
 	 * @return The property type or null if none exists
 	 */
 	public static Class getProperyType(Class clazz, String propertyName) {
 		if(clazz == null || StringUtils.isBlank(propertyName))
 			return null;

 		try {
 			BeanWrapper wrapper = (BeanWrapper)beanWrapperInstances.get( clazz.getName() );
 			if(wrapper == null) {
 				wrapper = new BeanWrapperImpl(clazz.newInstance());
 				beanWrapperInstances.put( clazz.getName(), wrapper );
 			}
 			return wrapper.getPropertyType(propertyName);

 		} catch (Exception e) {
 			// if there are any errors in instantiating just return null for the moment
 			return null;
 		}
 	}

 	/**
 	 * Retrieves all the properties of the given class for the given type
 	 *
 	 * @param clazz The class to retrieve the properties from
 	 * @param propertyType The type of the properties you wish to retrieve
 	 *
 	 * @return An array of PropertyDescriptor instances
 	 */
 	public static PropertyDescriptor[] getPropertiesOfType(Class clazz, Class propertyType) {
 		if(clazz == null || propertyType == null)
 			return new PropertyDescriptor[0];

 		Set properties = new HashSet();
 		try {
 			BeanWrapper wrapper = (BeanWrapper)beanWrapperInstances.get( clazz.getName() );
 			if(wrapper == null) {
 				wrapper = new BeanWrapperImpl(clazz.newInstance());
 				beanWrapperInstances.put( clazz.getName(), wrapper );
 			}
 			PropertyDescriptor[] descriptors = wrapper.getPropertyDescriptors();

 			for (int i = 0; i < descriptors.length; i++) {
 				if(descriptors[i].getPropertyType().equals( propertyType )  ) {
 					properties.add(descriptors[i]);
 				}
 			}

 		} catch (Exception e) {
 			// if there are any errors in instantiating just return null for the moment
 			return new PropertyDescriptor[0];
 		}
 		return (PropertyDescriptor[])properties.toArray( new PropertyDescriptor[ properties.size() ] );
 	}

 	/**
 	 * Retrieves a property of the given class of the specified name and type
 	 * @param clazz The class to retrieve the property from
 	 * @param propertyName The name of the property
 	 * @param propertyType The type of the property
 	 *
 	 * @return A PropertyDescriptor instance or null if none exists
 	 */
 	public static PropertyDescriptor getProperty(Class clazz, String propertyName, Class propertyType) {
 		if(clazz == null || propertyName == null || propertyType == null)
 			return null;

 		try {
 			BeanWrapper wrapper = (BeanWrapper)beanWrapperInstances.get( clazz.getName() );
 			if(wrapper == null) {
 				wrapper = new BeanWrapperImpl(clazz.newInstance());
 				beanWrapperInstances.put( clazz.getName(), wrapper );
 			}
 			PropertyDescriptor pd = wrapper.getPropertyDescriptor(propertyName);
 			if(pd.getPropertyType().equals( propertyType )) {
 				return pd;
 			}
 			else {
 				return null;
 			}
 		} catch (Exception e) {
 			// if there are any errors in instantiating just return null for the moment
 			return null;
 		}
 	}

 	/**
 	 * Returns the class name without the package prefix
 	 *
 	 * @param targetClass
 	 * @return
 	 */
 	public static String getShortName(Class targetClass) {
 		String className = targetClass.getName();
 		int i = className.lastIndexOf(".");
 		if(i > -1) {
 			className = className.substring( i + 1, className.length() );
 		}
 		return className;
 	}

 }
	/* Copyright 2004-2005 the original author or authors.
	*
	* Licensed 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.codehaus.groovy.grails.commons;


	import groovy.lang.Closure;

	import java.beans.PropertyDescriptor;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.Set;

	import org.apache.commons.lang.StringUtils;
	import org.springframework.beans.BeanWrapper;
	import org.springframework.beans.BeanWrapperImpl;

	/**
	* @author Graeme Rocher
	* @since 08-Jul-2005
	*
	* Class containing utility methods for dealing with Grails class artifacts
	*
	*/
	public class GrailsClassUtils {

	private static Map beanWrapperInstances = new HashMap();

	/**
	* Returns true of the specified Groovy class is a controller
	* @param clazz
	* @return
	*/
	public static boolean isBootstrapClass( Class clazz ) {
	return clazz.getName().endsWith(DefaultGrailsBootstrapClass.BOOT_STRAP) && !Closure.class.isAssignableFrom(clazz);
	}

	/**
	* Returns true of the specified Groovy class is a controller
	* @param clazz
	* @return
	*/
	public static boolean isControllerClass( Class clazz ) {
	return clazz.getName().endsWith(DefaultGrailsControllerClass.CONTROLLER) && !Closure.class.isAssignableFrom(clazz);
	}

	/**
	* <p>Returns true if the specified class is a page flow class type</p>
	*
	* @param clazz
	* @return
	*/
	public static boolean isPageFlowClass( Class clazz ) {
	return clazz.getName().endsWith(DefaultGrailsPageFlowClass.PAGE_FLOW) && !Closure.class.isAssignableFrom(clazz);
	}

	/**
	* <p>Returns true if the specified class is a data source.
	*
	* @param clazz
	* @return
	*/
	public static boolean isDataSource(Class clazz) {
	return clazz.getName().endsWith(DefaultGrailsDataSource.DATA_SOURCE) && !Closure.class.isAssignableFrom(clazz);
	}

	/**
	* <p>Returns true if the specified class is a service.
	*
	* @param clazz
	* @return
	*/
	public static boolean isService(Class clazz) {
	return clazz.getName().endsWith(DefaultGrailsServiceClass.SERVICE) && !Closure.class.isAssignableFrom(clazz);
	}

	/**
	* <p>Returns true if the specified class is a domain class. In Grails a domain class
	* is any class that has "id" and "version" properties</p>
	*
	* @param clazz The class to check
	* @return A boolean value
	*/
	public static boolean isDomainClass( Class clazz ) {
	try {
	// make sure the identify and version field exist
	clazz.getDeclaredField( GrailsDomainClassProperty.IDENTITY );
	clazz.getDeclaredField( GrailsDomainClassProperty.VERSION );
	// and its not a closure
	if(Closure.class.isAssignableFrom(clazz)) {
	return false;
	}
	// passes all conditions return true
	return true;
	} catch (SecurityException e) {
	return false;
	} catch (NoSuchFieldException e) {
	return false;
	}
	}

	/**
	*
	* Returns true if the specified property in the specified class is of the specified type
	*
	* @param clazz The class which contains the property
	* @param propertyName The property name
	* @param type The type to check
	*
	* @return A boolean value
	*/
	public static boolean isPropertyOfType( Class clazz, String propertyName, Class type ) {
	try {

	Class propType = getProperyType( clazz, propertyName );
	if(propType != null && propType.equals( type ))
	return true;
	else
	return false;
	}
	catch(Exception e) {
	return false;
	}
	}


	/**
	* Returns the value of the specified property and type from an instance of the specified Grails class
	*
	* @param clazz The name of the class which contains the property
	* @param propertyName The property name
	* @param propertyType The property type
	*
	* @return The value of the property or null if none exists
	*/
	public static Object getPropertyValue(Class clazz, String propertyName, Class propertyType) {
	// validate
	if(clazz == null \|\| StringUtils.isBlank(propertyName))
	return null;

	try {
	BeanWrapper wrapper = (BeanWrapper)beanWrapperInstances.get( clazz.getName() );
	if(wrapper == null) {
	wrapper = new BeanWrapperImpl(clazz.newInstance());
	beanWrapperInstances.put( clazz.getName(), wrapper );
	}
	Object pValue = wrapper.getPropertyValue( propertyName );
	if(pValue == null)
	return null;

	if(propertyType.isAssignableFrom(pValue.getClass())) {
	return pValue;
	}
	else {
	return null;
	}

	} catch (Exception e) {
	// if there are any errors in instantiating just return null
	return null;
	}
	}


	/**
	* Retrieves a PropertyDescriptor for the specified instance and property value
	*
	* @param instance The instance
	* @param propertyValue The value of the property
	* @return The PropertyDescriptor
	*/
	public static PropertyDescriptor getPropertyDescriptorForValue(Object instance, Object propertyValue) {
	if(instance == null \|\| propertyValue == null)
	return null;

	BeanWrapper wrapper = new BeanWrapperImpl(instance);
	PropertyDescriptor[] descriptors = wrapper.getPropertyDescriptors();

	for (int i = 0; i < descriptors.length; i++) {
	Object value = wrapper.getPropertyValue( descriptors[i].getName() );
	if(propertyValue.equals(value))
	return descriptors[i];
	}
	return null;
	}
	/**
	* Returns the type of the given property contained within the specified class
	*
	* @param clazz The class which contains the property
	* @param propertyName The name of the property
	*
	* @return The property type or null if none exists
	*/
	public static Class getProperyType(Class clazz, String propertyName) {
	if(clazz == null \|\| StringUtils.isBlank(propertyName))
	return null;

	try {
	BeanWrapper wrapper = (BeanWrapper)beanWrapperInstances.get( clazz.getName() );
	if(wrapper == null) {
	wrapper = new BeanWrapperImpl(clazz.newInstance());
	beanWrapperInstances.put( clazz.getName(), wrapper );
	}
	return wrapper.getPropertyType(propertyName);

	} catch (Exception e) {
	// if there are any errors in instantiating just return null for the moment
	return null;
	}
	}

	/**
	* Retrieves all the properties of the given class for the given type
	*
	* @param clazz The class to retrieve the properties from
	* @param propertyType The type of the properties you wish to retrieve
	*
	* @return An array of PropertyDescriptor instances
	*/
	public static PropertyDescriptor[] getPropertiesOfType(Class clazz, Class propertyType) {
	if(clazz == null \|\| propertyType == null)
	return new PropertyDescriptor[0];

	Set properties = new HashSet();
	try {
	BeanWrapper wrapper = (BeanWrapper)beanWrapperInstances.get( clazz.getName() );
	if(wrapper == null) {
	wrapper = new BeanWrapperImpl(clazz.newInstance());
	beanWrapperInstances.put( clazz.getName(), wrapper );
	}
	PropertyDescriptor[] descriptors = wrapper.getPropertyDescriptors();

	for (int i = 0; i < descriptors.length; i++) {
	if(descriptors[i].getPropertyType().equals( propertyType ) ) {
	properties.add(descriptors[i]);
	}
	}

	} catch (Exception e) {
	// if there are any errors in instantiating just return null for the moment
	return new PropertyDescriptor[0];
	}
	return (PropertyDescriptor[])properties.toArray( new PropertyDescriptor[ properties.size() ] );
	}

	/**
	* Retrieves a property of the given class of the specified name and type
	* @param clazz The class to retrieve the property from
	* @param propertyName The name of the property
	* @param propertyType The type of the property
	*
	* @return A PropertyDescriptor instance or null if none exists
	*/
	public static PropertyDescriptor getProperty(Class clazz, String propertyName, Class propertyType) {
	if(clazz == null \|\| propertyName == null \|\| propertyType == null)
	return null;

	try {
	BeanWrapper wrapper = (BeanWrapper)beanWrapperInstances.get( clazz.getName() );
	if(wrapper == null) {
	wrapper = new BeanWrapperImpl(clazz.newInstance());
	beanWrapperInstances.put( clazz.getName(), wrapper );
	}
	PropertyDescriptor pd = wrapper.getPropertyDescriptor(propertyName);
	if(pd.getPropertyType().equals( propertyType )) {
	return pd;
	}
	else {
	return null;
	}
	} catch (Exception e) {
	// if there are any errors in instantiating just return null for the moment
	return null;
	}
	}

	/**
	* Returns the class name without the package prefix
	*
	* @param targetClass
	* @return
	*/
	public static String getShortName(Class targetClass) {
	String className = targetClass.getName();
	int i = className.lastIndexOf(".");
	if(i > -1) {
	className = className.substring( i + 1, className.length() );
	}
	return className;
	}

	}