Modifier and Type	Class and Description
private static class	TypeResolver.TypeMappingIntrospector
private static class	TypeResolver.TypeTable A TypeTable maintains mapping from `TypeVariable` to types.
pack-priv static class	TypeResolver.TypeVariableKey Wraps around `TypeVariable<?`
private static class	TypeResolver.WildcardCapturer

Modifier and Type	Field and Description
private final TypeResolver.TypeTable	typeTable

Access	Constructor and Description
public	TypeResolver()
private	TypeResolver(TypeResolver.TypeTable typeTable)

Method Summary

Modifier and Type	Method and Description
pack-priv static TypeResolver	covariantly(Type contextType) Returns a resolver that resolves types "covariantly".
private static <T> T	expectArgument(Class<T> type, Object arg)
pack-priv static TypeResolver	invariantly(Type contextType) Returns a resolver that resolves types "invariantly".
private static void	populateTypeMappings(Map<TypeResolver.TypeVariableKey, Type> mappings, Type from, Type to)
private Type	resolveGenericArrayType(GenericArrayType type)
private ParameterizedType	resolveParameterizedType(ParameterizedType type)
public Type	resolveType(Type type) Resolves all type variables in `type` and all downstream types and returns a corresponding type with type variables resolved.
private Type[]	resolveTypes(Type[] types)
pack-priv Type[]	resolveTypesInPlace(Type[] types)
private WildcardType	resolveWildcardType(WildcardType type)
public TypeResolver	where(Type The type whose type variables or itself is mapped to other type(s). It's almost always a bug if `formal` isn't a type variable and contains no type variable. Make sure you are passing the two parameters in the right order. formal, Type The type that the formal type variable(s) are mapped to. It can be or contain yet other type variables, in which case these type variables will be further resolved if corresponding mappings exist in the current `TypeResolver` instance. actual) Returns a new `TypeResolver` with type variables in `formal` mapping to types in `actual`.
pack-priv TypeResolver	where(Map<TypeResolver.TypeVariableKey, ? extends Type> mappings) Returns a new `TypeResolver` with `variable` mapping to `type`.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

typeTable	back to summary
private final TypeResolver.TypeTable typeTable

TypeResolver	back to summary
public TypeResolver()

TypeResolver	back to summary
private TypeResolver(TypeResolver.TypeTable typeTable)

Method Detail

covariantly back to summary

covariantly	back to summary
pack-priv static TypeResolver covariantly(Type contextType) Returns a resolver that resolves types "covariantly". For example, when resolving `List<T>` in the context of `ArrayList<?>`, `<T>` is covariantly resolved to `<?>` such that return type of `List::get` is `<?>`.

pack-priv static TypeResolver covariantly(Type contextType)

Returns a resolver that resolves types "covariantly".

For example, when resolving List<T> in the context of ArrayList<?>, <T> is covariantly resolved to <?> such that return type of List::get is <?>.

expectArgument	back to summary
private static <T> T expectArgument(Class<T> type, Object arg)

invariantly back to summary

invariantly	back to summary
pack-priv static TypeResolver invariantly(Type contextType) Returns a resolver that resolves types "invariantly". For example, when resolving `List<T>` in the context of `ArrayList<?>`, `<T>` cannot be invariantly resolved to `<?>` because otherwise the parameter type of `List::set` will be `<?>` and it'll falsely say any object can be passed into `ArrayList<?>::set`. Instead, `<?>` will be resolved to a capture in the form of a type variable `<capture-of-? extends Object>`, effectively preventing `set` from accepting any type.

pack-priv static TypeResolver invariantly(Type contextType)

Returns a resolver that resolves types "invariantly".

For example, when resolving List<T> in the context of ArrayList<?>, <T> cannot be invariantly resolved to <?> because otherwise the parameter type of List::set will be <?> and it'll falsely say any object can be passed into ArrayList<?>::set.

Instead, <?> will be resolved to a capture in the form of a type variable <capture-of-? extends Object>, effectively preventing set from accepting any type.

