ru.vyarus.java.generics.resolver.util

Class GenericsResolutionUtils

java.lang.Object

ru.vyarus.java.generics.resolver.util.GenericsResolutionUtils

public final class GenericsResolutionUtils
extends java.lang.Object

Generics analysis utilities.

Since:

11.05.2018

Method Summary

Modifier and Type	Method and Description
static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>	fillOuterGenerics(java.lang.reflect.Type type, java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> generics, java.util.Map<java.lang.Class<?>,java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>> knownGenerics) Inner class could reference outer class generics and so this generics must be included into class context.
static java.util.Map<java.lang.Class<?>,java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>>	resolve(java.lang.Class<?> type, java.lang.Class<?>... ignoreClasses) Analyze class hierarchy and resolve actual generic values for all composing types.
static java.util.Map<java.lang.Class<?>,java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>>	resolve(java.lang.Class<?> type, java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> rootGenerics, java.util.Map<java.lang.Class<?>,java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>> knownGenerics, java.util.List<java.lang.Class<?>> ignoreClasses) Analyze class hierarchy and resolve actual generic values for all composing types.
static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>	resolveDirectRawGenerics(java.lang.Class<?> type) Resolve type generics by declaration (as upper bound).
static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>	resolveDirectRawGenerics(java.lang.reflect.Constructor constructor, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) Resolve constructor generics by declaration (as upper bound).
static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>	resolveDirectRawGenerics(java.lang.reflect.Method method, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) Resolve method generics by declaration (as upper bound).
static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>	resolveGenerics(java.lang.reflect.Type type, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) Resolve declared generics for type (actually declared generics in context of some type).
static java.lang.reflect.Type	resolveRawGeneric(java.lang.reflect.TypeVariable variable, java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> generics) Extracts declared upper bound from generic declaration.
static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>	resolveRawGenerics(java.lang.Class<?> type) Resolve type generics by declaration (as upper bound).

Methods inherited from class java.lang.Object

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

Method Detail

resolve

public static java.util.Map<java.lang.Class<?>,java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>> resolve(java.lang.Class<?> type,
                                                                                                                         java.lang.Class<?>... ignoreClasses)

Analyze class hierarchy and resolve actual generic values for all composing types. Root type generics (if present) will be resolved as upper bound from declaration.

Parameters:

type - type to resolve generics for

ignoreClasses - classes to ignore (if required)

Returns:

resolved generics for all types in class hierarchy

See Also:

for more custom resolution

resolve

public static java.util.Map<java.lang.Class<?>,java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>> resolve(java.lang.Class<?> type,
                                                                                                                         java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> rootGenerics,
                                                                                                                         java.util.Map<java.lang.Class<?>,java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>> knownGenerics,
                                                                                                                         java.util.List<java.lang.Class<?>> ignoreClasses)

Analyze class hierarchy and resolve actual generic values for all composing types. Root type generics must be specified directly.

If generics are known for some middle type, then they would be used "as is" instead of generics tracked from root. Also, known generics will be used for lower hierarchy resolution.

Parameters:

type - class to analyze

rootGenerics - resolved root type generics (including owner type generics); must not be null!

knownGenerics - type generics known before analysis (some middle class generics are known) and could contain possible outer generics (types for sure not included in resolving type hierarchy); must not be null, but could be empty map

ignoreClasses - classes to ignore during analysis

Returns:

resolved generics for all types in class hierarchy

resolveGenerics

public static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> resolveGenerics(java.lang.reflect.Type type,
                                                                                               java.util.Map<java.lang.String,java.lang.reflect.Type> generics)

Resolve declared generics for type (actually declared generics in context of some type). If provided class is inner class - resolves outer class generics as upper bound

If type is not ParameterizedType and so does not contains actual generics info, resolve generics from type declaration (resolveRawGenerics(Class)),

Parameters:

type - type to resolve generics for

generics - generics of context class

Returns:

resolved generics of parameterized type or empty map

resolveRawGenerics

