uk.co.strangeskies.reflection.token

Class TypeToken<T>

java.lang.Object

uk.co.strangeskies.reflection.token.TypeToken<T>

Type Parameters:

T - This is the type which the TypeToken object references.

All Implemented Interfaces:

Reified, DeclarationToken<TypeToken<T>>, ReifiedType<TypeToken<T>>, Copyable<TypeToken<T>>, DeepCopyable<TypeToken<T>>, Self<TypeToken<T>>

Direct Known Subclasses:

TypeParameter

public class TypeToken<T>
extends java.lang.Object
implements DeepCopyable<TypeToken<T>>, ReifiedType<TypeToken<T>>, DeclarationToken<TypeToken<T>>

TypeToken provides reflective operations and services over the Java type system. It is analogous to Class<?>, but provides access to a much richer set of tools, and can be used over the domain of all types, not just raw types.

TypeToken is effectively immutable, though may perform shared caching of results transparently to the user. Like Class, A TypeToken will always be parameterized with the type it reflects over when used as intended.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	TypeToken.Capture Specifies behavior of wildcards.
static interface	TypeToken.Infer Specifies behavior of wildcards.
static interface	TypeToken.Retain Specifies behavior of wildcards.
static class	TypeToken.Wildcards Treatment of wildcards for TypeTokens created over parameterized types.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	TypeToken()
protected	TypeToken(BoundSet bounds, java.lang.reflect.Type type)
protected	TypeToken(java.lang.reflect.Type type)

Method Summary