populateTypeMappings	back to summary
private static void populateTypeMappings(Map<TypeResolver.TypeVariableKey, Type> mappings, Type from, Type to)

resolveGenericArrayType	back to summary
private Type resolveGenericArrayType(GenericArrayType type)

resolveParameterizedType	back to summary
private ParameterizedType resolveParameterizedType(ParameterizedType type)

resolveType	back to summary
public Type resolveType(Type type) Resolves all type variables in `type` and all downstream types and returns a corresponding type with type variables resolved.

resolveTypes	back to summary
private Type[] resolveTypes(Type[] types)

resolveTypesInPlace	back to summary
pack-priv Type[] resolveTypesInPlace(Type[] types)

resolveWildcardType	back to summary
private WildcardType resolveWildcardType(WildcardType type)

where back to summary

where	back to summary
public TypeResolver where(Type formal, Type actual) Returns a new `TypeResolver` with type variables in `formal` mapping to types in `actual`. For example, if `formal` is a `TypeVariable T`, and `actual` is `String.class`, then `new TypeResolver().where(formal, actual)` will resolve `ParameterizedType List<T>` to `List<String>`, and resolve `Map<T, Something>` to `Map<String, Something>` etc. Similarly, `formal` and `actual` can be `Map<K, V>` and `Map<String, Integer>` respectively, or they can be `E[]` and `String[]` respectively, or even any arbitrary combination thereof. Parameters formal:Type The type whose type variables or itself is mapped to other type(s). It's almost always a bug if `formal` isn't a type variable and contains no type variable. Make sure you are passing the two parameters in the right order. actual:Type The type that the formal type variable(s) are mapped to. It can be or contain yet other type variables, in which case these type variables will be further resolved if corresponding mappings exist in the current `TypeResolver` instance.

public TypeResolver where(Type formal, Type actual)

Returns a new TypeResolver with type variables in formal mapping to types in actual.

For example, if formal is a TypeVariable T, and actual is String.class, then new TypeResolver().where(formal, actual) will resolve ParameterizedType List<T> to List<String>, and resolve Map<T, Something> to Map<String, Something> etc. Similarly, formal and actual can be Map<K, V> and Map<String, Integer> respectively, or they can be E[] and String[] respectively, or even any arbitrary combination thereof.

Parameters

formal:Type: The type whose type variables or itself is mapped to other type(s). It's almost always a bug if formal isn't a type variable and contains no type variable. Make sure you are passing the two parameters in the right order.
actual:Type: The type that the formal type variable(s) are mapped to. It can be or contain yet other type variables, in which case these type variables will be further resolved if corresponding mappings exist in the current TypeResolver instance.

where	back to summary
pack-priv TypeResolver where(Map<TypeResolver.TypeVariableKey, ? extends Type> mappings) Returns a new `TypeResolver` with `variable` mapping to `type`.

com.google.common.reflect back to summary

private final Class TypeResolver.TypeMappingIntrospector

Class Inheritance

extends TypeVisitor

java.lang.Object
com.google.common.reflect.TypeVisitor
com.google.common.reflect.TypeResolver.TypeMappingIntrospector

Field Summary

Modifier and Type	Field and Description
private final Map<TypeResolver.TypeVariableKey, Type>	mappings

Constructor Summary

Access	Constructor and Description
private	TypeMappingIntrospector()

Method Summary

Modifier and Type	Method and Description
pack-priv static ImmutableMap<TypeResolver.TypeVariableKey, Type>	getTypeMappings(Type contextType) Returns type mappings using type parameters and type arguments found in the generic superclass and the super interfaces of `contextClass`.
private void	map(TypeResolver.TypeVariableKey var, Type arg)
pack-priv void	visitClass(Class<?> clazz) Overrides com.google.common.reflect.TypeVisitor.visitClass.
pack-priv void	visitParameterizedType(ParameterizedType parameterizedType) Overrides com.google.common.reflect.TypeVisitor.visitParameterizedType.
pack-priv void	visitTypeVariable(TypeVariable<?> t) Overrides com.google.common.reflect.TypeVisitor.visitTypeVariable.
pack-priv void	visitWildcardType(WildcardType t) Overrides com.google.common.reflect.TypeVisitor.visitWildcardType.

