JavaClassHelper (Esper API Documentation)

java.lang.Object
- com.espertech.esper.util.JavaClassHelper

```
public class JavaClassHelper
extends Object
```
Helper for questions about Java classes such as
what is the boxed type for a primitive type
is this a numeric type.

Constructor Summary

Constructors
Constructor and Description

JavaClassHelper()

Constructors
Constructor and Description
`JavaClassHelper()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`canCoerce(Class numberClassToBeCoerced, Class numberClassToCoerceTo)` Determines if a number can be coerced upwards to another number class without loss.
`static Number`	`coerceBoxed(Number numToCoerce, Class resultBoxedType)` Coerce the given number to the given type, assuming the type is a Boxed type.
`static CodegenExpression`	`coerceNumberBoxedToBoxedCodegen(CodegenExpression exprReturningBoxed, Class fromTypeBoxed, Class targetTypeBoxed)`
`static CodegenExpression`	`coerceNumberToBoxedCodegen(CodegenExpression expr, Class fromType, Class targetTypeBoxed)`
`static Set<Field>`	`findAnnotatedFields(Class targetClass, Class<? extends Annotation> annotation)`
`static Set<Method>`	`findAnnotatedMethods(Class targetClass, Class<? extends Annotation> annotation)`
`static Method`	`findRequiredMethod(Class clazz, String methodName)`
`static Object`	`getAnnotationHook(Annotation[] annotations, HookType hookType, Class interfaceExpected, EngineImportService engineImportService)` Returns an instance of a hook as specified by an annotation.
`static List<Annotation>`	`getAnnotations(Class<? extends Annotation> annotationClass, Annotation[] annotations)`
`static Class`	`getArithmaticCoercionType(Class typeOne, Class typeTwo)` Returns the coercion type for the 2 numeric types for use in arithmatic.
`static Class`	`getArrayType(Class resultType)`
`static String`	`getBoxedClassName(String className)` Returns for the class name given the class name of the boxed (wrapped) type if the class name is one of the Java primitive types.
`static Class`	`getBoxedType(Class clazz)` Returns the boxed class for the given class, or the class itself if already boxed or not a primitive type.
`static Class`	`getClassForName(String className, ClassForNameProvider classForNameProvider)` Returns the class given a fully-qualified class name.
`static Class`	`getClassForSimpleName(String className, ClassForNameProvider classForNameProvider)` Returns the boxed class for the given classname, recognizing all primitive and abbreviations, uppercase and lowercase.
`static Class`	`getClassInClasspath(String classname, ClassForNameProvider classForNameProvider)`
`static String`	`getClassLoaderId(ClassLoader classLoader)`
`static String`	`getClassNameFullyQualPretty(Class clazz)`
`static String`	`getClassNameFullyQualPrettyWithClassloader(Class clazz)`
`static Map<String,Object>`	`getClassObjectFromPropertyTypeNames(Properties properties, ClassForNameProvider classForNameProvider)`
`static Class`	`getCommonCoercionType(Class[] types)` Determines a common denominator type to which one or more types can be casted or coerced.
`static Class`	`getCompareToCoercionType(Class typeOne, Class typeTwo)` Returns for 2 classes to be compared via relational operator the Class type of common comparison.
`static Class`	`getComponentTypeOutermost(Class clazz)`
`static Class`	`getGenericFieldType(Field field, boolean isAllowNull)` Returns the generic type parameter of a return value by a field.
`static Class`	`getGenericFieldTypeMap(Field field, boolean isAllowNull)` Returns the generic type parameter of a return value by a field or method.
`static Class`	`getGenericReturnType(Method method, boolean isAllowNull)` Returns the generic type parameter of a return value by a method.
`static Class`	`getGenericReturnType(Method method, Field field, boolean isAllowNull)` Returns the generic type parameter of a return value by a field or method.
`static Class`	`getGenericReturnTypeMap(Method method, boolean isAllowNull)` Returns the second generic type parameter of a return value by a field or method.
`static Class`	`getGenericReturnTypeMap(Method method, Field field, boolean isAllowNull)` Returns the second generic type parameter of a return value by a field or method.
`static Class`	`getGenericType(Type t, int index)`
`static String`	`getMessageInvocationTarget(String statementName, Method method, String classOrPropertyName, Object[] args, Throwable targetException)`
`static Method`	`getMethodByName(Class clazz, String methodName)`
`static int`	`getNumberOfDimensions(Class clazz)`
`static String`	`getParameterAsString(Class param)` Returns a parameter as a string text, allowing null values to represent a null select expression type.
`static String`	`getParameterAsString(Class[] parameters)` Returns a comma-separated parameter type list in readable form, considering arrays and null-type parameters.
`static Class`	`getPrimitiveClassForName(String typeName)` Returns the class for a Java primitive type name, ignoring case, and considering String as a primitive.
`static Class`	`getPrimitiveType(Class clazz)` Returns the un-boxed class for the given class, or the class itself if already un-boxed or not a primitive type.
`static String`	`getSimpleNameForClass(Class clazz)`
`static void`	`getSuper(Class clazz, Set<Class> result)` Populates all interface and superclasses for the given class, recursivly.
`static Class[]`	`getSuperInterfaces(Class clazz)`
`static void`	`getSuperInterfaces(Class clazz, Set<Class> result)`
`static Object`	`instantiate(Class implementedOrExtendedClass, Class clazz)` Checks that the given class implements or extends the required interface (first parameter), and instantiates an object.
`static Object`	`instantiate(Class implementedOrExtendedClass, String className, ClassForNameProvider classForNameProvider)` Looks up the given class and checks that it implements or extends the required interface, and instantiates an object.
`static boolean`	`isAnnotationListed(Class<? extends Annotation> annotationClass, Annotation[] annotations)`
`static boolean`	`isArrayTypeCompatible(Class target, Class provided)`
`static boolean`	`isAssignmentCompatible(Class invocationType, Class declarationType)` Returns true if 2 classes are assignment compatible.
`static boolean`	`isBigNumberType(Class clazz)` Returns true if the type is one of the big number types, i.e.
`static boolean`	`isBoolean(Class clazz)` Determines if the class passed in is a boolean boxed or unboxed type.
`static boolean`	`isCollectionMapOrArray(Class returnType)`
`static boolean`	`isDatetimeClass(Class inputType)`
`static boolean`	`isFloatingPointClass(Class clazz)` Returns true if the supplied type is a floating point number.
`static boolean`	`isFloatingPointNumber(Number number)` Returns true if the Number instance is a floating point number.
`static boolean`	`isFragmentableType(Class propertyType)` Returns true if the Class is a fragmentable type, i.e.
`static Pair<String,Boolean>`	`isGetArrayType(String type)`
`static boolean`	`isImplementsCharSequence(Class type)`
`static boolean`	`isImplementsInterface(Class clazz, Class interfaceClass)` Method to check if a given class, and its superclasses and interfaces (deep), implement a given interface.
`static boolean`	`isJavaBuiltinDataType(Class clazz)` Returns true if the class passed in is a Java built-in data type (primitive or wrapper) including String and 'null'.
`static boolean`	`isNumeric(Class clazz)` Determines if the class passed in is one of the numeric classes.
`static boolean`	`isNumericNonFP(Class clazz)` Determines if the class passed in is one of the numeric classes and not a floating point.
`static boolean`	`isSignatureCompatible(Class<?>[] one, Class<?>[] two)`
`static boolean`	`isSimpleNameFullyQualfied(String simpleClassName, String fullyQualifiedClassname)` Returns true if the simple class name is the class name of the fully qualified classname.
`static boolean`	`isSubclassOrImplementsInterface(Class extendorOrImplementor, Class extendedOrImplemented)` Method to check if a given class, and its superclasses and interfaces (deep), implement a given interface or extend a given class.
`static Object`	`parse(Class clazz, String text)` Parse the String using the given Java built-in class for parsing.
`static String`	`printInstance(Object instance, boolean fullyQualified)`
`static Object`	`resolveIdentAsEnumConst(String constant, EngineImportService engineImportService, boolean isAnnotation)` Resolve a string constant as a possible enumeration value, returning null if not resolved.
`static void`	`setFieldForAnnotation(Object target, Class<? extends Annotation> annotation, Object value)`
`static Class[]`	`takeFirstN(Class[] classes, int numToTake)`
`static Type[]`	`takeFirstN(Type[] types, int numToTake)`
`static void`	`writeInstance(StringWriter writer, Object instance, boolean fullyQualified)`
`static void`	`writeInstance(StringWriter writer, String title, Object instance)`

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

- Constructor Detail
  - JavaClassHelper
```
public JavaClassHelper()
```
- Method Detail
  - isImplementsCharSequence
```
public static boolean isImplementsCharSequence(Class type)
```
  - isArrayTypeCompatible
```
public static boolean isArrayTypeCompatible(Class target,
                                            Class provided)
