GenericsContext (generics-resolver 3.0.3 API)

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).

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

All Methods Instance Methods Concrete Methods
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).
    If provided type is primitive then wrapper will be used instead (for example, Integer instead of int).
    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).
    If provided type is primitive then wrapper will be used instead (for example, Integer instead of int).
    
    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

Class GenericsContext

Nested Class Summary

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

CURRENT_POSITION_MARKER

ownerType

ownerGenerics

allTypeGenerics

Constructor Detail

GenericsContext

GenericsContext

Method Detail

ownerClass

rootContext

isInlying

ownerGenericsMap

toString

getGenericsScope

getGenericsSource

type

method

constructor

inlyingType

inlyingTypeAs

chooseContext

switchContext

contextGenerics