one.microstream.reflect.XReflect

public final class XReflect
extends Object

Provides additional generic util methods for working with java reflection.

Method Summary

Modifier and Type	Method	Description
`static int`	`calculatePrimitivesLength(Field[] primFields)`
`static Field[]`	`collectInstanceFields(Class<?> objectClass)`
`static Field[]`	`collectInstanceFields(Class<?> objectClass, Predicate<? super Field> selector)`
`static Field[]`	`collectPrimitiveFieldsByByteSize(Field[] fields, int byteSize)`
`static <T, S extends T> S`	`copyFields(T source, S target)`
`static <T, S extends T> S`	`copyFields(T source, S target, Predicate<? super Field> fieldSelector)`
`static <T, S extends T> S`	`copyFields(T source, S target, Predicate<? super Field> fieldSelector, CopyPredicate copySelector)`
`static <T> T`	`defaultInstantiate(Class<T> type)`
`static ClassLoader`	`defaultTypeResolvingClassLoader()`	Local alias for `ClassLoader.getSystemClassLoader()`.
`static String`	`deriveFieldIdentifier(Field field)`
`static char`	`fieldIdentifierDelimiter()`
`static Field`	`getAnyField(Class<?> c, String name)`
`static Field`	`getAnyField(Class<?> c, Predicate<? super Field> predicate)`
`static Method`	`getAnyMethod(Class<?> c, String name)`
`static Method`	`getAnyMethod(Class<?> c, Predicate<? super Method> predicate)`
`static <T> Class<T>`	`getClass(T object)`	sigh
`static Class<?>[]`	`getClassHierarchyInterfaces(Class<?> classClass)`
`static <T> Constructor<T>`	`getDeclaredConstructor(Class<T> c, Class<?>... parameterTypes)`
`static Class<?>`	`getDeclaredEnumClass(Class<?> c)`
`static Field`	`getDeclaredField(Class<?> c, String name)`
`static Method`	`getDeclaredMethod(Class<?> c, String name, Class<?>... parameterTypes)`
`static Field`	`getField(Class<?> c, String name)`
`static int`	`getField_int(Field f, Object obj)`
`static String`	`getFieldIdentifierClassName(String fieldIdentifier)`
`static int`	`getFieldIdentifierDelimiterIndex(String identifier)`
`static String`	`getFieldIdentifierFieldName(String fieldIdentifier)`
`static Object`	`getFieldValue(Field field, Object obj)`	Calls `Field.get(Object)` and wraps the abstraction-destroying checked `IllegalAccessException` with a proper `IllegalAccessRuntimeException`.
`static Field`	`getInstanceFieldOfType(Class<?> declaringType, Class<?> fieldType)`
`static Class<?>`	`getSuperClassNonNull(Class<?> c)`
`static boolean`	`hasEnumeratedTypeName(Class<?> type)`
`static boolean`	`implementsInterface(Class<?> c, Class<?> interfaceClass)`
`static <T> T`	`invoke(Constructor<T> constructor, Object... args)`
`static <T> T`	`invoke(Method method, Object instance, Object... args)`
`static boolean`	`isAbstract(Class<?> type)`
`static boolean`	`isAbstract(Method method)`
`static boolean`	`isActualClass(Class<?> type)`
`static boolean`	`isDeclaredEnum(Class<?> c)`
`static boolean`	`isDefaultVisible(Member field)`
`static boolean`	`isEnum(Class<?> c)`	Utility method fixing the WRONGLY implemented `Class.isEnum()`.
`static boolean`	`isFinal(Member field)`
`static boolean`	`isInstanceField(Field field)`
`static boolean`	`isInterfaceOfType(Class<?> interfaceClass, Class<?> implementedSuperInterface)`
`static boolean`	`isJavaUtilCollectionType(Class<?> type)`	Checks if the passed type is equal to or a sub type of `Collection` or `Map`.
`static boolean`	`isNotTransient(Field field)`
`static boolean`	`isOfAnyType(Class<?> subject, Class<?>... supertypes)`
`static boolean`	`isOfAnyType(Class<?> subject, Iterable<Class<?>> supertypes)`
`static boolean`	`isOfClassType(Class<?> c, Class<?> superclass)`
`static boolean`	`isPrimitive(Field field)`
`static boolean`	`isPrimitiveTypeName(String typeName)`
`static boolean`	`isPrivate(Member field)`
`static boolean`	`isProtected(Member field)`
`static boolean`	`isProxyClass(Class<?> c)`
`static boolean`	`isPublic(Member field)`
`static boolean`	`isReference(Field field)`
`static boolean`	`isStatic(Member field)`
`static boolean`	`isStaticFinal(Member field)`
`static boolean`	`isSubClassOf(Class<?> c, Class<?> superclass)`
`static boolean`	`isSubEnum(Class<?> c)`
`static boolean`	`isSynthetic(Member field)`
`static boolean`	`isTransient(Field field)`
`static boolean`	`isValidProxyClass(Class<?> c)`
`static <C extends Consumer<? super Method>> C`	`iterateAllClassMethods(Class<?> clazz, C logic)`
`static <C extends Consumer<? super Method>> C`	`iterateAllClassMethods(Class<?> clazz, Class<?> bound, C logic)`
`static <L extends Consumer<Field>> L`	`iterateDeclaredFieldsUpwards(Class<?> startingClass, Class<?> boundingClass, L logic)`	Iterates over every declared field of all classes upwards starting at startingClass until class boundingClass is reached and executes the passed `Consumer` on it.
`static <L extends Consumer<Field>> L`	`iterateDeclaredFieldsUpwards(Class<?> startingClass, L logic)`	Alias for `iterateDeclaredFieldsUpwards(startingClass, Object.class, logic)`.
`static Class<?>`	`iterativeResolveType(ClassLoader classLoader, String... typeNames)`	Alias for `tryIterativeResolveType(ClassLoader, String...)` with the following difference: If none of the passed typeNames can be resolved, a `ClassNotFoundException` listing all passed typeNames is thrown.
`static Class<?>`	`iterativeResolveType(String... typeNames)`	Calls `iterativeResolveType(ClassLoader, String...)` with `defaultTypeResolvingClassLoader()`.
`static char`	`nestedClassNameSeparator()`
`static Object`	`resolveEnumConstantInstance(Class<?> type, int ordinal)`
`static <T> T`	`resolveEnumConstantInstanceTyped(Class<T> type, int ordinal)`
`static Class<?>`	`resolveType(String typeName)`	Calls `resolveType(String, ClassLoader)` with `defaultTypeResolvingClassLoader()`.
`static Class<?>`	`resolveType(String typeName, ClassLoader classLoader)`	Resolves the passed type name to a runtime type (instance of type `Class`).
`static Class<?>`	`resolveTypeForName(String typeName)`	Uses `Class.forName(String)` which uses the calling class's `ClassLoader`.
`static Field`	`setAccessible(Class<?> actualClass, Field field)`
`static <T> Constructor<T>`	`setAccessible(Constructor<T> constructor)`
`static Field`	`setAccessible(Field field)`
`static Method`	`setAccessible(Method method)`
`static void`	`setFieldValue(Field field, Object obj, Object value)`	Calls `Field.set(Object, Object)` and wraps the abstraction-destroying checked `IllegalAccessException` with a proper `IllegalAccessRuntimeException`.
`static String`	`toFieldName(Field field)`
`static String`	`toFullQualifiedFieldName(Class<?> actualClass, Field field)`
`static String`	`toFullQualifiedFieldName(Class<?> c, String fieldName)`
`static Field`	`tryGetDeclaredField(Class<?> declaringClass, String fieldName)`
`static Class<?>`	`tryIterativeResolveType(ClassLoader classLoader, String... typeNames)`	This methods attempts to resolve the passed typeNames to `Class` instances using `resolveType(String, ClassLoader)` one by one.
`static Class<?>`	`tryIterativeResolveType(String... typeNames)`
`static Class<?>`	`tryResolvePrimitiveType(String className)`
`static Class<?>`	`tryResolveType(String className)`	Calls `tryResolveType(String, ClassLoader)` with `defaultTypeResolvingClassLoader()`.
`static Class<?>`	`tryResolveType(String className, ClassLoader classLoader)`	Calls `resolveType(String, ClassLoader)`, but suppresses any `ClassNotFoundException` and returns `null` instead.
`static String`	`typename_enum()`
`static <A> Class<A>`	`validateArrayType(Class<A> arrayType)`
`static <T, S extends T> void`	`validateFamiliarClass(T superClassInstance, S sameOrSubClassInstance)`	Checks if `superClassInstance.getClass().isAssignableFrom(sameOrSubClassInstance.getClass())`
`static <A> Class<A>`	`validateInterfaceType(Class<A> type)`
`static <T> Class<T>`	`validateIsEnum(Class<T> type)`
`static <A> Class<A>`	`validateNonArrayType(Class<A> type)`
`static <A> Class<A>`	`validateNonInterfaceType(Class<A> type)`
`static <A> Class<A>`	`validateNonPrimitiveType(Class<A> primitiveType)`
`static <A> Class<A>`	`validatePrimitiveType(Class<A> primitiveType)`
`static <T> Instantiator<T>`	`WrapDefaultConstructor(Class<T> type)`

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details
- defaultInstantiate
  
  public static final <T> T defaultInstantiate(Class<T> type) throws NoSuchMethodRuntimeException, InstantiationRuntimeException
  
  Throws:
  
  NoSuchMethodRuntimeException
  
  InstantiationRuntimeException
