org.apache.reef.tang.util

Class ReflectionUtilities

java.lang.Object

org.apache.reef.tang.util.ReflectionUtilities

public final class ReflectionUtilities
extends Object

Field Summary

Fields

Modifier and Type	Field and Description
static String	REGEXP This is used to split Java classnames.

Method Summary

Methods

Modifier and Type	Method and Description
static Class<?>	boxClass(Class<?> c) Given a primitive type, return its boxed representation.
static Iterable<Type>	classAndAncestors(Type c) Given a Type, return all of the classes it extends and interfaces it implements (including the class itself).
static Class<?>	classForName(String name, ClassLoader loader) Lookup the provided name using the provided classloader.
static String	getFullName(Field f) Return the full name of the provided field.
static String	getFullName(Type name) Return the full name of the raw type of the provided Type.
static Type	getInterfaceTarget(Class<?> iface, Type type) This method takes a class called clazz that *directly* implements a generic interface or generic class, iface.
static Type	getNamedParameterTargetOrNull(Class<?> clazz)
static Class<?>	getRawClass(Type clazz) Coerce a Type into a Class.
static String	getSimpleName(Type name) Get the simple name of the class.
static boolean	isCoercable(Class<?> to, Class<?> from) Check to see if one class can be coerced into another.

Methods inherited from class java.lang.Object

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

Field Detail

REGEXP

public static final String REGEXP

This is used to split Java classnames. Currently, we split on . and on $

See Also:

Constant Field Values

Method Detail

boxClass

public static Class<?> boxClass(Class<?> c)

Given a primitive type, return its boxed representation.

Examples:

boxClass(int.class) -> Integer.class
 boxClass(String.class) -> String.class
 

Parameters:

c - The class to be boxed.

Returns:

The boxed version of c, or c if it is not a primitive type.

classAndAncestors

public static Iterable<Type> classAndAncestors(Type c)

Given a Type, return all of the classes it extends and interfaces it implements (including the class itself).

Examples:

Integer.class -> {Integer.class, Number.class, Object.class}
 T -> Object
 ? -> Object
 HashSet<T> -> {HashSet<T>, Set<T>, Collection<T>, Object}
 FooEventHandler -> {FooEventHandler, EventHandler<Foo>, Object}
 

isCoercable

public static boolean isCoercable(Class<?> to,
                  Class<?> from)

Check to see if one class can be coerced into another. A class is coercable to another if, once both are boxed, the target class is a superclass or implemented interface of the source class.

If both classes are numeric types, then this method returns true iff the conversion will not result in a loss of precision.

TODO: Float and double are currently coercible to int and long. This is a bug.

classForName

public static Class<?> classForName(String name,
                    ClassLoader loader)
                             throws ClassNotFoundException

Lookup the provided name using the provided classloader. This method includes special handling for primitive types, which can be looked up by short name (all other types need to be looked up by long name).

Throws:

ClassNotFoundException

getSimpleName

public static String getSimpleName(Type name)

Get the simple name of the class. This varies from the one in Class, in that it returns "1" for Classes like java.lang.String$1 In contrast, String.class.getSimpleName() returns "", which is not unique if java.lang.String$2 exists, causing all sorts of strange bugs.

Parameters:

name -

Returns:

getFullName

public static String getFullName(Type name)

Return the full name of the raw type of the provided Type.

Examples:

java.lang.String.class -> "java.lang.String"
 Set<String> -> "java.util.Set"  // such types can occur as constructor arguments, for example
 

Parameters:

name -

Returns:

getFullName

public static String getFullName(Field f)

Return the full name of the provided field. This will be globally unique. Following Java semantics, the full name will have all the generic parameters stripped out of it.

Example:

Set<X> { int size; } -> java.util.Set.size
 

getInterfaceTarget

public static Type getInterfaceTarget(Class<?> iface,
                      Type type)
                               throws IllegalArgumentException

This method takes a class called clazz that *directly* implements a generic interface or generic class, iface. Iface should take a single parameter, which this method will return.

TODO This is only tested for interfaces, and the type parameters associated with method arguments. TODO Not sure what we should do in the face of deeply nested generics (eg: Set<Set<String>) TODO Recurse up the class hierarchy in case there are intermediate interfaces

Parameters:

iface - A generic interface; we're looking up it's first (and only) parameter.

type - A type that is more specific than clazz, or clazz if no such type is available.

Returns:

The class implemented by the interface, or null(?) if the instantiation was not generic.

Throws:

IllegalArgumentException - if clazz does not directly implement iface.

getNamedParameterTargetOrNull

public static Type getNamedParameterTargetOrNull(Class<?> clazz)
                                          throws ClassHierarchyException

Parameters:

clazz -

Returns:

T if clazz implements Name<T>, null otherwise

Throws:

BindException - If clazz's definition incorrectly uses Name or @NamedParameter

ClassHierarchyException

getRawClass

public static Class<?> getRawClass(Type clazz)

Coerce a Type into a Class. This strips out any generic paramters, and resolves wildcards and free parameters to Object.

Examples:

java.util.Set<String> -> java.util.Set
 ? extends T -> Object
 T -> Object
 ? -> Object