```
  - isCollectionMapOrArray
```
public static boolean isCollectionMapOrArray(Class returnType)
```
  - getBoxedType
```
public static Class getBoxedType(Class clazz)
```
    Returns the boxed class for the given class, or the class itself if already boxed or not a primitive type. For primitive unboxed types returns the boxed types, e.g. returns java.lang.Integer for passing int.class. For any other class, returns the class passed.
    
    Parameters:
    
    clazz - is the class to return the boxed class for
    
    Returns:
    
    boxed variant of the same class
  - getParameterAsString
```
public static String getParameterAsString(Class[] parameters)
```
    Returns a comma-separated parameter type list in readable form, considering arrays and null-type parameters.
    
    Parameters:
    
    parameters - is the parameter types to render
    
    Returns:
    
    rendered list of parameters
  - getParameterAsString
```
public static String getParameterAsString(Class param)
```
    Returns a parameter as a string text, allowing null values to represent a null select expression type.
    
    Parameters:
    
    param - is the parameter type
    
    Returns:
    
    string representation of parameter
  - getPrimitiveType
```
public static Class getPrimitiveType(Class clazz)
```
    Returns the un-boxed class for the given class, or the class itself if already un-boxed or not a primitive type. For primitive boxed types returns the unboxed primitive type, e.g. returns int.class for passing Integer.class. For any other class, returns the class passed.
    
    Parameters:
    
    clazz - is the class to return the unboxed (or primitive) class for
    
    Returns:
    
    primitive variant of the same class
  - isNumeric
```
public static boolean isNumeric(Class clazz)
```
    Determines if the class passed in is one of the numeric classes.
    
    Parameters:
    
    clazz - to check
    
    Returns:
    
    true if numeric, false if not
  - isNumericNonFP
```
public static boolean isNumericNonFP(Class clazz)
```
    Determines if the class passed in is one of the numeric classes and not a floating point.
    
    Parameters:
    
    clazz - to check
    
    Returns:
    
    true if numeric and not a floating point, false if not
  - isAssignmentCompatible
```
public static boolean isAssignmentCompatible(Class invocationType,
                                             Class declarationType)