- setAccessible
  
  public static final Field setAccessible(Class<?> actualClass, Field field)
- setAccessible
  
  public static final Field setAccessible(Field field) throws SecurityException
  
  Throws:
  
  SecurityException
- setAccessible
  
  public static final Method setAccessible(Method method) throws SecurityException
  
  Throws:
  
  SecurityException
- setAccessible
  
  public static final <T> Constructor<T> setAccessible(Constructor<T> constructor) throws SecurityException
  
  Throws:
  
  SecurityException
- isInstanceField
  
  public static final boolean isInstanceField(Field field)
- toFieldName
  
  public static final String toFieldName(Field field)
- isInterfaceOfType
  
  public static final boolean isInterfaceOfType(Class<?> interfaceClass, Class<?> implementedSuperInterface)
- implementsInterface
  
  public static final boolean implementsInterface(Class<?> c, Class<?> interfaceClass)
- getClassHierarchyInterfaces
  
  public static final Class<?>[] getClassHierarchyInterfaces(Class<?> classClass)
- isOfClassType
  
  public static final boolean isOfClassType(Class<?> c, Class<?> superclass)
- isSubClassOf
  
  public static final boolean isSubClassOf(Class<?> c, Class<?> superclass)
- isActualClass
  
  public static final boolean isActualClass(Class<?> type)