Modifier and Type	Method and Description
T	cast(java.lang.Object object)
java.util.stream.Stream<ExecutableToken<java.lang.Void,T>>	constructors() Find which constructors can be invoked for this type.
TypeToken<T>	copy()
java.util.stream.Stream<ExecutableToken<java.lang.Void,T>>	declaredConstructors() Find which constructors can be invoked for this type.
java.util.stream.Stream<FieldToken<T,?>>	declaredFields() Find which fields are declared on this type.
java.util.stream.Stream<ExecutableToken<T,?>>	declaredMethods() Find which methods can be invoked on this type, whether statically or on instances.
TypeToken<T>	deepCopy(Isomorphism isomorphism)
boolean	equals(java.lang.Object obj)
java.util.stream.Stream<FieldToken<T,?>>	fields() Find which fields can be resolved on this type.
static TypeToken<?>	forAnnotatedType(java.lang.reflect.AnnotatedType type) Create a TypeToken for an arbitrary type, preserving wildcards where possible.
static <T> TypeToken<T>	forClass(java.lang.Class<T> type) Create a TypeToken for a raw class.
static TypeToken<?>	forNull() Create a TypeToken over the null type.
static TypeToken<?>	forType(BoundSet bounds, java.lang.reflect.Type type, TypeToken.Wildcards wildcards) Create a TypeToken for an arbitrary type, preserving wildcards where possible.
static TypeToken<?>	forType(java.lang.reflect.Type type) Create a TypeToken for an arbitrary type, preserving wildcards where possible.
static TypeToken<?>	forType(java.lang.reflect.Type type, TypeToken.Wildcards wildcards) Create a TypeToken for an arbitrary type.
static TypeToken<?>	fromString(java.lang.String typeString) Equivalent to the application of forType(Type) to the result of Types.fromString(String).
static TypeToken<?>	fromString(java.lang.String typeString, Imports imports) Equivalent to the application of forType(Type) to the result of AnnotatedTypes.fromString(String, Imports), with the given imports.
java.lang.reflect.AnnotatedType	getAnnotatedDeclaration()
BoundSet	getBounds() This method returns a copy of the Resolver backing by this TypeToken.
java.lang.Class<? super T>	getErasedType() See Types.getErasedType(Type).
TypeToken<? super T>	getErasedTypeToken() See Types.getErasedType(Type).
java.util.stream.Stream<java.lang.Class<?>>	getErasedUpperBounds() Determine the raw types of a given type, accounting for inference variables which may have instantiations or upper bounds within the context of this resolver.
TypeToken<? extends T>	getExtending(TypeToken.Wildcards wildcards) Create a TypeToken over a wildcard type which has the type represented by this TypeToken as an upper bound.
java.util.stream.Stream<InferenceVariable>	getInferenceVariablesMentioned() Determine which inference variables are mentioned by the type of this TypeToken.
java.util.Optional<DeclarationToken<?>>	getOwningDeclaration()
java.util.stream.Stream<InferenceVariable>	getRemainingInferenceVariableDependencies() Determine which inference variables are dependencies of those mentioned by the type of this TypeToken.
TypeToken<? super T>	getSuper(TypeToken.Wildcards wildcards) Create a TypeToken over a wildcard type which has the type represented by this TypeToken as a lower bound.
TypeToken<T>	getThis()
TypeToken<TypeToken<T>>	getThisTypeToken()
java.lang.reflect.Type	getType() The type represented by this TypeToken.
java.util.stream.Stream<TypeArgument<?>>	getTypeArguments()
int	getTypeParameterCount()
java.util.stream.Stream<TypeParameter<?>>	getTypeParameters()
java.util.stream.Stream<java.lang.reflect.Type>	getUpperBounds() Find the upper bounding classes and parameterized types of a given type.
TypeToken<? extends T>	getWildcardExtending() Create a TypeToken over a wildcard type which has the type represented by this TypeToken as an upper bound.
TypeToken<? super T>	getWildcardSuper() Create a TypeToken over a wildcard type which has the type represented by this TypeToken as a lower bound.
int	hashCode()
TypeToken<? extends T>	infer() If the type is raw it is parameterized with inference variables.
boolean	isCastableFrom(java.lang.reflect.Type type)
boolean	isCastableFrom(TypeToken<?> type)
boolean	isCastableTo(java.lang.reflect.Type type)
boolean	isCastableTo(TypeToken<?> type)
boolean	isGeneric()
boolean	isPrimitive() Is the type a primitive type as per the Java type system.
boolean	isPrimitiveWrapper() Is the type a wrapper for a primitive type as per the Java type system.
boolean	isProper() Determine whether this TypeToken represents a proper type.
boolean	isRaw()
java.util.stream.Stream<ExecutableToken<T,?>>	methods() Find which methods of the given name can be invoked on instances of this type.
TypeToken<? extends T>	parameterize() If the declaration is raw, parameterize it with its own type parameters, otherwise return the declaration itself.
TypeToken<T>	resolve() This method will attempt to infer the actual type represented by this TypeToken, which means the types of any inference variables mentioned will be inferred and substituted.
TypeToken<? super T>	resolveSupertype(java.lang.Class<?> superclass) As @see TypeHierarchy.resolveSupertype( Class).
boolean	satisfiesConstraintFrom(ConstraintFormula.Kind kind, java.lang.reflect.Type type) Derive a new type from this one, with a constraint between this type and a given type.
boolean	satisfiesConstraintFrom(ConstraintFormula.Kind kind, TypeToken<?> type) Derive a new type from this one, with a constraint between this type and a given type.
boolean	satisfiesConstraintTo(ConstraintFormula.Kind kind, java.lang.reflect.Type type) Derive a new type from this one, with a constraint between this type and a given type.
boolean	satisfiesConstraintTo(ConstraintFormula.Kind kind, TypeToken<?> type) Derive a new type from this one, with a constraint between this type and a given type.
TypeToken<T>	substituteInstantiations() This method will attempt to substitute any inference variables mentioned by this type with their instantiations, if instantiations are available, and return a TypeToken over the resulting type.
java.lang.String	toString()
java.lang.String	toString(Imports imports) Equivalent to the application of AnnotatedTypes.toString(AnnotatedType, Imports) to getAnnotatedDeclaration(), with the given imports.
TypeToken<T>	unwrapPrimitive() If this TypeToken is a wrapper of a primitive type, determine the unwrapped primitive type.
TypeToken<T>	withAllTypeArguments(java.util.List<java.lang.reflect.Type> typeArguments) Derive a new DeclarationToken instance with the given type argument parameterization.
TypeToken<T>	withAllTypeArguments(java.lang.reflect.Type... typeArguments)
TypeToken<T>	withBounds(BoundSet bounds) Derive a new TypeToken instance, with the given bounds incorporated into the bounds of the underlying resolver.
TypeToken<T>	withConstraintFrom(ConstraintFormula.Kind kind, java.lang.reflect.Type type) Derive a new type from this one, with a constraint between this type and a given type.
TypeToken<T>	withConstraintFrom(ConstraintFormula.Kind kind, TypeToken<?> type) Derive a new type from this one, with a constraint between this type and a given type.
TypeToken<T>	withConstraintTo(ConstraintFormula.Kind kind, java.lang.reflect.Type type) Derive a new type from this one, with a constraint between this type and a given type.
TypeToken<T>	withConstraintTo(ConstraintFormula.Kind kind, TypeToken<?> type) Derive a new type from this one, with a constraint between this type and a given type.
TypeToken<T>	withTypeArguments(java.util.Collection<? extends TypeArgument<?>> arguments) Derive a new ExecutableToken instance from this, with types substituted according to the given arguments.
TypeToken<T>	withTypeArguments(java.util.List<java.lang.reflect.Type> typeArguments) As @see DeclarationToken.withAllTypeArguments(List), but only providing arguments for the parameters occurring directly on the declaration.
TypeToken<T>	withTypeArguments(java.lang.reflect.Type... typeArguments)
TypeToken<T>	wrapPrimitive() If this TypeToken is a primitive type, determine the wrapped primitive type.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

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

