de.lmu.ifi.dbs.elki.utilities
Class ClassGenericsUtil

java.lang.Object
  de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil

public final class ClassGenericsUtil
extends Object

Utils for handling class instantiation especially with respect to Java generics.

Due to the way generics are implemented - via erasure - type safety cannot be guaranteed properly at compile time here. These classes collect such cases using helper functions, so that we have to suppress these warnings only in one place.

Note that many of these situations are still type safe, i.e. an empty array of List> can indeed be cast into a List>.

The only one potentially unsafe is instantiateGenerics(java.lang.Class, java.lang.String), since we can't verify that the runtime type 'type' adhers to the compile time restriction T. When T is not generic, such a check is possible, and then the developer should use instantiate(java.lang.Class, java.lang.String) instead.

Constructor Summary

ClassGenericsUtil()

Method Summary

static <B,T extends B> T	castWithGenericsOrNull(Class<B> base, Object obj) Cast an object at a base class, but return a subclass (for Generics!).
static <T> T	instantiate(Class<T> type, String className) Returns a new instance of the given type for the specified className.
static <T> T	instantiateGenerics(Class<?> type, String className) Returns a new instance of the given type for the specified className.
static <T> ArrayList<T>[]	newArrayOfEmptyArrayList(int len) Create an array of len empty ArrayLists.
static <T> HashSet<T>[]	newArrayOfEmptyHashSet(int len) Create an array of len empty HashSets.
static <T> T[]	newArrayOfNull(int len, Class<T> base) Create an array (of null values) This is a common unchecked cast we have to do due to Java Generics limitations.
static <B,T extends B> T[]	toArray(Collection<T> coll, Class<B> base) Convert a collection to an array.
static <D,T extends D> Class<T>	uglyCastIntoSubclass(Class<D> cls) Cast the (erased) generics onto a class.
static <BASE,FROM extends BASE,TO extends BASE> Class<TO>	uglyCrossCast(Class<FROM> cls, Class<BASE> base) This class performs an ugly cast, from Class<F> to Class<T>, where both F and T need to extend B.

Methods inherited from class java.lang.Object

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

Constructor Detail

ClassGenericsUtil

public ClassGenericsUtil()

Method Detail

instantiate

public static <T> T instantiate(Class<T> type,
                                String className)
                     throws UnableToComplyException

Returns a new instance of the given type for the specified className.

If the Class for className is not found, the instantiation is tried using the package of the given type as package of the given className.

Type Parameters:

T - Class type for compile time type checking

Parameters:

type - desired Class type of the Object to retrieve

className - name of the class to instantiate

Returns:

a new instance of the given type for the specified className

Throws:

UnableToComplyException - if the instantiation cannot be performed successfully

instantiateGenerics

public static <T> T instantiateGenerics(Class<?> type,
                                        String className)
                             throws UnableToComplyException

Returns a new instance of the given type for the specified className.

If the Class for className is not found, the instantiation is tried using the package of the given type as package of the given className.

This is a weaker type checked version of "instantiate(java.lang.Class, java.lang.String)" for use with Generics.

Type Parameters:

T - Class type for compile time type checking

Parameters:

type - desired Class type of the Object to retrieve

className - name of the class to instantiate

Returns:

a new instance of the given type for the specified className

Throws:

UnableToComplyException - if the instantiation cannot be performed successfully

newArrayOfNull

public static <T> T[] newArrayOfNull(int len,
                                     Class<T> base)

Create an array (of null values) This is a common unchecked cast we have to do due to Java Generics limitations.

Type Parameters:

T - Type the array elements have

Parameters:

len - array size

base - template class for array creation.

Returns:

new array of null pointers.

toArray

public static <B,T extends B> T[] toArray(Collection<T> coll,
                                          Class<B> base)

Convert a collection to an array.

Type Parameters:

T - Type the array elements have

Parameters:

coll - collection to convert.

base - Template class for array creation.

Returns:

new array with the collection contents.

newArrayOfEmptyArrayList

public static <T> ArrayList<T>[] newArrayOfEmptyArrayList(int len)

Create an array of len empty ArrayLists. This is a common unchecked cast we have to do due to Java Generics limitations.

Type Parameters:

T - Type the list elements have

Parameters:

len - array size

Returns:

new array of ArrayLists

newArrayOfEmptyHashSet

public static <T> HashSet<T>[] newArrayOfEmptyHashSet(int len)

Create an array of len empty HashSets. This is a common unchecked cast we have to do due to Java Generics limitations.

Type Parameters:

T - Type the set elements have

Parameters:

len - array size

Returns:

new array of HashSets

uglyCastIntoSubclass

public static <D,T extends D> Class<T> uglyCastIntoSubclass(Class<D> cls)

Cast the (erased) generics onto a class. Note: this function is a hack - notice that it would allow you to up-cast any class! Still it is preferable to have this cast in one place than in dozens without any explanation. The reason this is needed is the following: There is no Class<Set<String>>.class. This method allows you to do Class<Set<String>> setclass = uglyCastIntoSubclass(Set.class); We can't type check at runtime, since we don't have T.

uglyCrossCast

public static <BASE,FROM extends BASE,TO extends BASE> Class<TO> uglyCrossCast(Class<FROM> cls,
                                                                               Class<BASE> base)

This class performs an ugly cast, from Class<F> to Class<T>, where both F and T need to extend B. The restrictions are there to avoid misuse of this cast helper. While this sounds really ugly, the common use case will be something like

 BASE = Class<Database>
 FROM = Class<Database>
 TO = Class<Database<V>>
 

i.e. the main goal is to add missing Generics to the compile time type.

Type Parameters:

BASE - Base type

TO - Destination type

FROM - Source type

Parameters:

cls - Class to be cast

base - Base class for type checking.

Returns:

Casted class.

castWithGenericsOrNull

public static <B,T extends B> T castWithGenericsOrNull(Class<B> base,
                                                       Object obj)

Cast an object at a base class, but return a subclass (for Generics!). The main goal of this is to allow casting an object from e.g. " List" to "List<Something>" without having to add SuppressWarnings everywhere.

Type Parameters:

B - Base type to cast at

T - Derived type returned

Parameters:

base - Base class to cast at

obj - Object

Returns:

Cast object or null.