java.lang.Object
- org.apache.bval.util.reflection.TypeUtils

```
public class TypeUtils
extends Object
```
Taken from commons-lang3.
Utility methods focusing on type inspection, particularly with regard to generics.

Since:

1.1.2

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class TypeUtils.WildcardTypeBuilder
WildcardType builder.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static boolean`	`containsTypeVariables(Type type)`	Learn, recursively, whether any of the type parameters associated with `type` are bound to variables.
`static boolean`	`equals(Type t1, Type t2)`	Check equality of types.
`static Type`	`getArrayComponentType(Type type)`	Get the array component type of `type`.
`static Type[]`	`getImplicitBounds(TypeVariable<?> typeVariable)`	Returns an array containing the sole type of `Object` if `TypeVariable.getBounds()` returns an empty array.
`static Type[]`	`getImplicitLowerBounds(WildcardType wildcardType)`	Returns an array containing a single value of `null` if `WildcardType.getLowerBounds()` returns an empty array.
`static Type[]`	`getImplicitUpperBounds(WildcardType wildcardType)`	Returns an array containing the sole value of `Object` if `WildcardType.getUpperBounds()` returns an empty array.
`static Class<?>`	`getRawType(Type type, Type assigningType)`	Get the raw type of a Java type, given its context.
`static Map<TypeVariable<?>,Type>`	`getTypeArguments(ParameterizedType type)`	Retrieves all the type arguments for this parameterized type including owner hierarchy arguments such as `Outer<K,V>.Inner<T>.DeepInner<E>` .
`static Map<TypeVariable<?>,Type>`	`getTypeArguments(Type type, Class<?> toClass)`	Gets the type arguments of a class/interface based on a subtype.
`static boolean`	`isArrayType(Type type)`	Learn whether the specified type denotes an array type.
`static boolean`	`isAssignable(Type type, Type toType)`	Checks if the subject type may be implicitly cast to the target type following the Java generics rules.
`static boolean`	`isInstance(Object value, Type type)`	Checks if the given value can be assigned to the target type following the Java generics rules.
`static Type[]`	`normalizeUpperBounds(Type[] bounds)`	This method strips out the redundant upper bound types in type variable types and wildcard types (or it would with wildcard types if multiple upper bounds were allowed).
`static ParameterizedType`	`parameterizeWithOwner(Type owner, Class<?> raw, Type... typeArguments)`	Create a parameterized type instance.
`static String`	`toString(Type type)`	Present a given type as a Java-esque String.
`static Type`	`unrollVariables(Map<TypeVariable<?>,Type> typeArguments, Type type)`	Get a type representing `type` with variable assignments "unrolled."
`static TypeUtils.WildcardTypeBuilder`	`wildcardType()`	Get a `TypeUtils.WildcardTypeBuilder`.

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

- Method Detail
  - isAssignable
```
public static boolean isAssignable(Type type,
                                   Type toType)
```
    Checks if the subject type may be implicitly cast to the target type following the Java generics rules. If both types are Class objects, the method returns the result of Class.isAssignableFrom(Class).
    
    Parameters:
    
    type - the subject type to be assigned to the target type
    
    toType - the target type
    
    Returns:
    
    true if type is assignable to toType.
  - getTypeArguments
```
public static Map<TypeVariable<?>,Type> getTypeArguments(ParameterizedType type)
```
    Retrieves all the type arguments for this parameterized type including owner hierarchy arguments such as Outer<K,V>.Inner<T>.DeepInner<E> . The arguments are returned in a Map specifying the argument type for each TypeVariable.
    
    Parameters:
    
    type - specifies the subject parameterized type from which to harvest the parameters.
    
    Returns:
    
    a Map of the type arguments to their respective type variables.
  - getTypeArguments
```
public static Map<TypeVariable<?>,Type> getTypeArguments(Type type,
                                                               Class<?> toClass)
```
    Gets the type arguments of a class/interface based on a subtype. For instance, this method will determine that both of the parameters for the interface Map are Object for the subtype Properties even though the subtype does not directly implement the Map interface.
    
    This method returns null if type is not assignable to toClass. It returns an empty map if none of the classes or interfaces in its inheritance hierarchy specify any type arguments.
    
    A side effect of this method is that it also retrieves the type arguments for the classes and interfaces that are part of the hierarchy between type and toClass. So with the above example, this method will also determine that the type arguments for Hashtable are also both Object. In cases where the interface specified by toClass is (indirectly) implemented more than once (e.g. where toClass specifies the interface Iterable and type specifies a parameterized type that implements both Set and Collection), this method will look at the inheritance hierarchy of only one of the implementations/subclasses; the first interface encountered that isn't a subinterface to one of the others in the type to toClass hierarchy.
    
    Parameters:
    
    type - the type from which to determine the type parameters of toClass
    
    toClass - the class whose type parameters are to be determined based on the subtype type
    
    Returns:
    
    a Map of the type assignments for the type variables in each type in the inheritance hierarchy from type to toClass inclusive.
  - isInstance
```
public static boolean isInstance(Object value,
                                 Type type)