```
    Returns true if 2 classes are assignment compatible.
    
    Parameters:
    
    invocationType - type to assign from
    
    declarationType - type to assign to
    
    Returns:
    
    true if assignment compatible, false if not
  - isBoolean
```
public static boolean isBoolean(Class clazz)
```
    Determines if the class passed in is a boolean boxed or unboxed type.
    
    Parameters:
    
    clazz - to check
    
    Returns:
    
    true if boolean, false if not
  - getArithmaticCoercionType
```
public static Class getArithmaticCoercionType(Class typeOne,
                                              Class typeTwo)
                                       throws CoercionException
```
    Returns the coercion type for the 2 numeric types for use in arithmatic. Note: byte and short types always result in integer.
    
    Parameters:
    
    typeOne - is the first type
    
    typeTwo - is the second type
    
    Returns:
    
    coerced type
    
    Throws:
    
    CoercionException - if types don't allow coercion
  - coerceBoxed
```
public static Number coerceBoxed(Number numToCoerce,
                                 Class resultBoxedType)
```
    Coerce the given number to the given type, assuming the type is a Boxed type. Allows coerce to lower resultion number. Does't coerce to primitive types.
    Meant for statement compile-time use, not for runtime use.
    
    Parameters:
    
    numToCoerce - is the number to coerce to the given type
    
    resultBoxedType - is the boxed result type to return
    
    Returns:
    
    the numToCoerce as a value in the given result type
  - coerceNumberBoxedToBoxedCodegen
```
public static CodegenExpression coerceNumberBoxedToBoxedCodegen(CodegenExpression exprReturningBoxed,
                                                                Class fromTypeBoxed,
                                                                Class targetTypeBoxed)
