Package com.google.common.reflect

Class TypeResolver

java.lang.Object

com.google.common.reflect.TypeResolver

public final class TypeResolver
extends java.lang.Object

An object of this class encapsulates type mappings from type variables. Mappings are established with where(java.lang.reflect.Type, java.lang.reflect.Type) and types are resolved using resolveType(java.lang.reflect.Type).

Note that usually type mappings are already implied by the static type hierarchy (for example, the E type variable declared by class List naturally maps to String in the context of class MyStringList implements List<String>. In such case, prefer to use TypeToken.resolveType(java.lang.reflect.Type) since it's simpler and more type safe. This class should only be used when the type mapping isn't implied by the static type hierarchy, but provided through other means such as an annotation or external configuration file.

Since:

15.0

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	TypeResolver.TypeMappingIntrospector
private static class	TypeResolver.TypeTable	A TypeTable maintains mapping from TypeVariable to types.
(package private) static class	TypeResolver.TypeVariableKey	Wraps around TypeVariable<?> to ensure that any two type variables are equal as long as they are declared by the same GenericDeclaration and have the same name, even if their bounds differ.
private static class	TypeResolver.WildcardCapturer

Field Summary

Fields

Modifier and Type	Field	Description
private TypeResolver.TypeTable	typeTable

Constructor Summary

Constructors

Modifier	Constructor	Description
	TypeResolver()
private	TypeResolver(TypeResolver.TypeTable typeTable)

Method Summary

Modifier and Type	Method	Description
(package private) static TypeResolver	covariantly(java.lang.reflect.Type contextType)	Returns a resolver that resolves types "covariantly".
private static <T> T	expectArgument(java.lang.Class<T> type, java.lang.Object arg)
(package private) static TypeResolver	invariantly(java.lang.reflect.Type contextType)	Returns a resolver that resolves types "invariantly".
private static void	populateTypeMappings(java.util.Map<TypeResolver.TypeVariableKey,java.lang.reflect.Type> mappings, java.lang.reflect.Type from, java.lang.reflect.Type to)
private java.lang.reflect.Type	resolveGenericArrayType(java.lang.reflect.GenericArrayType type)
private java.lang.reflect.ParameterizedType	resolveParameterizedType(java.lang.reflect.ParameterizedType type)
java.lang.reflect.Type	resolveType(java.lang.reflect.Type type)	Resolves all type variables in type and all downstream types and returns a corresponding type with type variables resolved.
private java.lang.reflect.Type[]	resolveTypes(java.lang.reflect.Type[] types)
(package private) java.lang.reflect.Type[]	resolveTypesInPlace(java.lang.reflect.Type[] types)
private java.lang.reflect.WildcardType	resolveWildcardType(java.lang.reflect.WildcardType type)
TypeResolver	where(java.lang.reflect.Type formal, java.lang.reflect.Type actual)	Returns a new TypeResolver with type variables in formal mapping to types in actual.
(package private) TypeResolver	where(java.util.Map<TypeResolver.TypeVariableKey,? extends java.lang.reflect.Type> mappings)	Returns a new TypeResolver with variable mapping to type.

Methods inherited from class java.lang.Object

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

Field Detail

typeTable

private final TypeResolver.TypeTable typeTable

Constructor Detail

TypeResolver

public TypeResolver()

TypeResolver

private TypeResolver(TypeResolver.TypeTable typeTable)

Method Detail

covariantly

static TypeResolver covariantly(java.lang.reflect.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 <?>.

invariantly

static TypeResolver invariantly(java.lang.reflect.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.

where

public TypeResolver where(java.lang.reflect.Type formal,
                          java.lang.reflect.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 - 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 - 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

TypeResolver where(java.util.Map<TypeResolver.TypeVariableKey,? extends java.lang.reflect.Type> mappings)

Returns a new TypeResolver with variable mapping to type.

populateTypeMappings

private static void populateTypeMappings(java.util.Map<TypeResolver.TypeVariableKey,java.lang.reflect.Type> mappings,
                                         java.lang.reflect.Type from,
                                         java.lang.reflect.Type to)

resolveType

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

Resolves all type variables in type and all downstream types and returns a corresponding type with type variables resolved.

resolveTypesInPlace

java.lang.reflect.Type[] resolveTypesInPlace(java.lang.reflect.Type[] types)

resolveTypes

private java.lang.reflect.Type[] resolveTypes(java.lang.reflect.Type[] types)

resolveWildcardType

private java.lang.reflect.WildcardType resolveWildcardType(java.lang.reflect.WildcardType type)

resolveGenericArrayType

private java.lang.reflect.Type resolveGenericArrayType(java.lang.reflect.GenericArrayType type)

resolveParameterizedType

private java.lang.reflect.ParameterizedType resolveParameterizedType(java.lang.reflect.ParameterizedType type)

expectArgument

private static <T> T expectArgument(java.lang.Class<T> type,
                                    java.lang.Object arg)