deepCopy

Methods inherited from interface uk.co.strangeskies.reflection.token.ReifiedType

asTypedObject, getThisType

Methods inherited from interface uk.co.strangeskies.reflection.token.DeclarationToken

getAllTypeArguments, getAllTypeParameterCount, getAllTypeParameters, resolveTypeArgument, resolveTypeArgument, withTypeArguments

Constructor Detail

TypeToken

protected TypeToken()

TypeToken

protected TypeToken(java.lang.reflect.Type type)

TypeToken

protected TypeToken(BoundSet bounds,
                    java.lang.reflect.Type type)

Method Detail

forClass

public static <T> TypeToken<T> forClass(java.lang.Class<T> type)

Create a TypeToken for a raw class.

Type Parameters:

T - the type of the new TypeToken

Parameters:

type - the class to create a TypeToken for

Returns:

a TypeToken over the requested class

forType

public static TypeToken<?> forType(java.lang.reflect.Type type)

Create a TypeToken for an arbitrary type, preserving wildcards where possible.

Parameters:

type - the requested type

Returns:

a TypeToken over the requested type

forType

public static TypeToken<?> forType(BoundSet bounds,
                                   java.lang.reflect.Type type,
                                   TypeToken.Wildcards wildcards)

Create a TypeToken for an arbitrary type, preserving wildcards where possible.

Parameters:

bounds - the set of bounds on any inference variables mentioned in the type

type - the requested type

wildcards - how to deal with wildcard parameters on the given type

Returns:

a TypeToken over the requested type

forAnnotatedType

public static TypeToken<?> forAnnotatedType(java.lang.reflect.AnnotatedType type)

Create a TypeToken for an arbitrary type, preserving wildcards where possible.

Parameters:

type - the requested type

Returns:

a TypeToken over the requested type

forType

public static TypeToken<?> forType(java.lang.reflect.Type type,
                                   TypeToken.Wildcards wildcards)

Create a TypeToken for an arbitrary type.

Parameters:

type - the requested type

wildcards - how to deal with wildcard parameters on the given type

Returns:

a TypeToken over the requested type

forNull

public static TypeToken<?> forNull()

Create a TypeToken over the null type.

Returns:

a TypeToken over the null type

equals

public boolean equals(java.lang.Object obj)

Overrides:

equals in class java.lang.Object

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

getThis

public TypeToken<T> getThis()

Specified by:

getThis in interface Self<TypeToken<T>>

Returns:

A reference to the receiver, cast to it's type as denoted by the parameterization of Self.

getThisTypeToken

public TypeToken<TypeToken<T>> getThisTypeToken()

Specified by:

getThisTypeToken in interface ReifiedType<TypeToken<T>>

Returns:

a TypeToken over the value of ReifiedType.getThisType()

copy

public TypeToken<T> copy()

Specified by:

copy in interface Copyable<TypeToken<T>>

Returns:

a copy of the receiving instance

deepCopy

public TypeToken<T> deepCopy(Isomorphism isomorphism)

Specified by:

deepCopy in interface Copyable<TypeToken<T>>

Specified by:

deepCopy in interface DeepCopyable<TypeToken<T>>

Parameters:

isomorphism - an object graph Isomorphism

Returns:

a deep copy of the receiving instance, consistent with the given Isomorphism

withBounds

public TypeToken<T> withBounds(BoundSet bounds)

Derive a new TypeToken instance, with the given bounds incorporated into the bounds of the underlying resolver. The original TypeToken will remain unmodified.

All bounds are incorporated if and only if they have the potential to affect the resolution of inference variables mentioned by this type.

