Class Types

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

public final class Types extends Object
Type conversions and generic type manipulations
Version:
$Revision: 1 $
Author:
Bill Burke
  • Constructor Details

    • Types

      public Types()
  • Method Details

    • isA

      public static boolean isA(Class clazz, ParameterizedType pType)
      Is the genericType of a certain class?
      Parameters:
      clazz - class
      pType - type
      Returns:
      boolean result
    • getArgumentType

      public static Class getArgumentType(ParameterizedType pType, int index)
      Gets the index-th type argument.
      Parameters:
      pType - type
      index - index
      Returns:
      the type of argument at index position
    • 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 - first method
      intfMethod - second method
      Returns:
      boolean result
    • 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 - class
      intfMethod - method
      Returns:
      method in the root class
    • getImplementedInterfaceMethod

      public static Method getImplementedInterfaceMethod(Class<?> root, Class<?> iface, Method implementation)
      Find the by a method implementation implemented interface method.
      Parameters:
      root - The root class of the class hierarchy.
      iface - The containing interface of the implemented method in the class hierarchy.
      implementation - The method implementation.
      Returns:
      The implemented method.
    • findOverriddenMethod

      public static Method findOverriddenMethod(Class<?> root, Class<?> superClass, Method implementation)
      Find the by a method implementation overridden superclass method.
      Parameters:
      root - The root class of the class hierarchy.
      superClass - The containing class of the overridden method in the class hierarchy.
      implementation - The method implementation.
      Returns:
      The overridden method.
    • 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 - type
      Returns:
      null if there is no type parameter
    • isGenericTypeInstanceOf

      public static boolean isGenericTypeInstanceOf(Class<?> c, Type type)
      Checks that the given class, c, is the generic type of the given type.
      Parameters:
      c - the class the type is checked against
      type - the type to check
      Returns:
      true if the type is not null and is assignable from the class
      See Also:
    • 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 - root class
      typeVariable - type variable
      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 - class
      interfaceToFind - interface to find
      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 - root class
      searchedFor - searched class
      Returns:
      for generic class/interface returns array of real types
    • findClassParameterizedTypes

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

      public static Map<TypeVariable<?>,Type> populateParameterizedMap(Class<?> root, Class<?> superClass)
      Create a mapping for generic types to actual types between two classes / interfaces of a type hierarchy.
      Parameters:
      root - The root class / interface of the type hierarchy.
      superClass - A superclass / interface of the type hierarchy.
      Returns:
      The Mapping for generic types to actual types.
    • findInterfaceParameterizedTypes

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

      public static Type boxPrimitives(Type genericType)
    • hasPostConstruct

      public static boolean hasPostConstruct(Class<?> clazz)
    • hasPostConstruct

      public static boolean hasPostConstruct(Class<?> clazz, Function<Method,Boolean> validateParameterCount)