ru.vyarus.java.generics.resolver.context

Class GenericsContext

java.lang.Object

ru.vyarus.java.generics.resolver.context.AbstractGenericsContext

ru.vyarus.java.generics.resolver.context.GenericsContext

Direct Known Subclasses:

ConstructorGenericsContext, MethodGenericsContext

public class GenericsContext
extends AbstractGenericsContext

Generics context of specific type (class) or inlying context (when root type context known). See AbstractGenericsContext for more information.

Not merged with AbstractGenericsContext in order to separate more specific implementation details from common generic utility methods.

Since:

26.06.2015

See Also:

AbstractGenericsContext, inlyingType(java.lang.reflect.Type)

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	GenericsContext.RootContextAwareTypeWriter Hierarchy writer with root context info (if available).

Field Summary

Fields

Modifier and Type	Field and Description
protected java.util.Map<java.lang.String,java.lang.reflect.Type>	allTypeGenerics
static java.lang.String	CURRENT_POSITION_MARKER Current hierarchy position marker (for toString).
protected java.util.Map<java.lang.String,java.lang.reflect.Type>	ownerGenerics
protected java.lang.Class<?>	ownerType

Fields inherited from class ru.vyarus.java.generics.resolver.context.AbstractGenericsContext

currentType, genericsInfo, typeGenerics

Constructor Summary

Constructors

Constructor and Description
GenericsContext(GenericsInfo genericsInfo, java.lang.Class<?> type)
GenericsContext(GenericsInfo genericsInfo, java.lang.Class<?> type, GenericsContext root)

Method Summary

Modifier and Type	Method and Description
GenericsContext	chooseContext(java.lang.reflect.Type type) Look for generic variables presence inside type and, if found, try to switch to correct context.
ConstructorGenericsContext	constructor(java.lang.reflect.Constructor constructor) Navigates current context to specific constructor (type context is switched to constructor declaring class).
protected java.util.Map<java.lang.String,java.lang.reflect.Type>	contextGenerics()
GenericDeclarationScope	getGenericsScope() For example, CLASS scope could resolve only class level generics, whereas METHOD could see method context generics.
java.lang.reflect.GenericDeclaration	getGenericsSource() Declaration source could be: class, method or constructor.
GenericsContext	inlyingType(java.lang.reflect.Type type) Build generics context for type in context of current class.
GenericsContext	inlyingTypeAs(java.lang.reflect.Type type, java.lang.Class<?> asType) Build generics context for type extending some generic type in context of current class.
boolean	isInlying() During reflection analysis it's common to review some internal type like field or method return type.
MethodGenericsContext	method(java.lang.reflect.Method method) Navigates current context to specific method (type context is switched to method declaring class).
java.lang.Class<?>	ownerClass() class Owner<T> { class Inner { T field; } }.
java.util.Map<java.lang.String,java.lang.reflect.Type>	ownerGenericsMap() Inner class may use outer generics like this: class Owner<T> { class Inner { T field; } }.
GenericsContext	rootContext()
protected GenericsContext	switchContext(java.lang.Class target, java.lang.String msgPrefix) Used to switch to appropriate context or fail if type is not found in hierarchy.
java.lang.String	toString()
GenericsContext	type(java.lang.Class<?> type) Navigates current context to specific type in class hierarchy.

Methods inherited from class ru.vyarus.java.generics.resolver.context.AbstractGenericsContext

currentClass, fieldType, fieldTypeAs, generic, generic, genericAsString, genericAsString, generics, genericsAsString, genericsMap, genericType, genericType, genericTypes, getGenericsInfo, resolveClass, resolveFieldClass, resolveFieldGeneric, resolveFieldGenerics, resolveFieldType, resolveGenericOf, resolveGenericsOf, resolveType, resolveTypeGenerics, toStringCurrentClass, toStringCurrentClassDeclaration, toStringType, visibleGenericsMap

Methods inherited from class java.lang.Object

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

Field Detail

CURRENT_POSITION_MARKER

public static final java.lang.String CURRENT_POSITION_MARKER

Current hierarchy position marker (for toString).

See Also:

Constant Field Values

ownerType

protected java.lang.Class<?> ownerType

ownerGenerics

protected java.util.Map<java.lang.String,java.lang.reflect.Type> ownerGenerics

allTypeGenerics