Parameters:

bounds - the new bounds to incorporate

Returns:

the newly derived TypeToken

fromString

public static TypeToken<?> fromString(java.lang.String typeString)

Equivalent to the application of forType(Type) to the result of Types.fromString(String).

Parameters:

typeString - the String to parse

Returns:

a TypeToken representing the type described by the String

fromString

public static TypeToken<?> fromString(java.lang.String typeString,
                                      Imports imports)

Equivalent to the application of forType(Type) to the result of AnnotatedTypes.fromString(String, Imports), with the given imports.

Parameters:

typeString - the String to parse

imports - classes and packages for which full package qualification may be omitted from input

Returns:

a TypeToken representing the type described by the string

toString

public java.lang.String toString(Imports imports)

Equivalent to the application of AnnotatedTypes.toString(AnnotatedType, Imports) to getAnnotatedDeclaration(), with the given imports.

Parameters:

imports - classes and packages for which full package qualification may be omitted from output

Returns:

a string representing the type described by this type token

getWildcardExtending

public TypeToken<? extends T> getWildcardExtending()

Create a TypeToken over a wildcard type which has the type represented by this TypeToken as an upper bound. For example, invoking this method on a TypeToken<List<?>> will give a TypeToken<? extends List<?>>.

Returns:

the TypeToken representing a capture of the wildcard described

getExtending

public TypeToken<? extends T> getExtending(TypeToken.Wildcards wildcards)

Create a TypeToken over a wildcard type which has the type represented by this TypeToken as an upper bound. The wildcard will be represented according to the TypeToken.Wildcards argument given. Either the wildcard will be preserved, a fresh TypeVariableCapture of the wildcard type will be captured, or an InferenceVariable will be substituted. For example, invoking this method on a TypeToken<List<?>> will give a TypeToken<? extends List<?>>.

Parameters:

wildcards - how to deal with the wildcard parameter on the new type

Returns:

the TypeToken representing a capture of the wildcard described

getWildcardSuper

public TypeToken<? super T> getWildcardSuper()

Create a TypeToken over a wildcard type which has the type represented by this TypeToken as a lower bound. For example, invoking this method on a TypeToken<List<?>> will give a TypeToken<? super List<?>>.

Returns:

the TypeToken representing a capture of the wildcard described

getSuper

public TypeToken<? super T> getSuper(TypeToken.Wildcards wildcards)

Create a TypeToken over a wildcard type which has the type represented by this TypeToken as a lower bound. The wildcard will be represented according to the TypeToken.Wildcards argument given. Either the wildcard will be preserved, a fresh TypeVariableCapture of the wildcard type will be captured, or an InferenceVariable will be substituted. For example, invoking this method on a TypeToken<List<?>> will give a TypeToken<? super List<?>>.

Parameters:

wildcards - how to deal with the wildcard parameter on the new type

Returns:

the TypeToken representing a capture of the wildcard described

getErasedType

public java.lang.Class<? super T> getErasedType()

See Types.getErasedType(Type).

Returns:

the raw type of the type represented by this TypeToken

getErasedTypeToken

public TypeToken<? super T> getErasedTypeToken()

See Types.getErasedType(Type).

Returns:

the raw type of the type represented by this TypeToken

getUpperBounds

public java.util.stream.Stream<java.lang.reflect.Type> getUpperBounds()

Find the upper bounding classes and parameterized types of a given type. Unlike Types.getUpperBounds(Type) this respects bounds on the inference variables in this resolver.

Returns:

the upper bounds of the type represented by this TypeToken

getErasedUpperBounds

public java.util.stream.Stream<java.lang.Class<?>> getErasedUpperBounds()

Determine the raw types of a given type, accounting for inference variables which may have instantiations or upper bounds within the context of this resolver.

Returns:

the raw types of the type represented by this TypeToken

getBounds

public BoundSet getBounds()

This method returns a copy of the Resolver backing by this TypeToken.

Returns:

A new Resolver object containing whichever bounds have been internally derived from the type of this TypeToken.

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

getType

public java.lang.reflect.Type getType()

The type represented by this TypeToken.

Returns:

The actual Type object described.

isPrimitive

public boolean isPrimitive()

Is the type a primitive type as per the Java type system.

Returns:

True if the type is primitive, false otherwise.

isPrimitiveWrapper

public boolean isPrimitiveWrapper()