Inherited from com.google.common.reflect.TypeVisitor:: visit visitGenericArrayType

Field Detail

mappings	back to summary
private final Map<TypeResolver.TypeVariableKey, Type> mappings

Constructor Detail

TypeMappingIntrospector	back to summary
private TypeMappingIntrospector()

Method Detail

getTypeMappings	back to summary
pack-priv static ImmutableMap<TypeResolver.TypeVariableKey, Type> getTypeMappings(Type contextType) Returns type mappings using type parameters and type arguments found in the generic superclass and the super interfaces of `contextClass`.

map	back to summary
private void map(TypeResolver.TypeVariableKey var, Type arg)

visitClass	back to summary
pack-priv void visitClass(Class<?> clazz) Overrides com.google.common.reflect.TypeVisitor.visitClass. Annotations @Override

visitClass

back to summary

pack-priv void visitClass(Class<?> clazz)

Overrides com.google.common.reflect.TypeVisitor.visitClass.

Annotations

@Override

visitParameterizedType	back to summary
pack-priv void visitParameterizedType(ParameterizedType parameterizedType) Overrides com.google.common.reflect.TypeVisitor.visitParameterizedType. Annotations @Override

visitParameterizedType

back to summary

pack-priv void visitParameterizedType(ParameterizedType parameterizedType)

Overrides com.google.common.reflect.TypeVisitor.visitParameterizedType.

Annotations

@Override

visitTypeVariable	back to summary
pack-priv void visitTypeVariable(TypeVariable<?> t) Overrides com.google.common.reflect.TypeVisitor.visitTypeVariable. Annotations @Override

visitTypeVariable

back to summary

pack-priv void visitTypeVariable(TypeVariable<?> t)

Overrides com.google.common.reflect.TypeVisitor.visitTypeVariable.

Annotations

@Override

visitWildcardType	back to summary
pack-priv void visitWildcardType(WildcardType t) Overrides com.google.common.reflect.TypeVisitor.visitWildcardType. Annotations @Override

visitWildcardType

back to summary

pack-priv void visitWildcardType(WildcardType t)

Overrides com.google.common.reflect.TypeVisitor.visitWildcardType.

Annotations

@Override

com.google.common.reflect back to summary

private Class TypeResolver.TypeTable

Class Inheritance

extends Object

java.lang.Object
com.google.common.reflect.TypeResolver.TypeTable

A TypeTable maintains mapping from TypeVariable to types.

Field Summary

Modifier and Type	Field and Description
private final ImmutableMap<TypeResolver.TypeVariableKey, Type>	map

Constructor Summary

Access	Constructor and Description
pack-priv	TypeTable()
private	TypeTable(ImmutableMap<TypeResolver.TypeVariableKey, Type> map)

Method Summary

Modifier and Type	Method and Description
pack-priv final Type	resolve(TypeVariable<?> var)
pack-priv Type	resolveInternal(TypeVariable<?> var, TypeResolver.TypeTable forDependants) Resolves `var` using the encapsulated type mapping.
pack-priv final TypeResolver.TypeTable	where(Map<TypeResolver.TypeVariableKey, ? extends Type> mappings) Returns a new `TypeResolver` with `variable` mapping to `type`.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

map	back to summary
private final ImmutableMap<TypeResolver.TypeVariableKey, Type> map

Constructor Detail

TypeTable	back to summary
pack-priv TypeTable()

TypeTable	back to summary
private TypeTable(ImmutableMap<TypeResolver.TypeVariableKey, Type> map)

Method Detail

resolve	back to summary
pack-priv final Type resolve(TypeVariable<?> var)

resolveInternal back to summary