- isEnum
  
  public static boolean isEnum(Class<?> c)
  
  Utility method fixing the WRONGLY implemented Class.isEnum().
  Their description is weird ("if this class was declared as an enum in the source code") and the implemented behavior is dangerous and useless to identify all classes of instances that are enums.
  For enum anonymous inner class instances (writing { ... } behind an enum constant), Class.isEnum() returns false on the generated type. That is a bug since the type is still an enum, a sub class of Enum. So the correct way of testing a class for being an enum is using java.lang.Enum.class.isAssignableFrom(...). This method does that.
  
  Parameters:
  
  c - the Class to be tested.
  
  Returns:
  
  whether the passed Class is a sub class of Enum, i.e. an enum.
- isDeclaredEnum
  
  public static boolean isDeclaredEnum(Class<?> c)
- isSubEnum
  
  public static boolean isSubEnum(Class<?> c)
- getDeclaredEnumClass
  
  public static Class<?> getDeclaredEnumClass(Class<?> c)
- resolveEnumConstantInstance
  
  public static Object resolveEnumConstantInstance(Class<?> type, int ordinal)
- resolveEnumConstantInstanceTyped
  
  public static <T> T resolveEnumConstantInstanceTyped(Class<T> type, int ordinal)
- validateIsEnum
  
  public static <T> Class<T> validateIsEnum(Class<T> type)
