ClassUtil (The Leola Programming Language 0.9.6 API)

java.lang.Object
- leola.vm.util.ClassUtil

```
public class ClassUtil
extends Object
```
Simple utility class for reflection operations

Author:

Tony

Field Summary

Fields
Modifier and Type	Field and Description
`static Class<?>[]`	`BOOLEAN`
`static Class<?>[]`	`BYTE`
`static Class<?>[]`	`CHAR`
`static Class<?>[]`	`DOUBLE`
`static Class<?>[]`	`FLOAT`
`static Class<?>[]`	`INT`
`static Class<?>[]`	`INTEGER`
`static Class<?>[]`	`LONG`
`static Class<?>[]`	`NUMBER`
`static Class<?>[]`	`SHORT`
`static Class<?>[]`	`STRING`

Constructor Summary

Constructors
Constructor and Description

ClassUtil()

Constructors
Constructor and Description
`ClassUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`doesImplement(Class<?> testMe, Class<?> aInterface)` Determines if the supplied testMe class implements the supplied interface.
`static List<Field>`	`getAllDeclaredFields(Class<?> aClass)` Retrieves all of the fields defined in the supplied `Class`.
`static List<Method>`	`getAllDeclaredMethods(Class<?> aClass)` Retrieves all of the methods defined in the supplied `Class`.
`static <T extends Annotation> T`	`getAnnotation(Class<T> annotation, Class<?> ownerClass, Method method)` Retrieves the annotation from the method, if it is not on the method, the parent is checked.
`static Object`	`getFieldValue(Object instance, String fieldName)` Retrieve a data members value.
`static Field`	`getInheritedField(Class<?> aClass, String fieldName)` Get the data member by name.
`static Method`	`getInheritedMethodByName(Class<?> aClass, String name, Class<?>[] parameterTypes)` Get the method by name and parameter types.
`static Method`	`getMethodByAnnotationAlias(Class<?> aClass, String methodName)` Retrieves a `Method` by looking at the `LeolaMethod` annotation's `LeolaMethod.alias()` value.
`static Method`	`getMethodByName(Class<?> aClass, String methodName, Class<?>... params)` Retrieves a method by name (grabs the first if overloaded).
`static List<Method>`	`getMethodsByAnnotationAlias(Class<?> aClass, String methodName)` Retrieves the method names in which have the `LeolaMethod` annotation with the `LeolaMethod.alias()` of the supplied 'methodName'
`static List<Method>`	`getMethodsByName(Class<?> aClass, String methodName)` Retrieves all the overloaded methods by the supplied name
`static Object`	`getStaticFieldValue(Class<?> aClass, String fieldName)` Retrieve a class members value.
`static boolean`	`inheritsFrom(Class<?> child, Class<?> parent)` Determines if the supplied child class inherits from the supplied parent class.
`static Object`	`invokeMethod(List<Method> overloads, Object instance, LeoObject[] args)` Attempts to find the best matching overloaded `Method`.
`static Object`	`invokeMethod(Method method, Object owner, LeoObject[] params)` Invokes the supplied method.
`static Object`	`invokeMethod(Method method, Object owner, Object[] params)` Invokes a method reflectively.
`static boolean`	`isNativeClass(String className)` Determines if the supplied class name is a native class.
`static boolean`	`isType(Class<?> type, Class<?>... classes)` Determines if the supplied `Class` if of any of the supplied `Class` types.
`static LeoNativeClass`	`newNativeInstance(String className, LeoObject... params)` Creates a new `LeoNativeClass` based off of the Java fully qualified name and supplied parameters.
`static Class<?>`	`primitiveToWrapper(Class<?> cls)`
`static Class<?>`	`wrapperToPrimitive(Class<?> cls)`

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

- Field Detail
  - STRING
```
public static final Class<?>[] STRING
```
  - BOOLEAN
```
public static final Class<?>[] BOOLEAN
```
  - BYTE
```
public static final Class<?>[] BYTE
```
  - CHAR
```
public static final Class<?>[] CHAR
```
  - SHORT
```
public static final Class<?>[] SHORT
```
  - INT
```
public static final Class<?>[] INT
```
  - LONG
```
public static final Class<?>[] LONG
```
  - FLOAT
```
public static final Class<?>[] FLOAT
```
  - DOUBLE
```
public static final Class<?>[] DOUBLE
```
  - INTEGER
```
public static final Class<?>[] INTEGER
```
  - NUMBER
```
public static final Class<?>[] NUMBER
```
- Constructor Detail
  - ClassUtil
```
public ClassUtil()
```
- Method Detail
  - getMethodByName
```
public static Method getMethodByName(Class<?> aClass,
                                     String methodName,
                                     Class<?>... params)