```
  - coerceNumberToBoxedCodegen
```
public static CodegenExpression coerceNumberToBoxedCodegen(CodegenExpression expr,
                                                           Class fromType,
                                                           Class targetTypeBoxed)
```
  - isFloatingPointNumber
```
public static boolean isFloatingPointNumber(Number number)
```
    Returns true if the Number instance is a floating point number.
    
    Parameters:
    
    number - to check
    
    Returns:
    
    true if number is Float or Double type
  - isFloatingPointClass
```
public static boolean isFloatingPointClass(Class clazz)
```
    Returns true if the supplied type is a floating point number.
    
    Parameters:
    
    clazz - to check
    
    Returns:
    
    true if primitive or boxed float or double
  - getCompareToCoercionType
```
public static Class getCompareToCoercionType(Class typeOne,
                                             Class typeTwo)
                                      throws CoercionException
```
    Returns for 2 classes to be compared via relational operator the Class type of common comparison. The output is always Long.class, Double.class, String.class or Boolean.class depending on whether the passed types are numeric and floating-point. Accepts primitive as well as boxed types.
    
    Parameters:
    
    typeOne - is the first type
    
    typeTwo - is the second type
    
    Returns:
    
    One of Long.class, Double.class or String.class
    
    Throws:
    
    CoercionException - if the types cannot be compared
  - isBigNumberType
```
public static boolean isBigNumberType(Class clazz)
```
    Returns true if the type is one of the big number types, i.e. BigDecimal or BigInteger
    
    Parameters:
    
    clazz - to check
    
    Returns:
    
    true for big number
  - canCoerce
```
public static boolean canCoerce(Class numberClassToBeCoerced,
                                Class numberClassToCoerceTo)
```
    Determines if a number can be coerced upwards to another number class without loss.
    Clients must pass in two classes that are numeric types.
    Any number class can be coerced to double, while only double cannot be coerced to float. Any non-floating point number can be coerced to long. Integer can be coerced to Byte and Short even though loss is possible, for convenience.
    
    Parameters:
    
    numberClassToBeCoerced - the number class to be coerced
    
    numberClassToCoerceTo - the number class to coerce to
    
    Returns:
    
    true if numbers can be coerced without loss, false if not
  - getBoxedClassName
```
public static String getBoxedClassName(String className)
```
    Returns for the class name given the class name of the boxed (wrapped) type if the class name is one of the Java primitive types.
    
    Parameters:
    
    className - is a class name, a Java primitive type or other class
    
    Returns:
    
    boxed class name if Java primitive type, or just same class name passed in if not a primitive type
  - isJavaBuiltinDataType
```
public static boolean isJavaBuiltinDataType(Class clazz)
```
    Returns true if the class passed in is a Java built-in data type (primitive or wrapper) including String and 'null'.
    
    Parameters:
    
    clazz - to check
    
    Returns:
    
    true if built-in data type, or false if not
  - getCommonCoercionType
```
public static Class getCommonCoercionType(Class[] types)
                                   throws CoercionException
```
    Determines a common denominator type to which one or more types can be casted or coerced. For use in determining the result type in certain expressions (coalesce, case).
    Null values are allowed as part of the input and indicate a 'null' constant value in an expression tree. Such as value doesn't have any type and can be ignored in determining a result type.
    For numeric types, determines a coercion type that all types can be converted to via the method getArithmaticCoercionType.
    Indicates that there is no common denominator type by throwing CoercionException.
    
    Parameters:
    
    types - is an array of one or more types, which can be Java built-in (primitive or wrapper) or user types
    
    Returns:
    
    common denominator type if any can be found, for use in comparison
    
    Throws:
    
    CoercionException - when no coercion type could be determined
  - getClassForName
```
public static Class getClassForName(String className,
                                    ClassForNameProvider classForNameProvider)
                             throws ClassNotFoundException
```
    Returns the class given a fully-qualified class name.
    
    Parameters:
    
    className - is the fully-qualified class name, java primitive types included.
    
    classForNameProvider - lookup of class for class name
    
    Returns:
    
    class for name
    
    Throws:
    
    ClassNotFoundException - if the class cannot be found
  - getClassForSimpleName
```
public static Class getClassForSimpleName(String className,
                                          ClassForNameProvider classForNameProvider)
                                   throws EventAdapterException