- iterateDeclaredFieldsUpwards
  
  public static final <L extends Consumer<Field>> L iterateDeclaredFieldsUpwards(Class<?> startingClass, L logic)
  
  Alias for iterateDeclaredFieldsUpwards(startingClass, Object.class, logic).
  
  Type Parameters:
  
  L - The logic's contextual type.
  
  Parameters:
  
  startingClass - the class whose fields shall be iterated.
  
  logic - the Consumer to be executed on each field.
  
  Returns:
  
  the passed logic.
- iterateDeclaredFieldsUpwards
  
  public static final <L extends Consumer<Field>> L iterateDeclaredFieldsUpwards(Class<?> startingClass, Class<?> boundingClass, L logic)
  
  Iterates over every declared field of all classes upwards starting at startingClass until class boundingClass is reached and executes the passed Consumer on it.
  The declared fields of each class are iterated in reverse order (from index Class.getDeclaredFields().length - 1 to index 0 ).
  This method is useful to maintain the natural declaration order of the fields, iterating from the last declared field of the lowest class (the passed class itself) to the first declared field of the highest class declaring a field.
  
  Type Parameters:
  
  L - The logic's contextual type.
  
  Parameters:
  
  startingClass - the class whose fields shall be iterated.
  
  boundingClass - the class in the hierarchy at which to stop iterating, exclusive bound.
  
  logic - the Consumer to be executed on each field.
  
  Returns:
  
  the passed logic.
- getDeclaredField
  
  public static final Field getDeclaredField(Class<?> c, String name) throws NoSuchFieldRuntimeException
  
  Throws:
  
  NoSuchFieldRuntimeException
- getDeclaredMethod
  
  public static final Method getDeclaredMethod(Class<?> c, String name, Class<?>... parameterTypes) throws NoSuchFieldRuntimeException
  
  Throws:
  
  NoSuchFieldRuntimeException
- getDeclaredConstructor
  
  public static final <T> Constructor<T> getDeclaredConstructor(Class<T> c, Class<?>... parameterTypes) throws NoSuchFieldRuntimeException
  
  Throws:
  
  NoSuchFieldRuntimeException
- getField
  
  public static final Field getField(Class<?> c, String name) throws NoSuchFieldRuntimeException
  
  Throws:
  
  NoSuchFieldRuntimeException
- getAnyField
  
  public static final Field getAnyField(Class<?> c, String name) throws NoSuchFieldRuntimeException
  
  Throws:
  
  NoSuchFieldRuntimeException
- getAnyField
  
  public static final Field getAnyField(Class<?> c, Predicate<? super Field> predicate) throws NoSuchFieldRuntimeException
  
  Throws:
  
  NoSuchFieldRuntimeException
- getInstanceFieldOfType
  
  public static final Field getInstanceFieldOfType(Class<?> declaringType, Class<?> fieldType) throws NoSuchFieldRuntimeException
  
  Throws:
  
  NoSuchFieldRuntimeException
- getAnyMethod
  
  public static final Method getAnyMethod(Class<?> c, String name) throws NoSuchMethodRuntimeException
  
  Throws:
  
  NoSuchMethodRuntimeException
- getAnyMethod
  
  public static final Method getAnyMethod(Class<?> c, Predicate<? super Method> predicate) throws NoSuchMethodRuntimeException
  
  Throws:
  
  NoSuchMethodRuntimeException
- iterateAllClassMethods
  
  public static final <C extends Consumer<? super Method>> C iterateAllClassMethods(Class<?> clazz, C logic)
- iterateAllClassMethods
  
  public static final <C extends Consumer<? super Method>> C iterateAllClassMethods(Class<?> clazz, Class<?> bound, C logic)
- isFinal
  
  public static final boolean isFinal(Member field)
- isStatic
  
  public static final boolean isStatic(Member field)
