Package nz.org.riskscape

Class ReflectionUtils

java.lang.Object

nz.org.riskscape.ReflectionUtils

public class ReflectionUtils
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static enum	ReflectionUtils.SearchOptions

Constructor Summary

Constructors

Constructor	Description
ReflectionUtils()

Method Summary

Modifier and Type	Method	Description
static Optional<Class<?>>	findCommonAncestorOfType(Class<?> lhs, Class<?> rhs, Class<?> lookFor)	Search through both classes hierarchies, looking for the most recent ancestor that is either equal to lookFor or an ancestor that implements lookFor.
static <T> Class<? extends T>	findImplementingClass(Class<T> iface, Class<? extends T> search, ReflectionUtils.SearchOptions... optionsArray)	Search through a class's hierarchy for an interface, returning the class or interface that implemented it.
static <T> Class<T>	findParameterClass(Class<?> subclass)
static <T> Class<T>	findParameterClass(Class<?> subclass, int parameterIndex)	Extracts the parameterized type (The T from MyClass<T>) from a parameterized subclass (e.g.
static List<Field>	getAnnotatedFields(Class<?> parameterClass, Class<? extends Annotation> annotationClass)
static List<Class<?>>	getInterfaces(Class<?> clazz)
static Optional<Field>	getPublicField(Class<?> clazz, String fieldName)	Very simple public field lookup method that returns empty if no such field exists
static <T> T	newInstance(Class<T> clazz)	Calls clazz.newInstance, wrapping the checked exceptions in an unchecked runtime exception
static <T, E extends Exception> T	newInstance(Class<T> clazz, Function<Exception,E> constructor)	Calls clazz.newInstance, wrapping the checked exceptions in an exception provided from constructor
static void	setField(Field field, Object instance, Object value)	Calls field.set(instance, value), wrapping the checked exception in an unchecked runtime exception

Methods inherited from class java.lang.Object

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

Constructor Details

ReflectionUtils

public ReflectionUtils()

Method Details

getAnnotatedFields

public static List<Field> getAnnotatedFields(Class<?> parameterClass,
 Class<? extends Annotation> annotationClass)

Returns:

all fields annotated with the desired annotation in the class hierarchy of the given class

getInterfaces

public static List<Class<?>> getInterfaces(Class<?> clazz)

Returns:

all interfaces that a class implements by following the class hierarchy up to object.

It does not include interfaces that are inherited by implemented interfaces. E.g. class foo implements bar. interface bar extends baz, getInterfaces(Foo.class) returns bar, but not baz.

findCommonAncestorOfType

public static Optional<Class<?>> findCommonAncestorOfType(Class<?> lhs,
 Class<?> rhs,
 Class<?> lookFor)

Search through both classes hierarchies, looking for the most recent ancestor that is either equal to lookFor or an ancestor that implements lookFor. See ReflectionUtilsTest for examples.

Parameters:

lhs - a type to search through

rhs - another type to search through

lookFor - either a parent class in the shared ancestry, or an interface a shared ancestor should implement.

Returns:

empty if lhs and rhs have no common ancestor of lookFor. If they have a common ancestor that is either exactly lookFor, or implements lookFor, then the ancestor is returned.

findImplementingClass

public static <T> Class<? extends T> findImplementingClass(Class<T> iface,
 Class<? extends T> search,
 ReflectionUtils.SearchOptions... optionsArray)

Search through a class's hierarchy for an interface, returning the class or interface that implemented it. See ReflectionUtilsTest for more details.

Type Parameters:

T - The type of the interface we're looking for

Parameters:

iface - the class instance for the interface we're looking for

search - where to start searching from

optionsArray - search options

Returns:

The implementing class. Will never return null, but can throw a RiskscapeException if the interface is implemented multiple times or is not found given the ReflectionUtils.SearchOptions.

newInstance

public static <T> T newInstance(Class<T> clazz)

Calls clazz.newInstance, wrapping the checked exceptions in an unchecked runtime exception

newInstance

public static <T,
E extends Exception> T newInstance(Class<T> clazz,
 Function<Exception,E> constructor)
                                             throws E

Calls clazz.newInstance, wrapping the checked exceptions in an exception provided from constructor

Throws:

E extends Exception

setField

public static void setField(Field field,
 Object instance,
 Object value)

Calls field.set(instance, value), wrapping the checked exception in an unchecked runtime exception

Also ensures that the field is set to accessible before attempting to set the value.

getPublicField

public static Optional<Field> getPublicField(Class<?> clazz,
 String fieldName)

Very simple public field lookup method that returns empty if no such field exists

findParameterClass

public static <T> Class<T> findParameterClass(Class<?> subclass)

findParameterClass

public static <T> Class<T> findParameterClass(Class<?> subclass,
 int parameterIndex)

Extracts the parameterized type (The T from MyClass<T>) from a parameterized subclass (e.g. Foo extends MyClass<Bar>). Normally, java's generics are runtime only, but subclasses keep their declared parameter types in their class metadata, and these are available in the reflection API - this method will extract a parameterized type and return it, as well as fudging the casting.

Parameters:

subclass - a class that declares type arguments

parameterIndex - the index of the declared type argument