```
    Returns the boxed class for the given classname, recognizing all primitive and abbreviations, uppercase and lowercase.
    Recognizes "int" as Integer.class and "strIng" as String.class, and "Integer" as Integer.class, and so on.
    
    Parameters:
    
    className - is the name to recognize
    
    classForNameProvider - lookup of class for class name
    
    Returns:
    
    class
    
    Throws:
    
    EventAdapterException - is throw if the class cannot be identified
  - getSimpleNameForClass
```
public static String getSimpleNameForClass(Class clazz)
```
  - getPrimitiveClassForName
```
public static Class getPrimitiveClassForName(String typeName)
```
    Returns the class for a Java primitive type name, ignoring case, and considering String as a primitive.
    
    Parameters:
    
    typeName - is a potential primitive Java type, or some other type name
    
    Returns:
    
    class for primitive type name, or null if not a primitive type.
  - parse
```
public static Object parse(Class clazz,
                           String text)
```
    Parse the String using the given Java built-in class for parsing.
    
    Parameters:
    
    clazz - is the class to parse the value to
    
    text - is the text to parse
    
    Returns:
    
    value matching the type passed in
  - isImplementsInterface
```
public static boolean isImplementsInterface(Class clazz,
                                            Class interfaceClass)
```
    Method to check if a given class, and its superclasses and interfaces (deep), implement a given interface.
    
    Parameters:
    
    clazz - to check, including all its superclasses and their interfaces and extends
    
    interfaceClass - is the interface class to look for
    
    Returns:
    
    true if such interface is implemented by any of the clazz or its superclasses or extends by any interface and superclasses (deep check)
  - isSubclassOrImplementsInterface
```
public static boolean isSubclassOrImplementsInterface(Class extendorOrImplementor,
                                                      Class extendedOrImplemented)
```
    Method to check if a given class, and its superclasses and interfaces (deep), implement a given interface or extend a given class.
    
    Parameters:
    
    extendorOrImplementor - is the class to inspects its extends and implements clauses
    
    extendedOrImplemented - is the potential interface, or superclass, to check
    
    Returns:
    
    true if such interface is implemented by any of the clazz or its superclasses or extends by any interface and superclasses (deep check)
  - instantiate
```
public static Object instantiate(Class implementedOrExtendedClass,
                                 String className,
                                 ClassForNameProvider classForNameProvider)
                          throws ClassInstantiationException
```
    Looks up the given class and checks that it implements or extends the required interface, and instantiates an object.
    
    Parameters:
    
    implementedOrExtendedClass - is the class that the looked-up class should extend or implement
    
    className - of the class to load, check type and instantiate
    
    classForNameProvider - lookup of class for class name
    
    Returns:
    
    instance of given class, via newInstance
    
    Throws:
    
    ClassInstantiationException - if the type does not match or the class cannot be loaded or an object instantiated
  - instantiate
```
public static Object instantiate(Class implementedOrExtendedClass,
                                 Class clazz)
                          throws ClassInstantiationException
```
    Checks that the given class implements or extends the required interface (first parameter), and instantiates an object.
    
    Parameters:
    
    implementedOrExtendedClass - is the class that the looked-up class should extend or implement
    
    clazz - to check type and instantiate
    
    Returns:
    
    instance of given class, via newInstance
    
    Throws:
    
    ClassInstantiationException - if the type does not match or the class cannot be loaded or an object instantiated
  - getSuper
```
public static void getSuper(Class clazz,
                            Set<Class> result)
```
    Populates all interface and superclasses for the given class, recursivly.
    
    Parameters:
    
    clazz - to reflect upon
    
    result - set of classes to populate
  - isSimpleNameFullyQualfied
```
public static boolean isSimpleNameFullyQualfied(String simpleClassName,
                                                String fullyQualifiedClassname)
```
    Returns true if the simple class name is the class name of the fully qualified classname.
    This method does not verify validity of class and package names, it uses simple string compare inspecting the trailing part of the fully qualified class name.
    
    Parameters:
    
    simpleClassName - simple class name
    
    fullyQualifiedClassname - fully qualified class name contains package name and simple class name
    
    Returns:
    
    true if simple class name of the fully qualified class name, false if not
  - isFragmentableType
```
public static boolean isFragmentableType(Class propertyType)
```
    Returns true if the Class is a fragmentable type, i.e. not a primitive or boxed type or any of the common built-in types or does not implement Map.
    
    Parameters:
    
    propertyType - type to check
    
    Returns:
    
    true if fragmentable
  - getSuperInterfaces
```
public static Class[] getSuperInterfaces(Class clazz)
```
  - getSuperInterfaces
```
public static void getSuperInterfaces(Class clazz,
                                      Set<Class> result)