- isSynthetic
  
  public static final boolean isSynthetic(Member field)
- isStaticFinal
  
  public static final boolean isStaticFinal(Member field)
- isPrimitive
  
  public static final boolean isPrimitive(Field field)
- isReference
  
  public static final boolean isReference(Field field)
- isTransient
  
  public static final boolean isTransient(Field field)
- isNotTransient
  
  public static final boolean isNotTransient(Field field)
- isPrivate
  
  public static final boolean isPrivate(Member field)
- isProtected
  
  public static final boolean isProtected(Member field)
- isPublic
  
  public static final boolean isPublic(Member field)
- isDefaultVisible
  
  public static final boolean isDefaultVisible(Member field)
- isAbstract
  
  public static final boolean isAbstract(Class<?> type)
- isAbstract
  
  public static final boolean isAbstract(Method method)
- getFieldValue
  
  public static final Object getFieldValue(Field field, Object obj)
  
  Calls Field.get(Object) and wraps the abstraction-destroying checked IllegalAccessException with a proper IllegalAccessRuntimeException.
  
  Parameters:
  
  field - the field from which the value shall be extracted.
  
  obj - object from which the represented field's value is to be extracted
  
  Returns:
  
  the value of the represented field in object obj; primitive values are wrapped in an appropriate object before being returned
- invoke
  
  public static final <T> T invoke(Constructor<T> constructor, Object... args)
- invoke
  
  public static final <T> T invoke(Method method, Object instance, Object... args)
- setFieldValue
  
  public static final void setFieldValue(Field field, Object obj, Object value)
  
  Calls Field.set(Object, Object) and wraps the abstraction-destroying checked IllegalAccessException with a proper IllegalAccessRuntimeException.
  
  Parameters:
  
  field - the field to be modified
  
  obj - the object whose field should be modified
  
  value - the new value for the field of obj being modified
- getField_int
  
  public static int getField_int(Field f, Object obj) throws IllegalAccessRuntimeException
  
  Throws:
  
  IllegalAccessRuntimeException
- resolveType
  
  public static final Class<?> resolveType(String typeName, ClassLoader classLoader) throws LinkageError, ExceptionInInitializerError, ClassNotFoundException
  
  Resolves the passed type name to a runtime type (instance of type Class). In contrary to JDK's type resolving mechanisms, this method resolves primitive type names, as well.
  Note on naming:
  1.) Looking up a runtime type instance for a type name string is best described as "resolving" the type.
  2.) The things that are resolved are TYPES (classes, interfaces, arrays and in later Java versions enums and annotations), not just classes. That the java inventors seemingly didn't understand their own type system and just called everything "Class" on the API-level,* even interfaces, is just an error that should be repeated as less as possible.
  
  Parameters:
  
  typeName - the type name to be resolved, primitive name or full qualified type name.
  
  Returns:
  
  the resolved type instance (of type Class)
  
  Throws:
  
  LinkageError - see Class.forName(String)
  
  ExceptionInInitializerError - see Class.forName(String)
  
  ClassNotFoundException - see Class.forName(String)
- resolveTypeForName
  
  public static final Class<?> resolveTypeForName(String typeName) throws LinkageError, ExceptionInInitializerError, ClassNotFoundException
  
  Uses Class.forName(String) which uses the calling class's ClassLoader.
  
  Parameters:
  
  typeName -
  
  Throws:
  
  LinkageError
  
  ExceptionInInitializerError
  
  ClassNotFoundException
- tryResolveType
  
  public static final Class<?> tryResolveType(String className, ClassLoader classLoader)
  
  Calls resolveType(String, ClassLoader), but suppresses any ClassNotFoundException and returns null instead. This is useful if the passed class name is only potentially resolvable at runtime and is still valid if not. Example: resolving a old type dictionary as far as possible and marking the not resolvable types as unresolvable.
  
  Parameters:
  
  className -
  
  Returns:
  
  the Class instance representing the passed class name or null if unresolevable.
