ru.vyarus.java.generics.resolver.context

Class MethodGenericsContext

java.lang.Object

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

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

ru.vyarus.java.generics.resolver.context.MethodGenericsContext

public class MethodGenericsContext
extends GenericsContext

Method generics context. Additional context is required because method could contain it's own generics, for example:

 class A {
     <T> T method();
 }

Such generics are not known in type and, as a result, any operation on type with such generic will lead to unknown generic exception.

Also, context contains special methods for parameters and return type analysis.

Since:

26.06.2015

Nested Class Summary

Nested classes/interfaces inherited from class ru.vyarus.java.generics.resolver.context.GenericsContext

GenericsContext.RootContextAwareTypeWriter

Field Summary

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

allTypeGenerics, CURRENT_POSITION_MARKER, ownerGenerics, ownerType

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

currentType, genericsInfo, typeGenerics

Constructor Summary

Constructors

Constructor and Description
MethodGenericsContext(GenericsInfo genericsInfo, java.lang.reflect.Method method, GenericsContext root)

Method Summary

Modifier and Type	Method and Description
protected java.util.Map<java.lang.String,java.lang.reflect.Type>	contextGenerics()
java.lang.reflect.Method	currentMethod()
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.
MethodGenericsContext	method(java.lang.reflect.Method method) Navigates current context to specific method (type context is switched to method declaring class).
java.util.Map<java.lang.String,java.lang.reflect.Type>	methodGenericsMap() class A<E> { <T, K extends E> K method(T arg); } class B extends A<Serializable> {} context.method(A.class.getMethod("method", Object.class)).methodGenericsMap() == ["T": Object.class, "K": Serializable.class] For method generics it's impossible to know actual type (available only in time of method call), so generics resolved as upper bound.
java.util.List<java.lang.reflect.Type>	methodGenericTypes() <T extends Serializable> T method();.
GenericsContext	parameterType(int pos) Create generics context for parameter type (with correctly resolved root generics).
GenericsContext	parameterTypeAs(int pos, java.lang.Class<?> asType) Create generics context for actual class, passed into parameter type (assuming you have access to that instance or know exact type).
java.util.List<java.lang.Class<?>>	resolveParameters() Useful for introspection, to know exact parameter types.
java.util.List<java.lang.reflect.Type>	resolveParametersTypes() Returns parameter types with resolved generic variables.
java.lang.reflect.Type	resolveParameterType(int pos)
java.lang.Class<?>	resolveReturnClass() Useful for introspection, to know exact return type of generified method.
java.lang.reflect.Type	resolveReturnType() class B extends A<Long> {} class A<T> { List<T> get(); }.
java.lang.Class<?>	resolveReturnTypeGeneric() Shortcut for resolveReturnTypeGenerics() useful for single generic types or when just first generic required.
java.util.List<java.lang.Class<?>>	resolveReturnTypeGenerics() Useful for introspection, to know exact generic value.
GenericsContext	returnType() Create generics context for return type (with correctly resolved root generics).
GenericsContext	returnTypeAs(java.lang.Class<?> asType) Create generics context for actual class, returned form method (assuming you have access to that instance or know exact type).
java.lang.String	toString()
java.lang.String	toStringMethod()

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

chooseContext, constructor, inlyingType, inlyingTypeAs, isInlying, ownerClass, ownerGenericsMap, rootContext, switchContext, type

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

Constructor Detail

MethodGenericsContext

public MethodGenericsContext(GenericsInfo genericsInfo,
                             java.lang.reflect.Method method,
                             GenericsContext root)

Method Detail

currentMethod

public java.lang.reflect.Method currentMethod()

Returns:

current context method

methodGenericTypes

public java.util.List<java.lang.reflect.Type> methodGenericTypes()

<T extends Serializable> T method();.

 context.method(A.getMethod('method')).methodGenericTypes() == [Class<Serializable>]

Returns:

current method generics types

methodGenericsMap

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

 class A<E> {
     <T, K extends E> K method(T arg);
 }
 class B extends A<Serializable> {}
 

 context.method(A.class.getMethod("method", Object.class)).methodGenericsMap() ==
          ["T": Object.class, "K": Serializable.class]

For method generics it's impossible to know actual type (available only in time of method call), so generics resolved as upper bound.

Returns:

map of current method generics (runtime mapping of generic name to actual type)

resolveReturnClass

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

Useful for introspection, to know exact return type of generified method.

 class A extends B<Long>;
 class B<T> {
     T doSmth();
 }

Resolving return type in type of root class: type(B.class).resolveReturnClass(B.class.getMethod("doSmth")) == Long.class

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

Returns:

resolved return class of method (generic resolved or, in case of simple class, returned as is)

See Also:

AbstractGenericsContext.resolveClass(java.lang.reflect.Type)

resolveParameters

public java.util.List<java.lang.Class<?>> resolveParameters()

