ClassUtils (Metawidget API Documentation)

java.lang.Object
- org.metawidget.util.ClassUtils

```
public final class ClassUtils
extends Object
```
Utilities for working with Classes.

Author:

Richard Kennard

Field Summary

Fields
Modifier and Type Field and Description

static String JAVABEAN_GET_PREFIX

static String JAVABEAN_IS_PREFIX

static String JAVABEAN_SET_PREFIX

Fields
Modifier and Type	Field and Description
`static String`	`JAVABEAN_GET_PREFIX`
`static String`	`JAVABEAN_IS_PREFIX`
`static String`	`JAVABEAN_SET_PREFIX`

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean`	`classExists(String clazz)` Gracefully test whether a class exists.
`static String`	`getGenericTypeAsString(Type type)` Converts a `java.lang.reflect.Type`, as returned by `getGenericType` into a String representation.
`static Object`	`getNumberMaxValue(Class<?> clazz)`
`static Object`	`getNumberMinValue(Class<?> clazz)`
`static <T extends Annotation> T`	`getOriginalAnnotation(Method method, Class<T> annotationClass)` Gets the given annotationClass defined on the given method.
`static Class<?>`	`getOriginalDeclaringClass(Method method)` Similar to `Method.getDeclaringClass`, but traverses the class heirarchy to find the class that originally declared this method, in the event the implementation has been overridden.
`static Type[]`	`getOriginalGenericParameterTypes(Method method)` Gets the given genericParameterTypes defined on the given method.
`static Type`	`getOriginalGenericReturnType(Method method)` Gets the given genericReturnType defined on the given method.
`static String`	`getPackagesAsFolderNames(Class<?> clazz)` Converts `com.foo.Bar` into `/com/foo`.
`static <T> T`	`getProperty(Object base, String property)` Get the value of the JavaBean-convention property without using `java.beans`, as that package is not available on all target platforms.
`static Method`	`getReadMethod(Class<?> clazz, String property)` Lookup JavaBean-convention getter without using `java.beans`, as that package is not available on all target platforms.
`static String`	`getSimpleName(String qualifiedClassName)` Gets the 'simple' name of the class, given the fully qualified name.
`static Class<?>`	`getWrapperClass(Class<?> clazz)` Returns the wrapper class for a primitive class (eg.
`static Method`	`getWriteMethod(Class<?> clazz, String property, Class<?> type)` Lookup JavaBean-convention setter without using `java.beans`, as that package is not available on all target platforms.
`static boolean`	`isPrimitive(String className)`
`static boolean`	`isPrimitiveWrapper(Class<?> clazz)` Returns `true` if the given class is the Object-wrapper of a primitive type (eg.
`static Class<?>`	`niceForName(String className)` Replacement for `Class.forName()` that: supports primitives (`int`, `long`, etc) returns `null` if there is no such class (eg.
`static Class<?>`	`niceForName(String className, ClassLoader classLoader)` Replacement for `Class.forName()` that: returns `null` if there is no such class (eg.
`static Object`	`parseNumber(Class<?> clazz, String value)`
`static void`	`registerAlienClassLoader(ClassLoader classLoader)` When dealing with multiple isolated ClassLoaders, sometimes the object being inspected may reference a class that is not available to any of our own ClassLoaders.
`static void`	`setProperty(Object base, String property, Object value)` Set the value of the JavaBean-convention property without using `java.beans`, as that package is not available on all target platforms.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - JAVABEAN_SET_PREFIX
```
public static final String JAVABEAN_SET_PREFIX
```
    See Also:
    Constant Field Values
  - JAVABEAN_GET_PREFIX
```
public static final String JAVABEAN_GET_PREFIX
```
    See Also:
    Constant Field Values
  - JAVABEAN_IS_PREFIX
```
public static final String JAVABEAN_IS_PREFIX
```
    See Also:
    Constant Field Values
- Method Detail
  - getReadMethod
```
public static Method getReadMethod(Class<?> clazz,
                   String property)
```
    Lookup JavaBean-convention getter without using java.beans, as that package is not available on all target platforms.
  - getWriteMethod
```
public static Method getWriteMethod(Class<?> clazz,
                    String property,
                    Class<?> type)
```
    Lookup JavaBean-convention setter without using java.beans, as that package is not available on all target platforms.
  - getProperty
```
public static <T> T getProperty(Object base,
                String property)
```
    Get the value of the JavaBean-convention property without using java.beans, as that package is not available on all target platforms.
  - setProperty
```
public static void setProperty(Object base,
               String property,
               Object value)
```
    Set the value of the JavaBean-convention property without using java.beans, as that package is not available on all target platforms.
  - isPrimitiveWrapper
```
public static boolean isPrimitiveWrapper(Class<?> clazz)
```
    Returns true if the given class is the Object-wrapper of a primitive type (eg. Integer for int).
    We want to be able to distinguish these, because we can't usefully drill into them and may do better to 'inspect from parent' (see UIMetawidget).
  - getWrapperClass
```
public static Class<?> getWrapperClass(Class<?> clazz)
```
    Returns the wrapper class for a primitive class (eg. Integer.class for int.class)
  - classExists
```
public static boolean classExists(String clazz)
```
    Gracefully test whether a class exists. Returns true or false, rather than throwing ClassNotFoundException.
  - parseNumber
```
public static Object parseNumber(Class<?> clazz,
                 String value)