- iterativeResolveType
  
  public static final Class<?> iterativeResolveType(ClassLoader classLoader, String... typeNames) throws ClassNotFoundException
  
  Alias for tryIterativeResolveType(ClassLoader, String...) with the following difference:
  If none of the passed typeNames can be resolved, a ClassNotFoundException listing all passed typeNames is thrown.
  
  Parameters:
  
  typeNames - the full qualified type names to be attempted to be resolved one by one.
  
  Returns:
  
  the first successfully resolved Class instance.
  
  Throws:
  
  ClassNotFoundException - if none of the passed typeNames could have been resolved.
  
  See Also:
  
  tryIterativeResolveType(ClassLoader, String...)
- tryIterativeResolveType
  
  public static final Class<?> tryIterativeResolveType(ClassLoader classLoader, String... typeNames)
  
  This methods attempts to resolve the passed typeNames to Class instances using resolveType(String, ClassLoader) one by one. The Class instance of the first successful attempt is returned. If none of the passed typeNames can be resolved, null is returned. See iterativeResolveType(ClassLoader, String...) for an exception-throwing version.
  Note:
  While it is generally a bad idea to just use a trial and error approach until something works, a logic like this is required to resolve types whose packages changes accross different versions of a library. If the different full qualified class names are known, they can be used in an iterative attempt to resolve the class, hence avoiding hard dependencies to certain library versions in the using code by moving type names from imports at compile time to dynamic class resolving at runtime.
  However, this approach has its limits, of course. If too much changes (field names, method names, parameters, behavior) the dynamic strategy results in chaos as the compiler gets more and more circumvented and more and more source code is transformed into contextless plain strings.
  Therefore, when in doubt, it is preferable to stick to the general notion of this method being a "bad idea" and finding a more reliable solution.
  
  Parameters:
  
  typeNames - the full qualified type names to be attempted to be resolved one by one.
  
  Returns:
  
  the first successfully resolved Class instance or null
  
  See Also:
  
  resolveType(String, ClassLoader)
- defaultTypeResolvingClassLoader
  
  public static final ClassLoader defaultTypeResolvingClassLoader()
  
  Local alias for ClassLoader.getSystemClassLoader().
  
  Returns:
  
  the system class loader.
- resolveType
  
  public static final Class<?> resolveType(String typeName) throws LinkageError, ExceptionInInitializerError, ClassNotFoundException
  
  Calls resolveType(String, ClassLoader) with defaultTypeResolvingClassLoader(). Make sure this is a suitable ClassLoader when using this method.
  
  Parameters:
  
  typeName -
  
  Throws:
  
  LinkageError
  
  ExceptionInInitializerError
  
  ClassNotFoundException
- tryResolveType
  
  public static final Class<?> tryResolveType(String className)
  
  Calls tryResolveType(String, ClassLoader) with defaultTypeResolvingClassLoader(). Make sure this is a suitable ClassLoader when using this method.
  
  Parameters:
  
  className -
- iterativeResolveType
  
  public static final Class<?> iterativeResolveType(String... typeNames) throws ClassNotFoundException
  
  Calls iterativeResolveType(ClassLoader, String...) with defaultTypeResolvingClassLoader(). Make sure this is a suitable ClassLoader when using this method.
  
  Parameters:
  
  typeNames -
  
  Throws:
  
  ClassNotFoundException
- tryIterativeResolveType
  
  public static final Class<?> tryIterativeResolveType(String... typeNames)
- tryGetDeclaredField
  
  public static final Field tryGetDeclaredField(Class<?> declaringClass, String fieldName)
- tryResolvePrimitiveType
  
  public static final Class<?> tryResolvePrimitiveType(String className)
- isPrimitiveTypeName
  
  public static boolean isPrimitiveTypeName(String typeName)
- isOfAnyType
  
  public static final boolean isOfAnyType(Class<?> subject, Class<?>... supertypes)
- isOfAnyType
  
  public static final boolean isOfAnyType(Class<?> subject, Iterable<Class<?>> supertypes)
- getClass
  
  public static <T> Class<T> getClass(T object)
  
  *sigh*
  
  Parameters:
  
  object -