public static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> resolveRawGenerics(java.lang.Class<?> type)

Resolve type generics by declaration (as upper bound). Used for cases when actual generic definition is not available (so actual generics are unknown). In most cases such generics resolved as Object (for example, Some<T>).

If class is inner class, resolve outer class generics (which may be used in class)

Parameters:

type - class to analyze generics for

Returns:

resolved generics (including outer class generics) or empty map if not generics used

See Also:

to resolve without outer type

resolveDirectRawGenerics

public static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> resolveDirectRawGenerics(java.lang.Class<?> type)

Resolve type generics by declaration (as upper bound). Used for cases when actual generic definition is not available (so actual generics are unknown). In most cases such generics resolved as Object (for example, Some<T>).

Parameters:

type - class to analyze generics for

Returns:

resolved generics or empty map if not generics used

See Also:

to include outer type generics

resolveDirectRawGenerics

public static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> resolveDirectRawGenerics(java.lang.reflect.Method method,
                                                                                                        java.util.Map<java.lang.String,java.lang.reflect.Type> generics)

Resolve method generics by declaration (as upper bound). Generics are resolved as upper bound (because it is all available type information). For example, public <T extends Serializable> do(T param) contains generic T which must be resolved as Serializable.

Parameters:

method - method to analyze generics for

generics - context class generics (which could be used in method generics declarations)

Returns:

resolved generics or empty map if method does not contain generics

resolveDirectRawGenerics

public static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> resolveDirectRawGenerics(java.lang.reflect.Constructor constructor,
                                                                                                        java.util.Map<java.lang.String,java.lang.reflect.Type> generics)

Resolve constructor generics by declaration (as upper bound). Generics are resolved as upper bound (because it is all available type information). For example, public <T extends Serializable> MyType(T param) contains generic T which must be resolved as Serializable.

Parameters:

constructor - constructor to analyze generics for

generics - context class generics (which could be used in constructor generics declarations)

Returns:

resolved generics or empty map if constructor does not contain generics

resolveRawGeneric

public static java.lang.reflect.Type resolveRawGeneric(java.lang.reflect.TypeVariable variable,
                                                       java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> generics)

Extracts declared upper bound from generic declaration. For example, Base<T> will be resolved as Object (default bound). Base<T extends A & B> resolved as "impossible" wildcard ? extends A & B in order to preserve all known information.

Map of already resolved generics is required because declaration may rely on them. For example, Base<T extends Serializable, K extends T> could be solved as T = Serializable, K = Serializable.

Parameters:

variable - generic declaration to analyze

generics - already resolved generics (on the left of current)

Returns:

either upper bound class or wildcard with multiple bounds

fillOuterGenerics

public static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> fillOuterGenerics(java.lang.reflect.Type type,
                                                                                                 java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> generics,
                                                                                                 java.util.Map<java.lang.Class<?>,java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>> knownGenerics)

Inner class could reference outer class generics and so this generics must be included into class context.

Outer generics could be included into declaration like Outer<String>.Inner field. In this case incoming type should be ParameterizedType with generified owner.

When provided type is simply a class (or anything resolvable to class), then outer class generics are resolved as upper bound (by declaration). Class may declare the same generic name and, in this case, outer generic will be ignored (as not visible).

During inlying context resolution, if outer generic is not declared in type we can try to guess it: we know outer context, and, if outer class is in outer context hierarchy, we could assume that it's actual parent class and so we could use more specific generics. This will be true for most sane cases (often inner class is used inside owner), but other cases are still possible (anyway, the chance that inner class will appear in two different hierarchies of outer class is quite small).

It is very important to use returned map instead of passed in map because, incoming empty map is always replaced to avoid modifications of shared empty maps.

Parameters:

type - context type

generics - resolved type generics

knownGenerics - map of known middle generics and possibly known outer context (outer context may contain outer class generics declarations). May be null.

Returns:

actual generics map (incoming map may be default empty map and in this case it must be replaced)