resolveInternal	back to summary
pack-priv Type resolveInternal(TypeVariable<?> var, TypeResolver.TypeTable forDependants) Resolves `var` using the encapsulated type mapping. If it maps to yet another non-reified type or has bounds, `forDependants` is used to do further resolution, which doesn't try to resolve any type variable on generic declarations that are already being resolved. Should only be called and overridden by `resolve(TypeVariable)`.

pack-priv Type resolveInternal(TypeVariable<?> var, TypeResolver.TypeTable forDependants)

Resolves var using the encapsulated type mapping. If it maps to yet another non-reified type or has bounds, forDependants is used to do further resolution, which doesn't try to resolve any type variable on generic declarations that are already being resolved.

Should only be called and overridden by resolve(TypeVariable).

where	back to summary
pack-priv final TypeResolver.TypeTable where(Map<TypeResolver.TypeVariableKey, ? extends Type> mappings) Returns a new `TypeResolver` with `variable` mapping to `type`.

com.google.common.reflect back to summary

pack-priv final Class TypeResolver.TypeVariableKey

Class Inheritance

extends Object

java.lang.Object
com.google.common.reflect.TypeResolver.TypeVariableKey

Wraps around TypeVariable<?> to ensure that any two type variables are equal as long as they are declared by the same java.lang.reflect.GenericDeclaration and have the same name, even if their bounds differ.

While resolving a type variable from a var -> type map, we don't care whether the type variable's bound has been partially resolved. As long as the type variable "identity" matches.

On the other hand, if for example we are resolving List<A extends B> to List<A extends String>, we need to compare that <A extends B> is unequal to <A extends String> in order to decide to use the transformed type instead of the original type.

Field Summary

Modifier and Type	Field and Description
private final TypeVariable<?>	var

Constructor Summary

Access	Constructor and Description
pack-priv	TypeVariableKey(TypeVariable<?> var)

Method Summary

Modifier and Type	Method and Description
public boolean	equals(Object the reference object with which to compare. obj) Overrides java.lang.Object.equals. Indicates whether some other object is "equal to" this one.
pack-priv boolean	equalsType(Type type) Returns true if `type` is a `TypeVariable` with the same name and declared by the same `GenericDeclaration`.
private boolean	equalsTypeVariable(TypeVariable<?> that)
pack-priv static TypeResolver.TypeVariableKey	forLookup(Type t) Wraps `t` in a `TypeVariableKey` if it's a type variable.
public int	hashCode() Overrides java.lang.Object.hashCode. Returns a hash code value for the object.
public String	toString() Overrides java.lang.Object.toString. Returns a string representation of the object.

Inherited from java.lang.Object:: clone finalize getClass notify notifyAll wait wait wait

Field Detail

var	back to summary
private final TypeVariable<?> var

Constructor Detail

TypeVariableKey	back to summary
pack-priv TypeVariableKey(TypeVariable<?> var)

Method Detail

equals back to summary

equals	back to summary
public boolean equals(Object obj) Overrides java.lang.Object.equals. Doc from java.lang.Object.equals. Indicates whether some other object is "equal to" this one. The `equals` method implements an equivalence relation on non-null object references: It is reflexive: for any non-null reference value `x`, `x.equals(x)` should return `true`. It is symmetric: for any non-null reference values `x` and `y`, `x.equals(y)` should return `true` if and only if `y.equals(x)` returns `true`. It is transitive: for any non-null reference values `x`, `y`, and `z`, if `x.equals(y)` returns `true` and `y.equals(z)` returns `true`, then `x.equals(z)` should return `true`. It is consistent: for any non-null reference values `x` and `y`, multiple invocations of `x.equals(y)` consistently return `true` or consistently return `false`, provided no information used in `equals` comparisons on the objects is modified. For any non-null reference value `x`, `x.equals(null)` should return `false`. An equivalence relation partitions the elements it operates on into equivalence classes; all the members of an equivalence class are equal to each other. Members of an equivalence class are substitutable for each other, at least for some purposes. Parameters obj:Object the reference object with which to compare. Returns:boolean `true` if this object is the same as the obj argument; `false` otherwise. Annotations @Override