```
    Retrieves a method by name (grabs the first if overloaded).
    
    Parameters:
    
    methodName -
    
    Returns:
    
    the method if found, otherwise null
  - getMethodsByName
```
public static List<Method> getMethodsByName(Class<?> aClass,
                                            String methodName)
```
    Retrieves all the overloaded methods by the supplied name
    
    Parameters:
    
    aClass -
    
    methodName -
    
    Returns:
    
    all methods by the given name.
  - getMethodsByAnnotationAlias
```
public static List<Method> getMethodsByAnnotationAlias(Class<?> aClass,
                                                       String methodName)
```
    Retrieves the method names in which have the LeolaMethod annotation with the LeolaMethod.alias() of the supplied 'methodName'
    
    Parameters:
    
    aClass -
    
    methodName -
    
    Returns:
    
    all methods that have a LeolaMethod annotation with the matching alias name
  - getMethodByAnnotationAlias
```
public static Method getMethodByAnnotationAlias(Class<?> aClass,
                                                String methodName)
```
    Retrieves a Method by looking at the LeolaMethod annotation's LeolaMethod.alias() value.
    
    Parameters:
    
    aClass -
    
    methodName -
    
    Returns:
    
    the Method if found, otherwise null
  - invokeMethod
```
public static Object invokeMethod(List<Method> overloads,
                                  Object instance,
                                  LeoObject[] args)
```
    Attempts to find the best matching overloaded Method. If one is found, it executes the Method.
    
    Parameters:
    
    overloads -
    
    instance -
    
    args -
    
    Returns:
    
    the resulting Java object from the method execution.
  - invokeMethod
```
public static Object invokeMethod(Method method,
                                  Object owner,
                                  LeoObject[] params)
                           throws LeolaRuntimeException
```
    Invokes the supplied method.
    
    Parameters:
    
    method - the method to be executed
    
    owner - the instance owner of the method
    
    params - the parameters to be used
    
    Returns:
    
    the result of executing the method
    
    Throws:
    
    LeolaRuntimeException
  - invokeMethod
```
public static Object invokeMethod(Method method,
                                  Object owner,
                                  Object[] params)
                           throws LeolaRuntimeException
```
    Invokes a method reflectively.
    
    Parameters:
    
    method - the method to be executed
    
    owner - the instance owner of the method
    
    params - the parameters to be used
    
    Returns:
    
    the result of executing the method
    
    Throws:
    
    LeolaRuntimeException
  - getFieldValue
```
public static Object getFieldValue(Object instance,
                                   String fieldName)
```
    Retrieve a data members value.
    
    Parameters:
    
    instance - the instance of a class
    
    fieldName - the data member name, in which to retrieve its value
    
    Returns:
    
    the value of the field.
  - getStaticFieldValue
```
public static Object getStaticFieldValue(Class<?> aClass,
                                         String fieldName)
```
    Retrieve a class members value.
    
    Parameters:
    
    aClass - the class in which to retrieve a field
    
    fieldName - the class member name, in which to retrieve its value
    
    Returns:
    
    the value of the field.
  - isNativeClass
```
public static boolean isNativeClass(String className)
```
    Determines if the supplied class name is a native class.
    
    Parameters:
    
    className - the fully qualified Java class name
    
    Returns:
    
    true if the supplied class name is a valid Java class; false otherwise
  - primitiveToWrapper
```
public static Class<?> primitiveToWrapper(Class<?> cls)
```
  - wrapperToPrimitive
```
public static Class<?> wrapperToPrimitive(Class<?> cls)
```
  - isType
```
public static boolean isType(Class<?> type,
                             Class<?>... classes)
