uk.co.strangeskies.reflection

Class TypeResolver

java.lang.Object

uk.co.strangeskies.reflection.TypeResolver

All Implemented Interfaces:

Copyable<TypeResolver>, DeepCopyable<TypeResolver>, Self<TypeResolver>

public class TypeResolver
extends java.lang.Object
implements DeepCopyable<TypeResolver>

A TypeResolver represents a view over an underlying BoundSet, and provides a number of important functionalities for interacting with that BoundSet. Multiple TypeResolvers can provide different views of the same BoundSet instance.

Whenever any InferenceVariable is created by way of a TypeResolver instance, that InferenceVariable will be associated with a particular GenericDeclaration. Within this context, which is so described by a GenericDeclaration, at most only one InferenceVariable may by created for any given TypeVariable. A TypeResolver always creates InferenceVariable according to the behavior of inferTypeParameters(GenericDeclaration).

Constructor Summary

Constructors

Constructor and Description
TypeResolver() Create a new resolver over a new bound set.
TypeResolver(BoundSet bounds) Create a new TypeResolver over the given BoundSet.

Method Summary

Modifier and Type	Method and Description
TypeResolver	copy()
TypeResolver	deepCopy(Isomorphism isomorphism) Create a copy of an existing resolver.
BoundSet	getBounds()
java.lang.reflect.Type	getInstantiation(InferenceVariable variable) Resolve the proper instantiation of a given InferenceVariable if one exists.
TypeResolver	incorporateBounds(BoundSet bounds) Incorporate the given bounds into the bounds of the resolver.
java.lang.reflect.GenericArrayType	inferTypeArguments(java.lang.reflect.GenericArrayType type) Add inference variables for the type parameters of the given type to the resolver, then incorporate containment constraints based on the arguments of the given type.
java.lang.reflect.ParameterizedType	inferTypeArguments(java.lang.reflect.ParameterizedType type) Add inference variables for the type parameters of the given type to the resolver, then incorporate containment constraints based on the arguments of the given type.
java.lang.reflect.ParameterizedType	inferTypeParameters(java.lang.Class<?> declaration)
java.util.stream.Stream<java.util.Map.Entry<java.lang.reflect.TypeVariable<?>,InferenceVariable>>	inferTypeParameters(java.lang.reflect.GenericDeclaration declaration) Each type variable within the given GenericDeclaration, and each non-statically enclosing declaration thereof, is incorporated into the backing BoundSet.
java.util.stream.Stream<java.util.Map.Entry<java.lang.reflect.TypeVariable<?>,InferenceVariable>>	inferTypeParameters(java.lang.reflect.GenericDeclaration declaration, java.util.Map<java.lang.reflect.TypeVariable<?>,? extends java.lang.reflect.Type> existingCaptures)
java.util.stream.Stream<java.util.Map.Entry<java.lang.reflect.TypeVariable<?>,InferenceVariable>>	inferTypeParameters(java.lang.reflect.GenericDeclaration declaration, java.lang.reflect.ParameterizedType enclosing) Each type variable within the given GenericDeclaration, and each non-statically enclosing declaration thereof, is incorporated into the backing BoundSet.
InferenceVariable	inferWildcardType(java.lang.reflect.WildcardType type) Incorporate a new inference variable for a given wildcard type, and add the bounds of the wildcard as bounds to the inference variable.
TypeResolver	reduceConstraint(ConstraintFormula constraintFormula) Reduce the given constraint formula into the bound set of the resolver.
java.util.stream.Stream<java.util.Map.Entry<InferenceVariable,java.lang.reflect.Type>>	resolve() Infer proper instantiations for each inference variable registered within this TypeResolver instance.
java.util.stream.Stream<java.util.Map.Entry<InferenceVariable,java.lang.reflect.Type>>	resolve(java.util.Collection<? extends InferenceVariable> variables) Infer proper instantiations for the given InferenceVariables.
java.util.stream.Stream<java.util.Map.Entry<InferenceVariable,java.lang.reflect.Type>>	resolve(InferenceVariable... variables) Infer proper instantiations for the given InferenceVariables.
java.lang.reflect.Type	resolve(InferenceVariable inferenceVariable) Infer a proper instantiations for a single given InferenceVariable.
java.lang.reflect.Type	resolve(java.lang.reflect.Type type) Infer a proper instantiations for each InferenceVariable mentioned by the given type.
java.lang.reflect.Type	substituteInstantiations(java.lang.reflect.Type type) Derive a new type from the type given, with any mentioned instances of InferenceVariable substituted with their proper instantiations where available, as per getInstantiation(InferenceVariable).

Methods inherited from class java.lang.Object

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

Methods inherited from interface uk.co.strangeskies.utility.DeepCopyable

deepCopy

Methods inherited from interface uk.co.strangeskies.utility.Self

getThis

Constructor Detail

TypeResolver

public TypeResolver(BoundSet bounds)

Create a new TypeResolver over the given BoundSet.

Parameters:

bounds - The exact bound set we wish to create a resolver over. Operations on the new resolver may mutate the given bound set.

TypeResolver

public TypeResolver()

Create a new resolver over a new bound set.

Method Detail

copy

public TypeResolver copy()

Specified by:

copy in interface Copyable<TypeResolver>

Returns:

a copy of the receiving instance

deepCopy

public TypeResolver deepCopy(Isomorphism isomorphism)

Create a copy of an existing resolver. All the inference variables contained within the resolver will be substituted for the new inference variables, and all the bounds on them will be substituted for equivalent bounds. These mappings will be entered into the given map when they are made.

Specified by:

deepCopy in interface Copyable<TypeResolver>

Specified by:

deepCopy in interface DeepCopyable<TypeResolver>

Parameters:

isomorphism - an isomorphism for inference variables