Is the type a wrapper for a primitive type as per the Java type system.

Returns:

True if the type is a primitive wrapper, false otherwise.

wrapPrimitive

public TypeToken<T> wrapPrimitive()

If this TypeToken is a primitive type, determine the wrapped primitive type.

Returns:

The wrapper type of the primitive type this TypeToken represents, otherwise this TypeToken itself.

unwrapPrimitive

public TypeToken<T> unwrapPrimitive()

If this TypeToken is a wrapper of a primitive type, determine the unwrapped primitive type.

Returns:

The primitive type wrapped by this TypeToken, otherwise this TypeToken itself.

withConstraintTo

public TypeToken<T> withConstraintTo(ConstraintFormula.Kind kind,
                                     java.lang.reflect.Type type)

Derive a new type from this one, with a constraint between this type and a given type. The invocation will fail if the constraint cannot be satisfied. For types which mention inference variables, this constraint may have an effect on the bounds of those inference variables within the resulting type.

Parameters:

type - the type to constrain against

kind - the kind of the constraint formula

Returns:

a new type token which satisfies the constraint

withConstraintTo

public TypeToken<T> withConstraintTo(ConstraintFormula.Kind kind,
                                     TypeToken<?> type)

Derive a new type from this one, with a constraint between this type and a given type. The invocation will fail if the constraint cannot be satisfied. For types which mention inference variables, this constraint may have an effect on the bounds of those inference variables within the resulting type.

Parameters:

type - the type to constrain against

kind - the kind of the constraint formula

Returns:

a new type token which satisfies the constraint

withConstraintFrom

public TypeToken<T> withConstraintFrom(ConstraintFormula.Kind kind,
                                       java.lang.reflect.Type type)

Derive a new type from this one, with a constraint between this type and a given type. The invocation will fail if the constraint cannot be satisfied. For types which mention inference variables, this constraint may have an effect on the bounds of those inference variables within the resulting type.

Parameters:

type - the type to constrain against

kind - the kind of the constraint formula

Returns:

a new type token which satisfies the constraint

withConstraintFrom

public TypeToken<T> withConstraintFrom(ConstraintFormula.Kind kind,
                                       TypeToken<?> type)

Derive a new type from this one, with a constraint between this type and a given type. The invocation will fail if the constraint cannot be satisfied. For types which mention inference variables, this constraint may have an effect on the bounds of those inference variables within the resulting type.

Parameters:

type - the type to constrain against

kind - the kind of the constraint formula

Returns:

a new type token which satisfies the constraint

satisfiesConstraintTo

public boolean satisfiesConstraintTo(ConstraintFormula.Kind kind,
                                     java.lang.reflect.Type type)

Derive a new type from this one, with a constraint between this type and a given type. The invocation will fail if the constraint cannot be satisfied. For types which mention inference variables, this constraint may have an effect on the bounds of those inference variables within the resulting type.

Parameters:

type - the type to constrain against

kind - the kind of the constraint formula

Returns:

a new type token which satisfies the constraint

satisfiesConstraintTo

public boolean satisfiesConstraintTo(ConstraintFormula.Kind kind,
                                     TypeToken<?> type)

Derive a new type from this one, with a constraint between this type and a given type. The invocation will fail if the constraint cannot be satisfied. For types which mention inference variables, this constraint may have an effect on the bounds of those inference variables within the resulting type.

Parameters:

type - the type to constrain against

kind - the kind of the constraint formula

Returns:

a new type token which satisfies the constraint

satisfiesConstraintFrom

public boolean satisfiesConstraintFrom(ConstraintFormula.Kind kind,
                                       java.lang.reflect.Type type)

Derive a new type from this one, with a constraint between this type and a given type. The invocation will fail if the constraint cannot be satisfied. For types which mention inference variables, this constraint may have an effect on the bounds of those inference variables within the resulting type.

Parameters:

type - the type to constrain against

kind - the kind of the constraint formula

Returns:

a new type token which satisfies the constraint

satisfiesConstraintFrom

public boolean satisfiesConstraintFrom(ConstraintFormula.Kind kind,
                                       TypeToken<?> type)

Derive a new type from this one, with a constraint between this type and a given type. The invocation will fail if the constraint cannot be satisfied. For types which mention inference variables, this constraint may have an effect on the bounds of those inference variables within the resulting type.

Parameters:

type - the type to constrain against

kind - the kind of the constraint formula

Returns:

a new type token which satisfies the constraint