```
    Determines if the supplied Class if of any of the supplied Class types.
    
    Parameters:
    
    type - the type to check
    
    classes - the classes to compare type against
    
    Returns:
    
    true if type is any of the supplied classes; false otherwise
  - inheritsFrom
```
public static boolean inheritsFrom(Class<?> child,
                                   Class<?> parent)
```
    Determines if the supplied child class inherits from the supplied parent class.
    
    Parameters:
    
    child -
    
    parent -
    
    Returns:
    
    true if child inherits from parent, false otherwise
  - doesImplement
```
public static boolean doesImplement(Class<?> testMe,
                                    Class<?> aInterface)
```
    Determines if the supplied testMe class implements the supplied interface.
    
    Parameters:
    
    testMe -
    
    aInterface -
    
    Returns:
    
    true if the testMe class implements aInterface, false otherwise.
  - getAllDeclaredMethods
```
public static List<Method> getAllDeclaredMethods(Class<?> aClass)
```
    Retrieves all of the methods defined in the supplied Class. This will navigate up the class hierarchy up until the Object class is reached.
    This will not grab any methods annotated with LeolaIgnore.
    
    Parameters:
    
    aClass - the class to grab all the public methods from.
    
    Returns:
    
    the List of public Methods.
  - getAllDeclaredFields
```
public static List<Field> getAllDeclaredFields(Class<?> aClass)
```
    Retrieves all of the fields defined in the supplied Class. This will navigate up the class hierarchy up until the Object class is reached.
    This will not grab any fields annotated with LeolaIgnore.
    
    Parameters:
    
    aClass - the class to grab all the public fields from.
    
    Returns:
    
    the List of public Fields.
  - getInheritedMethodByName
```
public static Method getInheritedMethodByName(Class<?> aClass,
                                              String name,
                                              Class<?>[] parameterTypes)
```
    Get the method by name and parameter types. It walks the class hierarchy and attempts to find the method by using Class.getMethod(String, Class...).
    
    Parameters:
    
    aClass - the class to check
    
    methodName - the methods name
    
    parameterTypes - the parameter types.
    
    Returns:
    
    the Method if found; otherwise null.
  - getInheritedField
```
public static Field getInheritedField(Class<?> aClass,
                                      String fieldName)
```
    Get the data member by name. It walks the class hierarchy and attempts to find the field.
    
    Parameters:
    
    aClass - the class to check
    
    fieldName - the data member name
    
    Returns:
    
    the Field if found; otherwise null.
  - getAnnotation
```
public static <T extends Annotation> T getAnnotation(Class<T> annotation,
                                                     Class<?> ownerClass,
                                                     Method method)
```
    Retrieves the annotation from the method, if it is not on the method, the parent is checked. This solves the "inherited annotation" problem for interfaces.
    
    Parameters:
    
    annotation - the annotation to look for
    
    ownerClass - the class in which this method belongs to
    
    method - the method which should be probed for annotations
    
    Returns:
    
    the Annotation instance if found; otherwise null
  - newNativeInstance
```
public static LeoNativeClass newNativeInstance(String className,
                                               LeoObject... params)
                                        throws LeolaRuntimeException
```
    Creates a new LeoNativeClass based off of the Java fully qualified name and supplied parameters.
    
    Parameters:
    
    className - the fully qualified Java class name
    
    params - the parameters used to construct the instance
    
    Returns:
    
    the LeoNativeClass
    
    Throws:
    
    LeolaRuntimeException

Class ClassUtil

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

STRING

BOOLEAN

BYTE

CHAR

SHORT

INT

LONG

FLOAT

DOUBLE

INTEGER

NUMBER

Constructor Detail

ClassUtil

Method Detail

getMethodByName

getMethodsByName

getMethodsByAnnotationAlias

getMethodByAnnotationAlias

invokeMethod

invokeMethod

invokeMethod

getFieldValue

getStaticFieldValue

isNativeClass

primitiveToWrapper

wrapperToPrimitive

isType

inheritsFrom

doesImplement

getAllDeclaredMethods

getAllDeclaredFields

getInheritedMethodByName

getInheritedField

getAnnotation

newNativeInstance