ru.vyarus.java.generics.resolver.util

Class GenericsUtils

java.lang.Object

ru.vyarus.java.generics.resolver.util.GenericsUtils

public final class GenericsUtils
extends java.lang.Object

Helper utilities to correctly resolve generified types of super interfaces.

Since:

17.10.2014

Method Summary

Modifier and Type	Method and Description
static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type>	createGenericsMap(java.lang.Class<?> type, java.util.List<? extends java.lang.reflect.Type> generics) Converts type's known generics collection into generics map, suitable for usage with the api.
static java.util.Map<java.lang.String,java.lang.reflect.Type>	extractOwnerGenerics(java.lang.Class<?> type, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) It is important to keep possible outer class generics, because they may be used in type declarations.
static java.util.Map<java.lang.String,java.lang.reflect.Type>	extractTypeGenerics(java.lang.Class<?> type, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) Generics declaration may contain type's generics together with outer class generics (if type is inner class).
static java.lang.reflect.TypeVariable	findIncompatibleVariable(java.lang.reflect.Type type, java.lang.Class<?> context, GenericDeclarationScope contextScope, java.lang.reflect.GenericDeclaration contextSource) Generics visibility (from inside context class): Generics declared on class Generics declared on outer class (if current is inner) Constructor generics (if inside constructor) Method generics (if inside method) .
static java.util.List<java.lang.reflect.TypeVariable>	findVariables(java.lang.reflect.Type type) Searches for generic variable declarations in type.
static java.lang.Class<?>	getDeclarationClass(java.lang.reflect.GenericDeclaration source)
static java.lang.Class<?>	getDeclarationClass(java.lang.reflect.TypeVariable variable)
static java.lang.reflect.Type[]	getGenerics(java.lang.reflect.Type type, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) If type is a variable, looks actual variable type, if it contains generics.
static java.lang.Class<?>	getReturnClass(java.lang.reflect.Method method, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) Called to properly resolve return type of root finder or inherited finder method.
static java.util.List<java.lang.reflect.TypeVariable>	orderVariablesForResolution(java.util.List<java.lang.reflect.TypeVariable> variables) Order variables for consequent variables resolution (to support reverse order declaration cases).
static java.lang.Class<?>	resolveClass(java.lang.reflect.Type type, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) Resolves top class for provided type (for example, for generified classes like List<T> it returns base type List).
static java.util.List<java.lang.Class<?>>	resolveClasses(java.lang.reflect.Type[] types, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) Resolve classes of provided types.
static java.util.List<java.lang.Class<?>>	resolveGenericsOf(java.lang.reflect.Type type, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) Called to properly resolve generified type (e.g. generified method return).
static java.lang.reflect.Type[]	resolveTypeVariables(java.lang.reflect.Type[] types, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) Shortcut for resolveTypeVariables(Type, Map) to process multiple types at once.
static java.lang.reflect.Type	resolveTypeVariables(java.lang.reflect.Type type, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) Resolve type generics.
static java.lang.Class[]	resolveUpperBounds(java.lang.reflect.Type type, java.util.Map<java.lang.String,java.lang.reflect.Type> generics) In most cases resolveClass(Type, Map) could be used instead (for simplicity).

Methods inherited from class java.lang.Object

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

Method Detail

getReturnClass

public static java.lang.Class<?> getReturnClass(java.lang.reflect.Method method,
                                                java.util.Map<java.lang.String,java.lang.reflect.Type> generics)

Called to properly resolve return type of root finder or inherited finder method. Supposed to return enough type info to detect return type (collection, array or plain object).

Note: may return primitive because it might be important to differentiate actual value. Use TypeUtils.wrapPrimitive(Class) to box possible primitive, if required.

Parameters:

method - method to analyze

generics - generics resolution map for method class (will be null for root)

Returns:

return type class

getGenerics

public static java.lang.reflect.Type[] getGenerics(java.lang.reflect.Type type,
                                                   java.util.Map<java.lang.String,java.lang.reflect.Type> generics)

