uk.co.strangeskies.reflection.token

Interface DeclarationToken<S extends DeclarationToken<S>>

Type Parameters:

S - the type of declaration

All Known Subinterfaces:

MemberToken<T,S>

All Known Implementing Classes:

ExecutableToken, FieldToken, TypeParameter, TypeToken

public interface DeclarationToken<S extends DeclarationToken<S>>

A token representing a declaration. If the declaration is generic, it may be raw or parameterized.

Method Summary

Modifier and Type	Method and Description
default java.util.stream.Stream<TypeArgument<?>>	getAllTypeArguments()
default int	getAllTypeParameterCount()
default java.util.stream.Stream<TypeParameter<?>>	getAllTypeParameters()
java.util.Optional<? extends DeclarationToken<?>>	getOwningDeclaration()
java.util.stream.Stream<TypeArgument<?>>	getTypeArguments()
int	getTypeParameterCount()
java.util.stream.Stream<TypeParameter<?>>	getTypeParameters()
boolean	isGeneric()
boolean	isRaw()
default <U> TypeArgument<U>	resolveTypeArgument(TypeParameter<U> parameter) Resolve the instantiation of the given type variable in the context of this declaration.
default java.lang.reflect.Type	resolveTypeArgument(java.lang.reflect.TypeVariable<?> parameter)
DeclarationToken<?>	withAllTypeArguments(java.util.List<java.lang.reflect.Type> typeArguments) Derive a new DeclarationToken instance with the given type argument parameterization.
DeclarationToken<?>	withAllTypeArguments(java.lang.reflect.Type... typeArguments)
S	withTypeArguments(java.util.Collection<? extends TypeArgument<?>> arguments) Derive a new ExecutableToken instance from this, with types substituted according to the given arguments.
DeclarationToken<?>	withTypeArguments(java.util.List<java.lang.reflect.Type> typeArguments) As @see withAllTypeArguments(List), but only providing arguments for the parameters occurring directly on the declaration.
DeclarationToken<?>	withTypeArguments(java.lang.reflect.Type... typeArguments)
default S	withTypeArguments(TypeArgument<?>... arguments) Derive a new ExecutableToken instance from this, with the given instantiation substituted for the given TypeVariable.

Method Detail

isRaw

boolean isRaw()

Returns:

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

isGeneric

boolean isGeneric()

Returns:

true if the declaration is generic, false otherwise

getOwningDeclaration

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

Returns:

the declaration directly enclosing this declaration

getAllTypeParameterCount

default int getAllTypeParameterCount()

Returns:

the count of all generic type parameters of the declaration and any enclosing declarations

getAllTypeParameters

default java.util.stream.Stream<TypeParameter<?>> getAllTypeParameters()

Returns:

all generic type parameters of the declaration and any enclosing declarations

getAllTypeArguments

default java.util.stream.Stream<TypeArgument<?>> getAllTypeArguments()

Returns:

all generic type parameter instantiations of the declaration, or their inference variables if not yet instantiated.

getTypeParameterCount

int getTypeParameterCount()

Returns:

the count of the generic type parameters of the declaration.

getTypeParameters

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

Returns:

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

getTypeArguments

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

Returns:

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

withTypeArguments

default S withTypeArguments(TypeArgument<?>... arguments)

Derive a new ExecutableToken instance from this, with the given instantiation substituted for the given TypeVariable.

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

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));
 }
 
 

This behavior is different from withTypeArguments(List), which re-instantiates every parameter on the declaration rather than performing a substitution for arbitrary type variables.

Parameters:

arguments - the type variable instantiations

Returns:

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

withTypeArguments

S withTypeArguments(java.util.Collection<? extends TypeArgument<?>> arguments)

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));
 }
 
 

Parameters:

arguments - the type variable instantiations

Returns:

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

resolveTypeArgument

default <U> TypeArgument<U> resolveTypeArgument(TypeParameter<U> parameter)

Resolve the instantiation of the given type variable in the context of this declaration.

Type Parameters:

U - the type of the type variable to resolve

Parameters:

parameter - the type parameter

Returns:

the argument of the given parameter with respect to this declaration

resolveTypeArgument

default java.lang.reflect.Type resolveTypeArgument(java.lang.reflect.TypeVariable<?> parameter)

See Also:

resolveTypeArgument(TypeParameter)

withAllTypeArguments

DeclarationToken<?> withAllTypeArguments(java.lang.reflect.Type... typeArguments)

See Also:

withTypeArguments(List)

withTypeArguments

DeclarationToken<?> withTypeArguments(java.lang.reflect.Type... typeArguments)

See Also:

withTypeArguments(List)

withAllTypeArguments

DeclarationToken<?> withAllTypeArguments(java.util.List<java.lang.reflect.Type> typeArguments)

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 withTypeArguments(Collection), which performs a substitution for arbitrary type variables rather than re-instantiating every parameter on the declaration.

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

DeclarationToken<?> withTypeArguments(java.util.List<java.lang.reflect.Type> typeArguments)

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