- fieldIdentifierDelimiter
  
  public static char fieldIdentifierDelimiter()
- typename_enum
  
  public static String typename_enum()
- nestedClassNameSeparator
  
  public static char nestedClassNameSeparator()
- toFullQualifiedFieldName
  
  public static String toFullQualifiedFieldName(Class<?> actualClass, Field field)
- deriveFieldIdentifier
  
  public static String deriveFieldIdentifier(Field field)
- toFullQualifiedFieldName
  
  public static String toFullQualifiedFieldName(Class<?> c, String fieldName)
- getFieldIdentifierDelimiterIndex
  
  public static int getFieldIdentifierDelimiterIndex(String identifier)
- getFieldIdentifierClassName
  
  public static String getFieldIdentifierClassName(String fieldIdentifier)
- getFieldIdentifierFieldName
  
  public static String getFieldIdentifierFieldName(String fieldIdentifier)
- validateInterfaceType
  
  public static <A> Class<A> validateInterfaceType(Class<A> type)
- validateNonInterfaceType
  
  public static <A> Class<A> validateNonInterfaceType(Class<A> type)
- validateNonArrayType
  
  public static <A> Class<A> validateNonArrayType(Class<A> type)
- validateArrayType
  
  public static <A> Class<A> validateArrayType(Class<A> arrayType)
- validatePrimitiveType
  
  public static <A> Class<A> validatePrimitiveType(Class<A> primitiveType)
- validateNonPrimitiveType
  
  public static <A> Class<A> validateNonPrimitiveType(Class<A> primitiveType)
- WrapDefaultConstructor
  
  public static <T> Instantiator<T> WrapDefaultConstructor(Class<T> type) throws NoSuchMethodRuntimeException
  
  Throws:
  
  NoSuchMethodRuntimeException
- isJavaUtilCollectionType
  
  public static boolean isJavaUtilCollectionType(Class<?> type)
  
  Checks if the passed type is equal to or a sub type of Collection or Map.
  Sad that such a method is necessary in the first place, but here we are.
  (See XMap for an example on how to do it correctly.)
  
  Parameters:
  
  type - the type to be checked.
  
  Returns:
  
  whether or not the passed type is a java.util collection "in the broader sense".
  
  See Also:
  
  Collection, Map
- hasEnumeratedTypeName
  
  public static boolean hasEnumeratedTypeName(Class<?> type)
- isProxyClass
  
  public static boolean isProxyClass(Class<?> c)
- isValidProxyClass
  
  public static boolean isValidProxyClass(Class<?> c)
- collectPrimitiveFieldsByByteSize
  
  public static Field[] collectPrimitiveFieldsByByteSize(Field[] fields, int byteSize)
- collectInstanceFields
  
  public static final Field[] collectInstanceFields(Class<?> objectClass)
- collectInstanceFields
  
  public static final Field[] collectInstanceFields(Class<?> objectClass, Predicate<? super Field> selector)
- calculatePrimitivesLength
  
  public static int calculatePrimitivesLength(Field[] primFields)
- copyFields
  
  public static <T, S extends T> S copyFields(T source, S target)
- copyFields
  
  public static <T, S extends T> S copyFields(T source, S target, Predicate<? super Field> fieldSelector)
- copyFields
  
  public static <T, S extends T> S copyFields(T source, S target, Predicate<? super Field> fieldSelector, CopyPredicate copySelector)
- validateFamiliarClass
  
  public static <T, S extends T> void validateFamiliarClass(T superClassInstance, S sameOrSubClassInstance)
  
  Checks if superClassInstance.getClass().isAssignableFrom(sameOrSubClassInstance.getClass())
  
  Type Parameters:
  
  T -
  
  S -
  
  Parameters:
  
  superClassInstance -
  
  sameOrSubClassInstance -
- getSuperClassNonNull
  
  public static final Class<?> getSuperClassNonNull(Class<?> c)

Class XReflect

Method Summary

Methods inherited from class java.lang.Object

Method Details