If type is a variable, looks actual variable type, if it contains generics. For ParameterizedType return actual type parameters, for simple class returns raw class generics.

Note: returned generics may contain variables inside!

Parameters:

type - type to get generics of

generics - context generics map

Returns:

type generics array or empty array

resolveGenericsOf

public static java.util.List<java.lang.Class<?>> resolveGenericsOf(java.lang.reflect.Type type,
                                                                   java.util.Map<java.lang.String,java.lang.reflect.Type> generics)

Called to properly resolve generified type (e.g. generified method return). For example, when calling for List<T> it will return type of T.

If called on class (e.g. List) then return raw generic definition (upper bounds).

Parameters:

type - type to analyze

generics - root class generics mapping

Returns:

resolved generic classes or empty list if type does not support generics

Throws:

UnknownGenericException - when found generic not declared on type (e.g. method generic)

resolveClass

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

Resolves top class for provided type (for example, for generified classes like List<T> it returns base type List).

Note: may return primitive because it might be important to differentiate actual value. Use TypeUtils.wrapPrimitive(Class) to box possible primitive, if required.

Parameters:

type - type to resolve

generics - root class generics mapping

Returns:

resolved class

Throws:

UnknownGenericException - when found generic not declared on type (e.g. method generic)

resolveClasses

public static java.util.List<java.lang.Class<?>> resolveClasses(java.lang.reflect.Type[] types,
                                                                java.util.Map<java.lang.String,java.lang.reflect.Type> generics)

Resolve classes of provided types.

Note: may return primitives because it might be important to differentiate actual value. Use TypeUtils.wrapPrimitive(Class) to box possible primitive, if required.

Parameters:

types - types to resolve

generics - type generics

Returns:

list of resolved types classes

resolveUpperBounds

public static java.lang.Class[] resolveUpperBounds(java.lang.reflect.Type type,
                                                   java.util.Map<java.lang.String,java.lang.reflect.Type> generics)

In most cases resolveClass(Type, Map) could be used instead (for simplicity). This method will only return different result for wildcards inside resolved types (where generics are replaced resolveTypeVariables(Type, Map)). Also, in contrast to resolveClass(Type, Map), method will replace primitive types with wrappers (int -> Integer etc.) because this method is used mostly for comparison logic and avoiding primitives simplifies it.

Wildcards are used to store raw resolution of generic declaration T extends Number & Comparable (but ? extends Number & Comparable is not allowed in java). Only for this case multiple bounds will be returned.

That precision may be important only for exact types compatibility logic.

Parameters:

type - type to resolve upper bounds

generics - known generics

Returns:

resolved upper bounds (at least one class)

Throws:

UnknownGenericException - when found generic not declared on type (e.g. method generic)

See Also:

supplement check method

resolveTypeVariables

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

Resolve type generics. Returned type will contain actual types instead of generic names. Most likely, returned type will be different than provided: for example, original type may be TypeVariable and returned will be simple Class (resolved generic value).

Special handling for ExplicitTypeVariable - this kind of type variable is not resolved and not throw exception as unknown generic (thought as resolved type). This may be used for cases when type variable must be preserved (like generics tracking or custom to string).

