one.microstream.reflect

Class XReflect

java.lang.Object

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 and 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, Predicate<? super Field> predicate)
static Field	getAnyField(Class<?> c, String name)
static Method	getAnyMethod(Class<?> c, Predicate<? super Method> predicate)
static Method	getAnyMethod(Class<?> c, String name)
static <T> Class<T>	getClass(T object)
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 int	getField_int(Field f, Object obj)
static Field	getField(Class<?> c, String name)
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 typeName) Calls tryResolveType(String, ClassLoader) with defaultTypeResolvingClassLoader().
static Class<?>	tryResolveType(String typeName, 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 Detail

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.

classLoader - class loader from which the class must be loaded

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 - 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)

tryResolveType

public static final Class<?> tryResolveType(String typeName,
                                            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:

typeName - the type name to be resolved, primitive name or full qualified type name.

classLoader - class loader from which the class must be loaded

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:

classLoader - class loader from which the class must be loaded

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:

classLoader - class loader from which the class must be loaded

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 - 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)

tryResolveType

public static final Class<?> tryResolveType(String typeName)

Calls tryResolveType(String, ClassLoader) with defaultTypeResolvingClassLoader(). Make sure this is a suitable ClassLoader when using this method.

Parameters:

typeName - the type name to be resolved, primitive name or full qualified type name.

Returns:

the Class instance representing the passed class name or null if unresolevable.

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 - 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.

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)

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 - the super type

S - the same or sub type

Parameters:

superClassInstance - the super instance

sameOrSubClassInstance - ths sub or sub instance

Throws:

IllegalArgumentException - if the check fails

getSuperClassNonNull

public static final Class<?> getSuperClassNonNull(Class<?> c)