GenericsContext (generics-resolver 2.0.1 API)

java.lang.Object
- ru.vyarus.java.generics.resolver.context.GenericsContext

Direct Known Subclasses:

MethodGenericsContext, TypeGenericsContext
```
public abstract class GenericsContext
extends java.lang.Object
```
Context object wraps root type hierarchy generics information descriptor and provides utility methods for actual types resolution. Currently there are two types of contexts: type context (class) and method context.
Usage: navigate to required type context.type(MyClass.class) and use utility methods to get type's own generics or as helper for methods/fields introspection. To navigate to method context use context.method(method).

Every context object is immutable. Context doesn't hold actual types hierarchy (use reflection api in parallel if you need hierarchy info). Navigation is allowed to any class (within original root class hierarchy) from any child context. For convenience root class is also allowed (no matter the fact that it doesn't contain resolved generics).

API operated mainly on types, because it's the only way to resolve recursive generics: e.g. when you have List<Integer> then generic could be represented as Integer class, but if List<Collection<Integer>> we can't represent generic as class (Collection), because this makes actual collection generic not accessible)

Complete example: suppose we have class A extends B<Integer>. GenericsResolver.resolve(A.class).type(B.class).generic(0) == Integer.class

Since:

17.11.2014

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.lang.Class<?>`	`currentType`
`protected GenericsInfo`	`genericsInfo`
`protected java.util.Map<java.lang.String,java.lang.reflect.Type>`	`typeGenerics`

Constructor Summary

Constructors
Constructor and Description

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

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

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected abstract java.util.Map<java.lang.String,java.lang.reflect.Type>`	`contextGenerics()`
`java.lang.Class<?>`	`currentClass()`
`java.lang.Class<?>`	`generic(int position)` `class A extends B<Object, C<Long>>`.
`java.lang.Class<?>`	`generic(java.lang.String genericName)` `class B<T, K>`.
`java.lang.String`	`genericAsString(int position)` `class A extends B<Object, C<Long>>`.
`java.lang.String`	`genericAsString(java.lang.String genericName)` `class B<T, K>`.
`java.util.List<java.lang.Class<?>>`	`generics()` `class A extends B<Object, C<Long>>`.
`java.util.List<java.lang.String>`	`genericsAsString()` `class A extends B<Object, C<Long>>`.
`java.util.Map<java.lang.String,java.lang.reflect.Type>`	`genericsMap()` `class A extends B<Object, C<Long>>` and `class B<T, K>`.
`java.lang.reflect.Type`	`genericType(int position)` `class A extends B<Object, C<Long>>`.
`java.lang.reflect.Type`	`genericType(java.lang.String genericName)` `class B<T, K>`.
`java.util.List<java.lang.reflect.Type>`	`genericTypes()` `class A extends B<Object, C<Long>>`.
`GenericsInfo`	`getGenericsInfo()`
`MethodGenericsContext`	`method(java.lang.reflect.Method method)` Navigates current context to specific method (type context is switched(!)
`java.lang.Class<?>`	`resolveClass(java.lang.reflect.Type type)` Useful for introspection to know exact class of type.
`java.lang.Class<?>`	`resolveGenericOf(java.lang.reflect.Type type)` Shortcut for `resolveGenericsOf(java.lang.reflect.Type)` useful for single generic types or when just first generic required.
`java.util.List<java.lang.Class<?>>`	`resolveGenericsOf(java.lang.reflect.Type type)` Useful for introspection, to know exact generic value.
`java.lang.String`	`toStringType(java.lang.reflect.Type type)` Useful for reporting or maybe logging.
`TypeGenericsContext`	`type(java.lang.Class<?> type)` Navigates current context to specific type in class hierarchy.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - genericsInfo
```
protected final GenericsInfo genericsInfo
```
  - currentType
```
protected final java.lang.Class<?> currentType
```
  - typeGenerics
```
protected final java.util.Map<java.lang.String,java.lang.reflect.Type> typeGenerics
```
- Constructor Detail
  - GenericsContext
```
public GenericsContext(GenericsInfo genericsInfo,
                       java.lang.Class<?> type)
```
- Method Detail
  - currentClass
```
public java.lang.Class<?> currentClass()
```
    Returns:
    
    current context class
  - genericTypes
```
public java.util.List<java.lang.reflect.Type> genericTypes()
```
    class A extends B<Object, C<Long>>.
```
 type(B.class).genericTypes() == [Class<Object>, ParametrizedType] 
```
    Returns:
    
    current class generics types
  - generics
```
public java.util.List<java.lang.Class<?>> generics()
```
    class A extends B<Object, C<Long>>.
```
 type(B.class).generics() == [Class<Object>, Class<C>] 
```
    Note that this way you loose second level generics info (Long from C class)
    Returns:
    
    current class generic classes
  - genericsAsString
```
public java.util.List<java.lang.String> genericsAsString()
```
    class A extends B<Object, C<Long>>.
```
 type(B.class).genericsAsString() == ["Object", "C<Long>"] 
```
    Note, that returned generics are completely resolved, e.g. A extends B<Object> , where B<T> extends C<T, List<T>>, and when we call type(C.class).genericsAsString() == ["Object", "List<Object>]
    Returns:
    
    current generics string representation
  - genericType
```
public java.lang.reflect.Type genericType(int position)
```
    class A extends B<Object, C<Long>>.
```
 type(B.class).genericType(1) == ParametrizedType 
```
    Parameters:
    
    position - generic position (from 0)
    
    Returns:
    
    generic type
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - for wrong index
    
    See Also:
    
    for details
  - genericType
```
public java.lang.reflect.Type genericType(java.lang.String genericName)
```
    class B<T, K>.
```
 class A extends B<Object, C<Long>>
 type(B.class).genericType("K") == ParametrizedType 
```
    Parameters:
    
    genericName - generic position (from 0)
    
    Returns:
    
    generic type
    
    Throws:
    
    java.lang.IllegalArgumentException - for wrong generic name
    
    See Also:
    
    for details
  - generic
```
public java.lang.Class<?> generic(int position)
```
    class A extends B<Object, C<Long>>.
```
 type(B.class).generic(1) == C.class 
```
    Parameters:
    
    position - generic position (from 0)
    
    Returns:
    
    resolved generic class
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - for wrong index
    
    See Also:
    
    resolveClass(java.lang.reflect.Type)
  - generic
```
public java.lang.Class<?> generic(java.lang.String genericName)
```
    class B<T, K>.
```
 class A extends B<Object, C<Long>>
 type(B.class).generic("K") == C.class 
```
    Parameters:
    
    genericName - generic name
    
    Returns:
    
    resolved generic class
    
    Throws:
    
    java.lang.IllegalArgumentException - for wrong generic name
    
    See Also:
    
    resolveClass(java.lang.reflect.Type)
  - genericAsString
```
public java.lang.String genericAsString(int position)
```
    class A extends B<Object, C<Long>>.
```
 type(B.class).genericAsString(1) == "C<Long>" 
```
    Parameters:
    
    position - generic position (from 0)
    
    Returns:
    
    resolved generic string representation
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - for wrong index
    
    See Also:
    
    toStringType(java.lang.reflect.Type)
  - genericAsString
```
public java.lang.String genericAsString(java.lang.String genericName)
```
    class B<T, K>.
```
 class A extends B<Object, C<Long>>
 type(B.class).genericAsString("K") == "C<Long>" 
```
    Parameters:
    
    genericName - generic name
    
    Returns:
    
    resolved generic string representation
    
    Throws:
    
    java.lang.IllegalArgumentException - for wrong generic name
    
    See Also:
    
    toStringType(java.lang.reflect.Type)
  - genericsMap
```
public java.util.Map<java.lang.String,java.lang.reflect.Type> genericsMap()
```
    class A extends B<Object, C<Long>> and class B<T, K>.
```
 type(B.class).genericsMap() == ["T": Object.class, "K": ParametrizedType]
```
    Returns:
    
    map of current generics (runtime mapping of generic name to actual type)
  - getGenericsInfo
```
public GenericsInfo getGenericsInfo()
```
    Returns:
    
    generics info object, which contains all information of root class hierarchy generics
  - resolveClass
```
public java.lang.Class<?> resolveClass(java.lang.reflect.Type type)
```
    Useful for introspection to know exact class of type.
```
 class A extends B<Long>;
 class B<T> {
     T doSmth();
 }
```
    Resolving class of return type: type(B.class).resolveClass(B.class.getMethod("doSmth").getGenericReturnType()) == Long.class
    Parameters:
    
    type - type to resolve class
    
    Returns:
    
    resolved type class
  - resolveGenericsOf
```
public java.util.List<java.lang.Class<?>> resolveGenericsOf(java.lang.reflect.Type type)
                                                     throws NoGenericException
```
    Useful for introspection, to know exact generic value.
```
 class A extends B<Long>;
 class B<T> {
     List<T> doSmth();
 }
```
    Resolving parameters in context of root class: type(B.class).resolveGenericsOf(B.class.getMethod("doSmth").getGenericReturnType()) == [Long.class]
    Parameters:
    
    type - type to resolve generics
    
    Returns:
    
    resolved generic class
    
    Throws:
    
    NoGenericException - if provided type does not contain generic (exception required to distinguish Object.class generic value from class which doesn't support generic
  - resolveGenericOf
```
public java.lang.Class<?> resolveGenericOf(java.lang.reflect.Type type)
                                    throws NoGenericException
```
    Shortcut for resolveGenericsOf(java.lang.reflect.Type) useful for single generic types or when just first generic required.
    
    Parameters:
    
    type - type to resolve generic
    
    Returns:
    
    first resolved generic
    
    Throws:
    
    NoGenericException - if provided type does not contain generic (exception required to distinguish Object.class generic value from class which doesn't support generic
  - toStringType
```
public java.lang.String toStringType(java.lang.reflect.Type type)
```
    Useful for reporting or maybe logging. Resolves all generics and compose resulted type as string.
```
 class A extends B<Long>;
 class B<T> {
     List<T> doSmth();
 }
```
    Resolving parameters in type of root class: type(B.class).toStringType(B.class.getMethod("doSmth").getGenericReturnType()) == "List<Long>"
    Parameters:
    
    type - to to get string of
    
    Returns:
    
    string representation for resolved type
  - type
```
public TypeGenericsContext type(java.lang.Class<?> type)
```
    Navigates current context to specific type in class hierarchy.
    
    Parameters:
    
    type - class to navigate to
    
    Returns:
    
    new context instance specific to requested class
    
    Throws:
    
    java.lang.IllegalArgumentException - if requested class is not present in root class hierarchy
  - method
```
public MethodGenericsContext method(java.lang.reflect.Method method)
```
    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.
    
    Parameters:
    
    method - method in current class to navigate to
    
    Returns:
    
    new context instance specific to requested method
    
    Throws:
    
    java.lang.IllegalArgumentException - if requested method is not present in current class hierarchy
  - contextGenerics
```
protected abstract java.util.Map<java.lang.String,java.lang.reflect.Type> contextGenerics()
```
    Returns:
    
    resolved generics mapping for current context

Class GenericsContext

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

genericsInfo

currentType

typeGenerics

Constructor Detail

GenericsContext

Method Detail

currentClass

genericTypes

generics

genericsAsString

genericType

genericType

generic

generic

genericAsString

genericAsString

genericsMap

getGenericsInfo

resolveClass

resolveGenericsOf

resolveGenericOf

toStringType

type

method

contextGenerics