public boolean equals(Object obj)

Overrides java.lang.Object.equals.

Doc from java.lang.Object.equals.

Indicates whether some other object is "equal to" this one.

The equals method implements an equivalence relation on non-null object references:

It is reflexive: for any non-null reference value x, x.equals(x) should return true.
It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
For any non-null reference value x, x.equals(null) should return false.

An equivalence relation partitions the elements it operates on into equivalence classes; all the members of an equivalence class are equal to each other. Members of an equivalence class are substitutable for each other, at least for some purposes.

Parameters

obj:Object: the reference object with which to compare.

Returns:boolean

true if this object is the same as the obj argument; false otherwise.

Annotations

@Override

equalsType	back to summary
pack-priv boolean equalsType(Type type) Returns true if `type` is a `TypeVariable` with the same name and declared by the same `GenericDeclaration`.

equalsTypeVariable	back to summary
private boolean equalsTypeVariable(TypeVariable<?> that)

forLookup back to summary

forLookup	back to summary
pack-priv static TypeResolver.TypeVariableKey forLookup(Type t) Wraps `t` in a `TypeVariableKey` if it's a type variable. Annotations @CheckForNull

pack-priv static TypeResolver.TypeVariableKey forLookup(Type t)

Wraps t in a TypeVariableKey if it's a type variable.

Annotations

@CheckForNull

hashCode back to summary

hashCode	back to summary
public int hashCode() Overrides java.lang.Object.hashCode. Doc from java.lang.Object.hashCode. Returns a hash code value for the object. This method is supported for the benefit of hash tables such as those provided by `java.util.HashMap`. The general contract of `hashCode` is: Whenever it is invoked on the same object more than once during an execution of a Java application, the `hashCode` method must consistently return the same integer, provided no information used in `equals` comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application. If two objects are equal according to the `equals` method, then calling the `hashCode` method on each of the two objects must produce the same integer result. It is not required that if two objects are unequal according to the `equals` method, then calling the `hashCode` method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables. Returns:int a hash code value for this object. Annotations @Override

public int hashCode()

Overrides java.lang.Object.hashCode.

Doc from java.lang.Object.hashCode.

Returns a hash code value for the object. This method is supported for the benefit of hash tables such as those provided by java.util.HashMap.

The general contract of hashCode is:

Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
If two objects are equal according to the equals method, then calling the hashCode method on each of the two objects must produce the same integer result.
It is not required that if two objects are unequal according to the equals method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.

Returns:int

a hash code value for this object.

Annotations

@Override

toString	back to summary
public String toString() Overrides java.lang.Object.toString. Doc from java.lang.Object.toString. Returns a string representation of the object. Returns:String a string representation of the object. Annotations @Override

toString

back to summary

public String toString()

Overrides java.lang.Object.toString.

Doc from java.lang.Object.toString.

Returns a string representation of the object.

Returns:String

a string representation of the object.

Annotations

@Override

Modifier and Type	Method and Description
pack-priv final Type	capture(Type type)
pack-priv TypeVariable<?>	captureAsTypeVariable(Type[] upperBounds)
private Type	captureNullable(Type type)
private TypeResolver.WildcardCapturer	forTypeVariable(TypeVariable<?> typeParam)
private TypeResolver.WildcardCapturer	notForTypeVariable()

public final Class TypeResolver

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private final Class TypeResolver.TypeMappingIntrospector

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private Class TypeResolver.TypeTable

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

pack-priv final Class TypeResolver.TypeVariableKey

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private Class TypeResolver.WildcardCapturer

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

Modifier and Type	Field and Description
private final AtomicInteger	id
pack-priv static final TypeResolver.WildcardCapturer	INSTANCE

Access	Constructor and Description
private	WildcardCapturer()
private	WildcardCapturer(AtomicInteger id)