protected java.util.Map<java.lang.String,java.lang.reflect.Type> allTypeGenerics

Constructor Detail

GenericsContext

public GenericsContext(GenericsInfo genericsInfo,
                       java.lang.Class<?> type)

GenericsContext

public GenericsContext(GenericsInfo genericsInfo,
                       java.lang.Class<?> type,
                       GenericsContext root)

Method Detail

ownerClass

public java.lang.Class<?> ownerClass()

 class Owner<T> {
     class Inner {
         T field;
     }
 }

. For Inner class owner is Owner. For Owner class owner is null.

Note: interface class is always static (can't be inner, even if declared as inner).

Returns:

owner class if current class is inner, null otherwise

See Also:

ownerGenericsMap()

rootContext

public GenericsContext rootContext()

Returns:

root context (of class containing current type) for inlying context or null

See Also:

inlyingType(Type)

isInlying

public boolean isInlying()

During reflection analysis it's common to review some internal type like field or method return type. This types may be declared with context class generics, so to completely resolve this type we must know outer class generics. Contexts for such types resolved with outer context generic knowledge (inlyingType(Type)) are called inlying. You can always access root context for inlying using rootContext().

Returns:

true if context is inlying (context resolved with known outer context), false if context is resolved from root class

ownerGenericsMap

public java.util.Map<java.lang.String,java.lang.reflect.Type> ownerGenericsMap()

Inner class may use outer generics like this:

 class Owner<T> {
     class Inner {
         T field;
     }
 }

.

NOTE: contains only owner type generics, not hidden by inner class generics. For example:

 class Owner<T, K> {
      // hides outer generic
     class Inner<T> {}
 }

Here ownerGenericsMap() == ["K": Object] because owner generic "T" is overridden by inner class declaration.

In method or constructor contexts, context specific generics may also override owner generics (e.g. <T> T method();), but still all reachable by class owner generics wll be returned. This is done for consistency: no matter what context, method will return the same map. The only exception is AbstractGenericsContext.visibleGenericsMap() which return only actually visible generics from current context (class, method or constructor).

Returns:

reachable owner type generics if context type is inner class or empty map if not inner class or outer type does not contains generics

See Also:

ownerClass()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

getGenericsScope

public GenericDeclarationScope getGenericsScope()

Description copied from class: AbstractGenericsContext

For example, CLASS scope could resolve only class level generics, whereas METHOD could see method context generics. May be used for current context differentiation (instead of instanceof).

Specified by:

getGenericsScope in class AbstractGenericsContext

Returns:

maximum declaration scope for current context

See Also:

AbstractGenericsContext.getGenericsSource()

getGenericsSource

public java.lang.reflect.GenericDeclaration getGenericsSource()

Description copied from class: AbstractGenericsContext

Declaration source could be: class, method or constructor.

Specified by:

getGenericsSource in class AbstractGenericsContext

Returns:

declaration source for current context

See Also:

AbstractGenericsContext.getGenericsScope()

type

public GenericsContext type(java.lang.Class<?> type)

Description copied from class: AbstractGenericsContext

Navigates current context to specific type in class hierarchy.

Specified by:

type in class AbstractGenericsContext

Parameters:

type - class to navigate to

Returns:

new context instance specific to requested class or current context if type is the same

method

public MethodGenericsContext method(java.lang.reflect.Method method)

Description copied from class: AbstractGenericsContext

Navigates current context to specific method (type context is switched to method declaring class). It is required because method could contain it's own generics. For example, <T> void myMethod(T arg);.

Use context to work with method parameters, return type or resolving types inside method.

Specified by:

method in class AbstractGenericsContext

Parameters:

method - method in current class hierarchy to navigate to (may be method from subclass, relative to currently selected, in this case context type will be automatically switched)

Returns:

new context instance specific to requested method

constructor

public ConstructorGenericsContext constructor(java.lang.reflect.Constructor constructor)

Description copied from class: AbstractGenericsContext

Navigates current context to specific constructor (type context is switched to constructor declaring class). It is required because constructor could contain it's own generics. For example, <T> MyType(T arg).

Use context to work with constructor arguments.

Specified by:

constructor in class AbstractGenericsContext

Parameters:

constructor - constructor in current class hierarchy to navigate to (may be constructor from subclass, relative to currently selected, in this case context type is automatically switched)

Returns:

new context instance specific to requested constructor

inlyingType

public GenericsContext inlyingType(java.lang.reflect.Type type)

Description copied from class: AbstractGenericsContext

Build generics context for type in context of current class. This may be required to analyze class of field or method return type ("drill down"): new generics hierarchy must be built, but with correct resolution of root generics. For example:

 class A<T> {
    private C<T> field;
 }
 class C extends A<String> {}

To continue analysis of field type: type(A.class).inlyingType(A.class.getField("field") .getGenericType()) == generics context of C<String>

Use shortcut methods to simplify navigation: AbstractGenericsContext.fieldType(Field), MethodGenericsContext.returnType(), MethodGenericsContext.parameterType(int) and ConstructorGenericsContext.parameterType(int).

Check if type containing generics, belonging to different context in current hierarchy and automatically change context to properly resolve generics. Fails when it is impossible to correctly resolve generics (preventing incorrect usage).

If provided type did not contains generic then cached type resolution will be used (the same as GenericsResolver.resolve(Target.class) and if generics present then type will be built on each call.

Returned context holds reference to original (root) context: rootContext().

Ignored types, used for context creation, are counted (will also be ignored for inlying context building).

Specified by:

inlyingType in class AbstractGenericsContext

Parameters:

type - type to resolve hierarchy from (it must be generified type, resolved in current class)

Returns:

generics context of type (inlying context)

inlyingTypeAs

public GenericsContext inlyingTypeAs(java.lang.reflect.Type type,
                                     java.lang.Class<?> asType)

Description copied from class: AbstractGenericsContext

Build generics context for type extending some generic type in context of current class. This is required when only base/abstract type is declared in class, but we need to build context for actual value class use. In this case, we can build context from target implementation class (where generics are unknown) but include known generics for middle type (represented by provided). Useful for object instance analysis case (introspecting actual object).

Example case: field declaration is SomeInterface<T> field and we need to build inlying context for actual field value class SomeImpl<K> implements SomeInterface<K>. Type of root generic K will be tracked from known generic T (on interface), but even if it's not possible to track root generics, hierarchy starting from known type (interface in this case) will use correct generic value. This way, all known generics information is used.

Other than different target type, method is the same as AbstractGenericsContext.inlyingType(Type). By analogy, shortcuts are provided for simpler navigation: AbstractGenericsContext.fieldTypeAs(Field, Class), MethodGenericsContext.returnTypeAs(Class), MethodGenericsContext.parameterTypeAs(int, Class) and ConstructorGenericsContext.parameterTypeAs(int, Class).

Specified by:

inlyingTypeAs in class AbstractGenericsContext

Parameters:

type - type to resolve actual generics from (it must be generified type, resolved in current class)

asType - required target type to build generics context for (must include declared type as base class)

Returns:

generics context for required target type with correct type's generics (inlying context)

See Also:

AbstractGenericsContext.inlyingType(Type)

chooseContext

public GenericsContext chooseContext(java.lang.reflect.Type type)

Description copied from class: AbstractGenericsContext

Look for generic variables presence inside type and, if found, try to switch to correct context. Switching is based on declaration source information, contained inside generic.

Note that WrongGenericsContextException used instead of IllegalArgumentException, as in other cases, because it is more specific error: type may come from anywhere and it may be not so easy to track it's correct usage.

Specified by:

chooseContext in class AbstractGenericsContext

Parameters:

type - type, possibly containing generic variables

Returns:

correct context for generics resolution inside type or the same context if type does not contains generics

switchContext

protected GenericsContext switchContext(java.lang.Class target,
                                        java.lang.String msgPrefix)

Description copied from class: AbstractGenericsContext

Used to switch to appropriate context or fail if type is not found in hierarchy.

Note that this method may seem useless as correct context is always selected based on type generics, but method is required to show more specific error (better indicating context).

Specified by:

switchContext in class AbstractGenericsContext

Parameters:

target - target type

msgPrefix - error message prefix, identifying place

Returns:

correct context for type (may be current context instance)

See Also:

AbstractGenericsContext.chooseContext(Type)

contextGenerics

protected java.util.Map<java.lang.String,java.lang.reflect.Type> contextGenerics()

Specified by:

contextGenerics in class AbstractGenericsContext

Returns:

resolved generics mapping for current context