Returns:

A newly derived resolver, with each instance of an inference variable substituted for new mappings.

getBounds

public BoundSet getBounds()

Returns:

The bound set backing this resolver.

inferTypeParameters

public java.util.stream.Stream<java.util.Map.Entry<java.lang.reflect.TypeVariable<?>,InferenceVariable>> inferTypeParameters(java.lang.reflect.GenericDeclaration declaration,
                                                                                                                             java.util.Map<java.lang.reflect.TypeVariable<?>,? extends java.lang.reflect.Type> existingCaptures)

inferTypeParameters

public java.util.stream.Stream<java.util.Map.Entry<java.lang.reflect.TypeVariable<?>,InferenceVariable>> inferTypeParameters(java.lang.reflect.GenericDeclaration declaration,
                                                                                                                             java.lang.reflect.ParameterizedType enclosing)

Each type variable within the given GenericDeclaration, and each non-statically enclosing declaration thereof, is incorporated into the backing BoundSet.

Parameters:

declaration - the declaration we wish to incorporate

enclosing - the parameterized enclosing declaration

Returns:

mapping from the InferenceVariables on the given declaration, to their new capturing InferenceVariables

inferTypeParameters

public java.util.stream.Stream<java.util.Map.Entry<java.lang.reflect.TypeVariable<?>,InferenceVariable>> inferTypeParameters(java.lang.reflect.GenericDeclaration declaration)

Each type variable within the given GenericDeclaration, and each non-statically enclosing declaration thereof, is incorporated into the backing BoundSet.

Parameters:

declaration - the declaration we wish to incorporate

Returns:

a mapping from the InferenceVariables on the given declaration, to their new capturing InferenceVariables

inferTypeArguments

public java.lang.reflect.GenericArrayType inferTypeArguments(java.lang.reflect.GenericArrayType type)

Add inference variables for the type parameters of the given type to the resolver, then incorporate containment constraints based on the arguments of the given type.

Parameters:

type - The type whose generic type arguments we wish to perform inference operations over.

Returns:

A parameterized type derived from the given type, with inference variables in place of wildcards where appropriate.

inferTypeArguments

public java.lang.reflect.ParameterizedType inferTypeArguments(java.lang.reflect.ParameterizedType type)

Add inference variables for the type parameters of the given type to the resolver, then incorporate containment constraints based on the arguments of the given type.

Parameters:

type - The type whose generic type arguments we wish to perform inference operations over.

Returns:

A parameterized type derived from the given type, with inference variables in place of wildcards where appropriate.

inferTypeParameters

public java.lang.reflect.ParameterizedType inferTypeParameters(java.lang.Class<?> declaration)

inferWildcardType

public InferenceVariable inferWildcardType(java.lang.reflect.WildcardType type)

Incorporate a new inference variable for a given wildcard type, and add the bounds of the wildcard as bounds to the inference variable.

Parameters:

type - The wildcard type to capture as a bounded inference variable.

Returns:

The new inference variable created to satisfy the given wildcard.

resolve

public java.util.stream.Stream<java.util.Map.Entry<InferenceVariable,java.lang.reflect.Type>> resolve()

Infer proper instantiations for each inference variable registered within this TypeResolver instance.

Returns:

A mapping from each inference variable registered under this resolver, to their newly inferred instantiations.

resolve

public java.lang.reflect.Type resolve(java.lang.reflect.Type type)

Infer a proper instantiations for each InferenceVariable mentioned by the given type.

Parameters:

type - the type whose proper form we wish to infer

Returns:

a new type derived from the given type by substitution of instantiations for each InferenceVariable mentioned

resolve

public java.lang.reflect.Type resolve(InferenceVariable inferenceVariable)

Infer a proper instantiations for a single given InferenceVariable.

Parameters:

inferenceVariable - the type whose proper form we wish to infer

Returns:

a new instantiation for the given InferenceVariable

resolve

public java.util.stream.Stream<java.util.Map.Entry<InferenceVariable,java.lang.reflect.Type>> resolve(InferenceVariable... variables)

Infer proper instantiations for the given InferenceVariables.

Parameters:

variables - the inference variables for which we wish to infer instantiations

Returns:

a mapping from each of the given inference variables to their inferred instantiations

resolve

public java.util.stream.Stream<java.util.Map.Entry<InferenceVariable,java.lang.reflect.Type>> resolve(java.util.Collection<? extends InferenceVariable> variables)

Infer proper instantiations for the given InferenceVariables.

Parameters:

variables - The inference variables for which we wish to infer instantiations.

Returns:

A mapping from each of the given inference variables to their inferred instantiations.

substituteInstantiations

public java.lang.reflect.Type substituteInstantiations(java.lang.reflect.Type type)

Derive a new type from the type given, with any mentioned instances of InferenceVariable substituted with their proper instantiations where available, as per getInstantiation(InferenceVariable).

Parameters:

type - The type we wish to resolve.

Returns:

The resolved type.

getInstantiation

public java.lang.reflect.Type getInstantiation(InferenceVariable variable)

Resolve the proper instantiation of a given InferenceVariable if one exists.

Parameters:

variable - The inference variable whose proper instantiation we wish to determine.

Returns:

The proper instantiation of the given InferenceVariable if one exists, otherwise the InferenceVariable itself.

incorporateBounds

public TypeResolver incorporateBounds(BoundSet bounds)

Incorporate the given bounds into the bounds of the resolver.

Parameters:

bounds - the bounds to incorporate

Returns:

this resolver

reduceConstraint

public TypeResolver reduceConstraint(ConstraintFormula constraintFormula)

Reduce the given constraint formula into the bound set of the resolver.

Parameters:

constraintFormula - the constraint formula to reduce

Returns:

this resolver