```
  - getGenericReturnType
```
public static Class getGenericReturnType(Method method,
                                         Field field,
                                         boolean isAllowNull)
```
    Returns the generic type parameter of a return value by a field or method.
    
    Parameters:
    
    method - method or null if field
    
    field - field or null if method
    
    isAllowNull - whether null is allowed as a return value or expected Object.class
    
    Returns:
    
    generic type parameter
  - getGenericReturnTypeMap
```
public static Class getGenericReturnTypeMap(Method method,
                                            Field field,
                                            boolean isAllowNull)
```
    Returns the second generic type parameter of a return value by a field or method.
    
    Parameters:
    
    method - method or null if field
    
    field - field or null if method
    
    isAllowNull - whether null is allowed as a return value or expected Object.class
    
    Returns:
    
    generic type parameter
  - getGenericReturnType
```
public static Class getGenericReturnType(Method method,
                                         boolean isAllowNull)
```
    Returns the generic type parameter of a return value by a method.
    
    Parameters:
    
    method - method or null if field
    
    isAllowNull - whether null is allowed as a return value or expected Object.class
    
    Returns:
    
    generic type parameter
  - getGenericReturnTypeMap
```
public static Class getGenericReturnTypeMap(Method method,
                                            boolean isAllowNull)
```
    Returns the second generic type parameter of a return value by a field or method.
    
    Parameters:
    
    method - method or null if field
    
    isAllowNull - whether null is allowed as a return value or expected Object.class
    
    Returns:
    
    generic type parameter
  - getGenericFieldType
```
public static Class getGenericFieldType(Field field,
                                        boolean isAllowNull)
```
    Returns the generic type parameter of a return value by a field.
    
    Parameters:
    
    field - field or null if method
    
    isAllowNull - whether null is allowed as a return value or expected Object.class
    
    Returns:
    
    generic type parameter
  - getGenericFieldTypeMap
```
public static Class getGenericFieldTypeMap(Field field,
                                           boolean isAllowNull)
```
    Returns the generic type parameter of a return value by a field or method.
    
    Parameters:
    
    field - field or null if method
    
    isAllowNull - whether null is allowed as a return value or expected Object.class
    
    Returns:
    
    generic type parameter
  - getGenericType
```
public static Class getGenericType(Type t,
                                   int index)
```
  - getAnnotationHook
```
public static Object getAnnotationHook(Annotation[] annotations,
                                       HookType hookType,
                                       Class interfaceExpected,
                                       EngineImportService engineImportService)
                                throws ExprValidationException
```
    Returns an instance of a hook as specified by an annotation.
    
    Parameters:
    
    annotations - to search
    
    hookType - type to look for
    
    interfaceExpected - interface required
    
    engineImportService - for resolving references
    
    Returns:
    
    hook instance
    
    Throws:
    
    ExprValidationException - if instantiation failed
  - resolveIdentAsEnumConst
```
public static Object resolveIdentAsEnumConst(String constant,
                                             EngineImportService engineImportService,
                                             boolean isAnnotation)
                                      throws ExprValidationException
```
    Resolve a string constant as a possible enumeration value, returning null if not resolved.
    
    Parameters:
    
    constant - to resolve
    
    engineImportService - for engine-level use to resolve enums, can be null
    
    isAnnotation - whether we are in an annotation
    
    Returns:
    
    null or enumeration value
    
    Throws:
    
    ExprValidationException - if there is an error accessing the enum
  - getArrayType
```
public static Class getArrayType(Class resultType)
```
  - getClassNameFullyQualPretty
```
public static String getClassNameFullyQualPretty(Class clazz)
```
  - getClassNameFullyQualPrettyWithClassloader
```
public static String getClassNameFullyQualPrettyWithClassloader(Class clazz)
```
  - getClassLoaderId
```
public static String getClassLoaderId(ClassLoader classLoader)
```
  - getMethodByName
```
public static Method getMethodByName(Class clazz,
                                     String methodName)
