com.google.common.reflect

## Class TypeResolver

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

-     @Beta
      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

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `TypeResolver()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `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`.

    - ### 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(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.

    - #### 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.