parameterize

public TypeToken<? extends T> parameterize()

If the declaration is raw, parameterize it with its own type parameters, otherwise return the declaration itself.

Returns:

the parameterized version of the declaration where applicable, else the unmodified declaration

substituteInstantiations

public TypeToken<T> substituteInstantiations()

This method will attempt to substitute any inference variables mentioned by this type with their instantiations, if instantiations are available, and return a TypeToken over the resulting type.

Returns:

A TypeToken with the fully inferred type.

infer

public TypeToken<? extends T> infer()

If the type is raw it is parameterized with inference variables. Bounds are incorporated according to those present on the type variables each argument instantiates.

If the type is already parameterized, the existing arguments are substituted according to their type. Bounds are incorporated according to those present on the type variables each argument instantiates.

• Substitute wildcards with inference variables, incorporating bounds according to those present on the wildcard.
• Do not substitute types which are not wildcards.

Returns:

an inference over the exact type

resolve

public TypeToken<T> resolve()

This method will attempt to infer the actual type represented by this TypeToken, which means the types of any inference variables mentioned will be inferred and substituted. The receiver TypeToken instance will not be changed.

Returns:

A TypeToken with the fully inferred type.

isProper

public boolean isProper()

Determine whether this TypeToken represents a proper type.

Returns:

True if the type is proper, false otherwise.

getInferenceVariablesMentioned

public java.util.stream.Stream<InferenceVariable> getInferenceVariablesMentioned()

Determine which inference variables are mentioned by the type of this TypeToken.

Returns:

A set of all the inference variables which are contained within the bound set backing this TypeToken and which are mentioned by its type.

getRemainingInferenceVariableDependencies

public java.util.stream.Stream<InferenceVariable> getRemainingInferenceVariableDependencies()

Determine which inference variables are dependencies of those mentioned by the type of this TypeToken.

Returns:

A set of all the dependencies of the inference variables which are contained within the bound set backing this TypeToken and which are mentioned by its type.

getAnnotatedDeclaration

public java.lang.reflect.AnnotatedType getAnnotatedDeclaration()

Returns:

The annotated declaring type of this type token, if one exists, else an unannotated representation of the type of this type token.

cast

public T cast(java.lang.Object object)

Parameters:

object - an object to cast to this type

Returns:

the given object cast to a reference of this type

isCastableTo

public boolean isCastableTo(TypeToken<?> type)

Parameters:

type - the type to determine castability to

Returns:

true if the cast is possible, false otherwise

isCastableFrom

public boolean isCastableFrom(TypeToken<?> type)

Parameters:

type - the type to determine castability from

Returns:

true if the cast is possible, false otherwise

isCastableTo

public boolean isCastableTo(java.lang.reflect.Type type)

Parameters:

type - the type to determine castability to

Returns:

true if the cast is possible, false otherwise

isCastableFrom

public boolean isCastableFrom(java.lang.reflect.Type type)

Parameters:

type - the type to determine castability from

Returns:

true if the cast is possible, false otherwise

fields

public java.util.stream.Stream<FieldToken<T,?>> fields()

Find which fields can be resolved on this type.

Returns:

a list of all Field objects applicable to this type, wrapped in FieldToken instances

declaredFields

public java.util.stream.Stream<FieldToken<T,?>> declaredFields()

Find which fields are declared on this type.

Returns:

a list of all Field objects applicable to this type, wrapped in FieldToken instances

constructors

public java.util.stream.Stream<ExecutableToken<java.lang.Void,T>> constructors()

Find which constructors can be invoked for this type.

Returns:

a list of all Constructor objects applicable to this type, wrapped in ExecutableToken instances

declaredConstructors

public java.util.stream.Stream<ExecutableToken<java.lang.Void,T>> declaredConstructors()

Find which constructors can be invoked for this type.

Returns:

a list of all Constructor objects applicable to this type, wrapped in ExecutableToken instances

methods

public java.util.stream.Stream<ExecutableToken<T,?>> methods()

Find which methods of the given name can be invoked on instances of this type.

Returns:

a list of all Method objects applicable to this type, wrapped in ExecutableToken instances

declaredMethods

public java.util.stream.Stream<ExecutableToken<T,?>> declaredMethods()

Find which methods can be invoked on this type, whether statically or on instances.

Returns:

a list of all Method objects applicable to this type, wrapped in ExecutableToken instances

isRaw

public boolean isRaw()