```
  - printInstance
```
public static String printInstance(Object instance,
                                   boolean fullyQualified)
```
  - writeInstance
```
public static void writeInstance(StringWriter writer,
                                 Object instance,
                                 boolean fullyQualified)
```
  - writeInstance
```
public static void writeInstance(StringWriter writer,
                                 String title,
                                 Object instance)
```
  - getMessageInvocationTarget
```
public static String getMessageInvocationTarget(String statementName,
                                                Method method,
                                                String classOrPropertyName,
                                                Object[] args,
                                                Throwable targetException)
```
  - isDatetimeClass
```
public static boolean isDatetimeClass(Class inputType)
```
  - getClassObjectFromPropertyTypeNames
```
public static Map<String,Object> getClassObjectFromPropertyTypeNames(Properties properties,
                                                                     ClassForNameProvider classForNameProvider)
```
  - getClassInClasspath
```
public static Class getClassInClasspath(String classname,
                                        ClassForNameProvider classForNameProvider)
```
  - isSignatureCompatible
```
public static boolean isSignatureCompatible(Class<?>[] one,
                                            Class<?>[] two)
```
  - findRequiredMethod
```
public static Method findRequiredMethod(Class clazz,
                                        String methodName)
```
  - getAnnotations
```
public static List<Annotation> getAnnotations(Class<? extends Annotation> annotationClass,
                                              Annotation[] annotations)
```
  - isAnnotationListed
```
public static boolean isAnnotationListed(Class<? extends Annotation> annotationClass,
                                         Annotation[] annotations)
```
  - findAnnotatedFields
```
public static Set<Field> findAnnotatedFields(Class targetClass,
                                             Class<? extends Annotation> annotation)
```
  - findAnnotatedMethods
```
public static Set<Method> findAnnotatedMethods(Class targetClass,
                                               Class<? extends Annotation> annotation)
```
  - setFieldForAnnotation
```
public static void setFieldForAnnotation(Object target,
                                         Class<? extends Annotation> annotation,
                                         Object value)
```
  - isGetArrayType
```
public static Pair<String,Boolean> isGetArrayType(String type)
```
  - takeFirstN
```
public static Class[] takeFirstN(Class[] classes,
                                 int numToTake)
```
  - takeFirstN
```
public static Type[] takeFirstN(Type[] types,
                                int numToTake)
```
  - getComponentTypeOutermost
```
public static Class getComponentTypeOutermost(Class clazz)
```
  - getNumberOfDimensions
```
public static int getNumberOfDimensions(Class clazz)
```

Class JavaClassHelper

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

JavaClassHelper

Method Detail

isImplementsCharSequence

isArrayTypeCompatible

isCollectionMapOrArray

getBoxedType

getParameterAsString

getParameterAsString

getPrimitiveType

isNumeric

isNumericNonFP

isAssignmentCompatible

isBoolean

getArithmaticCoercionType

coerceBoxed

coerceNumberBoxedToBoxedCodegen

coerceNumberToBoxedCodegen

isFloatingPointNumber

isFloatingPointClass

getCompareToCoercionType

isBigNumberType

canCoerce

getBoxedClassName

isJavaBuiltinDataType

getCommonCoercionType

getClassForName

getClassForSimpleName

getSimpleNameForClass

getPrimitiveClassForName

parse

isImplementsInterface

isSubclassOrImplementsInterface

instantiate

instantiate

getSuper

isSimpleNameFullyQualfied

isFragmentableType

getSuperInterfaces

getSuperInterfaces

getGenericReturnType

getGenericReturnTypeMap

getGenericReturnType

getGenericReturnTypeMap

getGenericFieldType

getGenericFieldTypeMap

getGenericType

getAnnotationHook

resolveIdentAsEnumConst

getArrayType

getClassNameFullyQualPretty

getClassNameFullyQualPrettyWithClassloader

getClassLoaderId

getMethodByName

printInstance

writeInstance

writeInstance

getMessageInvocationTarget

isDatetimeClass

getClassObjectFromPropertyTypeNames

getClassInClasspath

isSignatureCompatible

findRequiredMethod

getAnnotations

isAnnotationListed

findAnnotatedFields

findAnnotatedMethods

setFieldForAnnotation

isGetArrayType

takeFirstN

takeFirstN

getComponentTypeOutermost

getNumberOfDimensions