```
    Checks if the given value can be assigned to the target type following the Java generics rules.
    
    Parameters:
    
    value - the value to be checked
    
    type - the target type
    
    Returns:
    
    true if value is an instance of type.
  - normalizeUpperBounds
```
public static Type[] normalizeUpperBounds(Type[] bounds)
```
    This method strips out the redundant upper bound types in type variable types and wildcard types (or it would with wildcard types if multiple upper bounds were allowed).
    
    Example, with the variable type declaration:
    <K extends java.util.Collection<String> & java.util.List<String>>
    
    since List is a subinterface of Collection, this method will return the bounds as if the declaration had been:
    
    <K extends java.util.List<String>>
    Parameters:
    
    bounds - an array of types representing the upper bounds of either WildcardType or TypeVariable, not null.
    
    Returns:
    
    an array containing the values from bounds minus the redundant types.
  - getImplicitBounds
```
public static Type[] getImplicitBounds(TypeVariable<?> typeVariable)
```
    Returns an array containing the sole type of Object if TypeVariable.getBounds() returns an empty array. Otherwise, it returns the result of TypeVariable.getBounds() passed into normalizeUpperBounds(java.lang.reflect.Type[]).
    
    Parameters:
    
    typeVariable - the subject type variable, not null
    
    Returns:
    
    a non-empty array containing the bounds of the type variable.
  - getImplicitUpperBounds
```
public static Type[] getImplicitUpperBounds(WildcardType wildcardType)
```
    Returns an array containing the sole value of Object if WildcardType.getUpperBounds() returns an empty array. Otherwise, it returns the result of WildcardType.getUpperBounds() passed into normalizeUpperBounds(java.lang.reflect.Type[]).
    
    Parameters:
    
    wildcardType - the subject wildcard type, not null
    
    Returns:
    
    a non-empty array containing the upper bounds of the wildcard type.
  - getImplicitLowerBounds
```
public static Type[] getImplicitLowerBounds(WildcardType wildcardType)
```
    Returns an array containing a single value of null if WildcardType.getLowerBounds() returns an empty array. Otherwise, it returns the result of WildcardType.getLowerBounds().
    
    Parameters:
    
    wildcardType - the subject wildcard type, not null
    
    Returns:
    
    a non-empty array containing the lower bounds of the wildcard type.
  - getRawType
```
public static Class<?> getRawType(Type type,
                                  Type assigningType)
```
    Get the raw type of a Java type, given its context. Primarily for use with TypeVariables and GenericArrayTypes, or when you do not know the runtime type of type: if you know you have a Class instance, it is already raw; if you know you have a ParameterizedType, its raw type is only a method call away.
    
    Parameters:
    
    type - to resolve
    
    assigningType - type to be resolved against
    
    Returns:
    
    the resolved Class object or null if the type could not be resolved
  - isArrayType
```
public static boolean isArrayType(Type type)
```
    Learn whether the specified type denotes an array type.
    
    Parameters:
    
    type - the type to be checked
    
    Returns:
    
    true if type is an array class or a GenericArrayType.
  - getArrayComponentType
```
public static Type getArrayComponentType(Type type)
```
    Get the array component type of type.
    
    Parameters:
    
    type - the type to be checked
    
    Returns:
    
    component type or null if type is not an array type
  - unrollVariables
```
public static Type unrollVariables(Map<TypeVariable<?>,Type> typeArguments,
                                   Type type)
```
    Get a type representing type with variable assignments "unrolled."
    
    Parameters:
    
    typeArguments - as from getTypeArguments(Type, Class)
    
    type - the type to unroll variable assignments for
    
    Returns:
    
    Type
  - containsTypeVariables
```
public static boolean containsTypeVariables(Type type)
```
    Learn, recursively, whether any of the type parameters associated with type are bound to variables.
    
    Parameters:
    
    type - the type to check for type variables
    
    Returns:
    
    boolean
  - parameterizeWithOwner
```
public static final ParameterizedType parameterizeWithOwner(Type owner,
                                                            Class<?> raw,
                                                            Type... typeArguments)
```
    Create a parameterized type instance.
    
    Parameters:
    
    owner - the owning type
    
    raw - the raw class to create a parameterized type instance for
    
    typeArguments - the types used for parameterization
    
    Returns:
    
    ParameterizedType
  - wildcardType
```
public static TypeUtils.WildcardTypeBuilder wildcardType()
```
    Get a TypeUtils.WildcardTypeBuilder.
    
    Returns:
    
    TypeUtils.WildcardTypeBuilder
  - equals
```
public static boolean equals(Type t1,
                             Type t2)
```
    Check equality of types.
    
    Parameters:
    
    t1 - the first type
    
    t2 - the second type
    
    Returns:
    
    boolean
  - toString
```
public static String toString(Type type)
```
    Present a given type as a Java-esque String.
    
    Parameters:
    
    type - the type to create a String representation for, not null
    
    Returns:
    
    String

Class TypeUtils

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

isAssignable

getTypeArguments

getTypeArguments

isInstance

normalizeUpperBounds

getImplicitBounds

getImplicitUpperBounds

getImplicitLowerBounds

getRawType

isArrayType

getArrayComponentType

unrollVariables

containsTypeVariables

parameterizeWithOwner

wildcardType

equals

toString