TypeResolver (Guava: Google Core Libraries for Java 31.1-jre API)

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

```
public final class TypeResolver
extends 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

Author:

Ben Yu

Constructor Summary

Constructors
Constructor Description

TypeResolver()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Type`	`resolveType(Type type)`	Resolves all type variables in `type` and all downstream types and returns a corresponding type with type variables resolved.
`TypeResolver`	`where(Type formal, Type actual)`	Returns a new `TypeResolver` with type variables in `formal` mapping to types in `actual`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - TypeResolver
```
public TypeResolver()
```
- Method Detail
  - where
```
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 - 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.
  - resolveType
```
public Type resolveType(Type type)
```
    Resolves all type variables in type and all downstream types and returns a corresponding type with type variables resolved.