Note that upper bounded wildcards are flattened to simple type (? extends Somthing -> Something as upper bounded wildcards are not useful at runtime. The only exception is wildcard with multiple bounds (repackaged declaration T extends A&B). Wildcards with Object as bound are also flattened (List<? extends Object> --> List<Object>, List<?> --> List<Object>, List<? super Object> --> List<Object>.

Parameters:

type - type to resolve

generics - root class generics mapping

Returns:

resolved type

Throws:

UnknownGenericException - when found generic not declared on type (e.g. method generic)

resolveTypeVariables

public static java.lang.reflect.Type[] resolveTypeVariables(java.lang.reflect.Type[] types,
                                                            java.util.Map<java.lang.String,java.lang.reflect.Type> generics)

Shortcut for resolveTypeVariables(Type, Map) to process multiple types at once.

Parameters:

types - types to replace named generics in

generics - known generics

Returns:

types without named generics

extractOwnerGenerics

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

It is important to keep possible outer class generics, because they may be used in type declarations. NOTE: It may be not all generics of owner type, but only visible owner generics.

 class Outer<T, K> {
      // outer generic T hidden
      class Inner<T> {}
 }

In order to recover possibly missed outer generics use extractTypeGenerics(type, resultedMap) (may be required for proper owner type to string printing with all generics).

Parameters:

type - type

generics - all type's context generics (self + outer class)

Returns:

owner class generics if type is inner class or empty map if not

extractTypeGenerics

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

Generics declaration may contain type's generics together with outer class generics (if type is inner class). Return map itself for not inner class (or if no extra generics present in map).

In case when type's generic is not mentioned in map - it will be resolved from variable declaration.

Parameters:

type - type

generics - all type's context generics (self + outer class)

Returns:

generics, declared on type (A<T, K> -> T, K) or empty map if no generics declared on type

getDeclarationClass

public static java.lang.Class<?> getDeclarationClass(java.lang.reflect.TypeVariable variable)

Parameters:

variable - generic variable

Returns:

declaration class or null if not supported declaration source (should be impossible)

getDeclarationClass

public static java.lang.Class<?> getDeclarationClass(java.lang.reflect.GenericDeclaration source)

Parameters:

source - generic declaration source (could be null)

Returns:

declaration class or null if not supported declaration source (should be impossible)

createGenericsMap

public static java.util.LinkedHashMap<java.lang.String,java.lang.reflect.Type> createGenericsMap(java.lang.Class<?> type,
                                                                                                 java.util.List<? extends java.lang.reflect.Type> generics)

Converts type's known generics collection into generics map, suitable for usage with the api.

Note that if provided class is inner class then outer class generics will be added to the map to avoid unknown generics while using api with this map (see GenericsResolutionUtils.fillOuterGenerics(Type, LinkedHashMap, Map)).

Parameters:

type - type to build generics map for

generics - known generics (assumed in correct order)

Returns:

map of type generics

Throws:

java.lang.IllegalArgumentException - if type's generics count don't match provided list

findIncompatibleVariable

public static java.lang.reflect.TypeVariable findIncompatibleVariable(java.lang.reflect.Type type,
                                                                      java.lang.Class<?> context,
                                                                      GenericDeclarationScope contextScope,
                                                                      java.lang.reflect.GenericDeclaration contextSource)

Generics visibility (from inside context class):

• Generics declared on class
• Generics declared on outer class (if current is inner)
• Constructor generics (if inside constructor)
• Method generics (if inside method)

.

Parameters:

type - type to check

context - current context class

contextScope - current context scope (class, method, constructor)

contextSource - context source object (required for method and constructor scopes)

Returns:

first variable, containing generic not visible from current class or null if no violations

orderVariablesForResolution

public static java.util.List<java.lang.reflect.TypeVariable> orderVariablesForResolution(java.util.List<java.lang.reflect.TypeVariable> variables)

Order variables for consequent variables resolution (to support reverse order declaration cases). E.g. T extends List<K>, K, P extends Collection<T> must be resolved as 2, 1, 3 or T extends List<D>, D extends Collection<P>, P must be resolved as 3, 2, 1 or T extends List<D>, P, D extends Collection<P> must be resolved as 2, 3, 1 (otherwise resolution will fail due to unknown generic).

Note: incomplete set of variables could be provided: method order only provided vars, ignoring all other variables (assuming they are known). This allows using this method inside error handler (in order to process only not recognized vars).

Parameters:

variables - variables to order

Returns:

variables ordered for correct types resolution

findVariables

public static java.util.List<java.lang.reflect.TypeVariable> findVariables(java.lang.reflect.Type type)

Searches for generic variable declarations in type. May be used for scope checks. For example, in List<T> it will find "T", in Some<Long, T, List<K> "T" and "K".

Parameters:

type - type to analyze.

Returns:

list of generic variables inside type or empty list