Useful for introspection, to know exact parameter types.

 class A extends B<Long> {}
 class B<T> {
     void doSmth(T a, Integer b);
 }

Resolving parameters in context of root class: method(B.class.getMethod("doSmth", Object.class, Integer.class)).resolveParameters() == [Long.class, Integer.class]

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

Returns:

resolved method parameters or empty list if method doesn't contain parameters

See Also:

resolveParametersTypes()

resolveParametersTypes

public java.util.List<java.lang.reflect.Type> resolveParametersTypes()

Returns parameter types with resolved generic variables.

 class A extends B<Long> {}
 class B<T>{
     void doSmth(List<T> a);
 }

Resolving parameters types in context of root class: method(B.class.getMethod("doSmth", List.class)).resolveParametersTypes() == [List<Long>]

Returns:

resolved method parameters types or empty list if method doesn't contain parameters

See Also:

resolveParameters()

resolveParameterType

public java.lang.reflect.Type resolveParameterType(int pos)

Parameters:

pos - parameter position (form 0)

Returns:

parameter type with resolved generic variables

Throws:

java.lang.IllegalArgumentException - if parameter index is incorrect

parameterType

public GenericsContext parameterType(int pos)

Create generics context for parameter type (with correctly resolved root generics). "Drill down".

 class A<T> {
    void doSmth(B<T>);
 }
 class C extends A<String> {}

Build generics context for parameter type (to continue analyzing parameter type fields): (context of C).method(A.class.getMethod("getSmth", B.class)).parameterType(0) == generics context of B<String>

Note that, in contrast to direct resolution GenericsResolver.resolve(B.class), actual root generic would be counted for hierarchy resolution.

Parameters:

pos - parameter position (from 0)

Returns:

generics context of parameter type

Throws:

java.lang.IllegalArgumentException - if parameter index is incorrect

See Also:

GenericsContext.inlyingType(Type)

parameterTypeAs

public GenericsContext parameterTypeAs(int pos,
                                       java.lang.Class<?> asType)

Create generics context for actual class, passed into parameter type (assuming you have access to that instance or know exact type). Context will contain correct generics for known declaration type (middle type in target type hierarchy). This is useful when analyzing object instance (introspecting actual object).

Other than target type, method is the same as parameterType(int).

Parameters:

pos - parameter position (from 0)

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

Returns:

generics context of requested type with known parameter generics

Throws:

java.lang.IllegalArgumentException - if parameter index is incorrect

See Also:

GenericsContext.inlyingTypeAs(Type, Class)

resolveReturnTypeGenerics

public java.util.List<java.lang.Class<?>> resolveReturnTypeGenerics()

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).method(B.class.getMethod("doSmth")).resolveReturnTypeGenerics() == [Long.class]

Returns:

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

resolveReturnTypeGeneric

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

Shortcut for resolveReturnTypeGenerics() useful for single generic types or when just first generic required.

Returns:

first resolved generic or null if type doesn't use generics

resolveReturnType

public java.lang.reflect.Type resolveReturnType()

 class B extends A<Long> {}
 class A<T> {
      List<T> get();
 }

. (context of B).method(A.class.getMethod("get")).resolveReturnType() == List<Long>

Returns:

method return type with resolved generic variables

returnType

public GenericsContext returnType()

Create generics context for return type (with correctly resolved root generics). "Drill down".

 class A<T> {
    B<T> doSmth();
 }
 class C extends A<String> {}

Build generics context for returning type (to continue analyzing return type fields): type(A.class).method(A.class.getMethod("getSmth")).returnType() == generics context of B<String>

Note that, in contrast to direct resolution GenericsResolver.resolve(B.class), actual root generic would be counted for hierarchy resolution.

Returns:

generics context of return type

See Also:

GenericsContext.inlyingType(Type)

returnTypeAs

public GenericsContext returnTypeAs(java.lang.Class<?> asType)

Create generics context for actual class, returned form method (assuming you have access to that instance or know exact type). Context will contain correct generics for known declaration type (middle type in target type hierarchy). This is useful when analyzing object instance (introspecting actual object).

Other than target type, method is the same as returnType().

Parameters:

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

Returns:

generics context of requested type with known return type generics

See Also:

GenericsContext.inlyingTypeAs(Type, Class)

toStringMethod

public java.lang.String toStringMethod()

Returns:

method declaration string with actual types instead of generic variables

toString

public java.lang.String toString()

Overrides:

toString in class GenericsContext

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

Overrides:

getGenericsScope in class GenericsContext

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.

Overrides:

getGenericsSource in class GenericsContext

Returns:

declaration source for current context

See Also:

AbstractGenericsContext.getGenericsScope()

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.

Overrides:

method in class GenericsContext

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

contextGenerics

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

Overrides:

contextGenerics in class GenericsContext

Returns:

resolved generics mapping for current context