org.jboss.resteasy.util

## Class Types

- java.lang.Object
- - org.jboss.resteasy.util.Types

-     public class Types
      extends Object

  Type conversions and generic type manipulations
  Version:
    $Revision: 1 $
  Author:
    Bill Burke

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `Types()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static Type[]` | `findClassParameterizedTypes(Class<?> root, ParameterizedType rootType, Class<?> searchedForClass)`
    `static Type[]` | `findInterfaceParameterizedTypes(Class<?> root, ParameterizedType rootType, Class<?> searchedForInterface)`
    `static Type[]` | `findParameterizedTypes(Class<?> root, Class<?> searchedFor)` Search for the given interface or class within the root's class/interface hierarchy.
    `static Type[]` | `getActualTypeArgumentsOfAnInterface(Class<?> classToSearch, Class<?> interfaceToFind)` Given a class and an interfaces, go through the class hierarchy to find the interface and return its type arguments.
    `static Class` | `getArgumentType(ParameterizedType pType, int index)` Gets the index-th type argument.
    `static Class` | `getCollectionBaseType(Class type, Type genericType)`
    `static Method` | `getImplementingMethod(Class clazz, Method intfMethod)` Given a method and a root class, find the actual method declared in the root that implements the method.
    `static Class` | `getMapKeyType(Type genericType)`
    `static Class` | `getMapValueType(Type genericType)`
    `static Class<?>` | `getRawType(Type type)`
    `static Class<?>` | `getRawTypeNoException(Type type)`
    `static Class` | `getTemplateParameterOfInterface(Class base, Class desiredInterface)`
    `static Class<?>` | `getTypeArgument(Type genericType)` Returns the type argument from a parameterized type
    `static boolean` | `isA(Class clazz, ParameterizedType pType)` Is the genericType of a certain class?
    `static boolean` | `isCompatible(Method method, Method intfMethod)` See if the two methods are compatible, that is they have the same relative signature
    `static Type` | `resolveTypeVariable(Class<?> root, TypeVariable<?> typeVariable)` Finds an actual value of a type variable.
    `static Type` | `resolveTypeVariables(Class<?> root, Type type)`

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### Types

          public Types()

  - ### Method Detail

    - #### isA

          public static boolean isA(Class clazz,
                    ParameterizedType pType)

      Is the genericType of a certain class?

    - #### getArgumentType

          public static Class getArgumentType(ParameterizedType pType,
                              int index)

      Gets the index-th type argument.

    - #### getTemplateParameterOfInterface

          public static Class getTemplateParameterOfInterface(Class base,
                                              Class desiredInterface)

    - #### isCompatible

          public static boolean isCompatible(Method method,
                             Method intfMethod)

      See if the two methods are compatible, that is they have the same relative signature
      Parameters:
        `method` -
        `intfMethod` -
      Returns:

    - #### getImplementingMethod

          public static Method getImplementingMethod(Class clazz,
                                     Method intfMethod)

      Given a method and a root class, find the actual method declared in the root that implements the method.
      Parameters:
        `clazz` -
        `intfMethod` -
      Returns:

    - #### getRawType

          public static Class<?> getRawType(Type type)

    - #### getRawTypeNoException

          public static Class<?> getRawTypeNoException(Type type)

    - #### getTypeArgument

          public static Class<?> getTypeArgument(Type genericType)

      Returns the type argument from a parameterized type
      Parameters:
        `genericType` -
      Returns:
        null if there is no type parameter

    - #### getCollectionBaseType

          public static Class getCollectionBaseType(Class type,
                                    Type genericType)

    - #### getMapKeyType

          public static Class getMapKeyType(Type genericType)

    - #### getMapValueType

          public static Class getMapValueType(Type genericType)

    - #### resolveTypeVariables

          public static Type resolveTypeVariables(Class<?> root,
                                  Type type)

    - #### resolveTypeVariable

          public static Type resolveTypeVariable(Class<?> root,
                                 TypeVariable<?> typeVariable)

      Finds an actual value of a type variable. The method looks in a class hierarchy for a class defining the variable and returns the value if present.
      Parameters:
        `root` -
        `typeVariable` -
      Returns:
        actual type of the type variable

    - #### getActualTypeArgumentsOfAnInterface

          public static Type[] getActualTypeArgumentsOfAnInterface(Class<?> classToSearch,
                                                   Class<?> interfaceToFind)

      Given a class and an interfaces, go through the class hierarchy to find the interface and return its type arguments.
      Parameters:
        `classToSearch` -
        `interfaceToFind` -
      Returns:
        type arguments of the interface

    - #### findParameterizedTypes

          public static Type[] findParameterizedTypes(Class<?> root,
                                      Class<?> searchedFor)

      Search for the given interface or class within the root's class/interface hierarchy. If the searched for class/interface is a generic return an array of real types that fill it out.
      Parameters:
        `root` -
        `searchedFor` -
      Returns:

    - #### findClassParameterizedTypes

          public static Type[] findClassParameterizedTypes(Class<?> root,
                                           ParameterizedType rootType,
                                           Class<?> searchedForClass)

    - #### findInterfaceParameterizedTypes

          public static Type[] findInterfaceParameterizedTypes(Class<?> root,
                                               ParameterizedType rootType,
                                               Class<?> searchedForInterface)

Copyright © 2014. All Rights Reserved.