```
  - getNumberMinValue
```
public static Object getNumberMinValue(Class<?> clazz)
```
  - getNumberMaxValue
```
public static Object getNumberMaxValue(Class<?> clazz)
```
  - registerAlienClassLoader
```
public static void registerAlienClassLoader(ClassLoader classLoader)
```
    When dealing with multiple isolated ClassLoaders, sometimes the object being inspected may reference a class that is not available to any of our own ClassLoaders. Therefore Class.forName will always fail. To cope with this, we record 'alien' ClassLoaders as and when we encounter them
  - niceForName
```
public static Class<?> niceForName(String className)
```
    Replacement for Class.forName() that:
    - supports primitives (int, long, etc)
    - returns null if there is no such class (eg. if the name is a symbolic type, such as 'Login Screen')
  - niceForName
```
public static Class<?> niceForName(String className,
                   ClassLoader classLoader)
```
    Replacement for Class.forName() that:
    - returns null if there is no such class (eg. if the name is a symbolic type, such as 'Login Screen')
    - supports primitives (int, long, etc)
    - supports parameterized types (strips off the <...>)
    This method first tries to load the class using the given ClassLoader (if any). If that fails, it then tries the Thread's current ClassLoader (this works best for EJB/WAR splits where, say, metawidget-core and metawidget-annotations are located in the EJB/lib and the other modules are located in the WAR/lib). If that fails, it tries ClassUtils' ClassLoader. If that fails, it tries our alien ClassLoader.
    Parameters:
    classLoader - the specific ClassLoader to use to try and load this class. In general clients should use the other form of this method, which will default to trying the current Thread's ClassLoader. Can be null.
    
    Throws:
    
    NullPointerException - if className is null
  - isPrimitive
```
public static boolean isPrimitive(String className)
```
  - getSimpleName
```
public static String getSimpleName(String qualifiedClassName)
```
    Gets the 'simple' name of the class, given the fully qualified name.
    Named after Class.getSimpleName.
  - getOriginalDeclaringClass
```
public static Class<?> getOriginalDeclaringClass(Method method)
```
    Similar to Method.getDeclaringClass, but traverses the class heirarchy to find the class that originally declared this method, in the event the implementation has been overridden.
  - getPackagesAsFolderNames
```
public static String getPackagesAsFolderNames(Class<?> clazz)
```
    Converts com.foo.Bar into /com/foo. The leading forward slash can be important in some module loading environments (e.g. for JBoss Forge).
  - getOriginalAnnotation
```
public static <T extends Annotation> T getOriginalAnnotation(Method method,
                                             Class<T> annotationClass)
```
    Gets the given annotationClass defined on the given method. If no annotations are defined at all (not just annotationClass) but the method is overridden, searches up the class heirarchy to original versions of the method and checks for annotationClass.
    We work off no annotations being defined (rather than just annotationClass) because we still want to support explicitly overriding methods in order to suppress annotations (such as UiHidden). This isn't perfect, because the overridden method still has to define at least one annotation.
    This approach is important for proxied classes, which don't always retain annotations.
  - getOriginalGenericReturnType
```
public static Type getOriginalGenericReturnType(Method method)
```
    Gets the given genericReturnType defined on the given method. If no such genericReturnType is defined but the method is overridden, searches up the class heirarchy to original versions of the method, and checks for genericReturnType.
    This approach is important for proxied classes, which don't always retain genetics.
  - getOriginalGenericParameterTypes
```
public static Type[] getOriginalGenericParameterTypes(Method method)
```
    Gets the given genericParameterTypes defined on the given method. If no such genericParameterTypes is defined but the method is overridden, searches up the class heirarchy to original versions of the method, and checks for genericParameterTypes.
    This approach is important for proxied classes, which don't always retain genetics.
  - getGenericTypeAsString
```
public static String getGenericTypeAsString(Type type)
```
    Converts a java.lang.reflect.Type, as returned by getGenericType into a String representation.

Class ClassUtils

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

JAVABEAN_SET_PREFIX

JAVABEAN_GET_PREFIX

JAVABEAN_IS_PREFIX

Method Detail

getReadMethod

getWriteMethod

getProperty

setProperty

isPrimitiveWrapper

getWrapperClass

classExists

parseNumber

getNumberMinValue

getNumberMaxValue

registerAlienClassLoader

niceForName

niceForName

isPrimitive

getSimpleName

getOriginalDeclaringClass

getPackagesAsFolderNames

getOriginalAnnotation

getOriginalGenericReturnType

getOriginalGenericParameterTypes

getGenericTypeAsString