Specified by:

isRaw in interface DeclarationToken<TypeToken<T>>

Returns:

true if the declaration represents a raw type or invocation, false otherwise

isGeneric

public boolean isGeneric()

Specified by:

isGeneric in interface DeclarationToken<TypeToken<T>>

Returns:

true if the declaration is generic, false otherwise

getTypeParameterCount

public int getTypeParameterCount()

Specified by:

getTypeParameterCount in interface DeclarationToken<TypeToken<T>>

Returns:

the count of the generic type parameters of the declaration.

getTypeParameters

public java.util.stream.Stream<TypeParameter<?>> getTypeParameters()

Specified by:

getTypeParameters in interface DeclarationToken<TypeToken<T>>

Returns:

The generic type parameter instantiations of the wrapped Executable, or their inference variables if not yet instantiated.

getTypeArguments

public java.util.stream.Stream<TypeArgument<?>> getTypeArguments()

Specified by:

getTypeArguments in interface DeclarationToken<TypeToken<T>>

Returns:

The generic type parameter instantiations of the wrapped Executable, or their inference variables if not yet instantiated.

withTypeArguments

public TypeToken<T> withTypeArguments(java.util.Collection<? extends TypeArgument<?>> arguments)

Description copied from interface: DeclarationToken

Derive a new ExecutableToken instance from this, with types substituted according to the given arguments.

More specifically, each of the given arguments represents a type variable and an instantiation for that type variable. Occurrences of those type variables in the declaration will be substituted for their instantiations in the derived declaration.

The substitution will only succeed if it results in a valid parameterization of the declaration.

For example, the following method could be used to derive instances of TypeToken over different parameterizations of List<?> at runtime.

 
 public TypeToken<List<T>> getListType(TypeToken<T> elementType)} {
   return new TypeToken<T>()} {}.withTypeArguments(new TypeParameter<T>() {}.as(elementType));
 }
 
 

Specified by:

withTypeArguments in interface DeclarationToken<TypeToken<T>>

Parameters:

arguments - the type variable instantiations

Returns:

a new derived ExecutableToken instance with the given instantiation substituted for the given type variable

getOwningDeclaration

public java.util.Optional<DeclarationToken<?>> getOwningDeclaration()

Specified by:

getOwningDeclaration in interface DeclarationToken<TypeToken<T>>

Returns:

the declaration directly enclosing this declaration

resolveSupertype

public TypeToken<? super T> resolveSupertype(java.lang.Class<?> superclass)

As @see TypeHierarchy.resolveSupertype( Class).

withTypeArguments

public TypeToken<T> withTypeArguments(java.util.List<java.lang.reflect.Type> typeArguments)

Description copied from interface: DeclarationToken

As @see DeclarationToken.withAllTypeArguments(List), but only providing arguments for the parameters occurring directly on the declaration.

Specified by:

withTypeArguments in interface DeclarationToken<TypeToken<T>>

withAllTypeArguments

public TypeToken<T> withAllTypeArguments(java.util.List<java.lang.reflect.Type> typeArguments)

Description copied from interface: DeclarationToken

Derive a new DeclarationToken instance with the given type argument parameterization.

The types in the given list correspond, in order, to the type parameters of this declaration. The current parameterization of the declaration is substituted for that given.

Each substitution will only succeed if it is compatible with the bounds on that type variable, and if it is more specific than the current argument, whether it is an InferenceVariable, a TypeVariableCapture, or another kind of Type.

This behavior is different from DeclarationToken.withTypeArguments(Collection), which performs a substitution for arbitrary type variables rather than re-instantiating every parameter on the declaration.

Specified by:

withAllTypeArguments in interface DeclarationToken<TypeToken<T>>

Parameters:

typeArguments - a list of arguments for each generic type parameter of the underlying declaration

Returns:

a new derived DeclarationToken instance with the given instantiations substituted for each generic type parameter, in order

withTypeArguments

public TypeToken<T> withTypeArguments(java.lang.reflect.Type... typeArguments)

Specified by:

withTypeArguments in interface DeclarationToken<TypeToken<T>>

See Also:

DeclarationToken.withTypeArguments(List)

withAllTypeArguments

public TypeToken<T> withAllTypeArguments(java.lang.reflect.Type... typeArguments)

Specified by:

withAllTypeArguments in interface DeclarationToken<TypeToken<T>>

See Also:

DeclarationToken.withTypeArguments(List)