ru.vyarus.java.generics.resolver.context

Class ConstructorGenericsContext

java.lang.Object

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

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

ru.vyarus.java.generics.resolver.context.ConstructorGenericsContext

public class ConstructorGenericsContext
extends GenericsContext

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

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

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

Since:

29.05.2018

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
ConstructorGenericsContext(GenericsInfo genericsInfo, java.lang.reflect.Constructor constructor, GenericsContext root)

Method Summary

Modifier and Type	Method and Description
ConstructorGenericsContext	constructor(java.lang.reflect.Constructor constructor) Navigates current context to specific constructor (type context is switched to constructor declaring class).
java.util.Map<java.lang.String,java.lang.reflect.Type>	constructorGenericsMap() class A<E>{ <T, K extends E> A(T arg1, K arg2); } class B extends A<Serializable> {} context.constructor(A.class.getConstructor(Object.class, Object.class)).constructorGenericsMap() == ["T": Object.class, "K": Serializable.class] For constructor generics it's impossible to know actual type (available only in time of constructor call), so generics resolved as upper bound.
java.util.List<java.lang.reflect.Type>	constructorGenericTypes() <T extends Serializable> Some(T arg);.
protected java.util.Map<java.lang.String,java.lang.reflect.Type>	contextGenerics()
java.lang.reflect.Constructor	currentConstructor()
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	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.String	toString()
java.lang.String	toStringConstructor()

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

chooseContext, inlyingType, inlyingTypeAs, isInlying, method, 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

ConstructorGenericsContext

public ConstructorGenericsContext(GenericsInfo genericsInfo,
                                  java.lang.reflect.Constructor constructor,
                                  GenericsContext root)

Method Detail

currentConstructor

public java.lang.reflect.Constructor currentConstructor()

Returns:

current context constructor

constructorGenericTypes

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

<T extends Serializable> Some(T arg);.

 context.constructor(Some.class.getConstructor(Object.class)).constructorGenericTypes() ==
 [Class<Serializable>]

Returns:

current constructor generics types

constructorGenericsMap

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

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

 context.constructor(A.class.getConstructor(Object.class, Object.class)).constructorGenericsMap() ==
      ["T": Object.class, "K": Serializable.class]

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

Returns:

map of current constructor generics (runtime mapping of generic name to actual 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> {
     B(T a, Integer b);
 }

Resolving parameters in context of root class: constructor(B.class.getConstructor(Object.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 primitive, if required.

Returns:

resolved constructor parameters or empty list if constructor 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>{
     B(List<T> arg);
 }

Resolving parameters types in context of root class: constructor(B.class.getConstructor(List.class)).resolveParametersTypes() == [List<Long>]

Returns:

resolved constructor parameters types or empty list if constructor 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> {
    A(B<T> arg);
 }
 class C extends A<String> {}

Build generics context for parameter type (to continue analyzing parameter type fields): (context of C).constructor(A.class.getConstructor(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)

toStringConstructor

public java.lang.String toStringConstructor()

Returns:

constructor 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()

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.

Overrides:

constructor in class GenericsContext

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

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