```
@API(status=MAINTAINED,
     since="1.0")
public interface TypeUsage
```
An instance of TypeUsage describes the information available for parameter or return types. The class is supposed to relieve its users from all the intricacies of the Java reflection API. Doing that it will resolve meta annotations, repeated annotations as well as annotated type parameters.
TypeUsage provides access to:
- the native type of an object
- the component type (if it's an array)
- the type parameters (again as instances of TypeUsage)
- the annotations (if the object is derived from a parameter)
- methods to test for compatibility of types that do also handle compatibility between raw types and boxed type
Within the public API TypeUsage is used in two places:
- @see ArbitraryProvider
- @see Arbitraries.defaultFor(Class, Class[])

Nested Class Summary

Nested Classes
Modifier and Type	Interface	Description
`static interface`	`TypeUsage.Enhancer`	Enhancers can manipulate the perceived type of parameters.
`static class`	`TypeUsage.TypeUsageFacade`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`TypeUsage`	`asNotNullable()`	Return type usage object with just nullablity set to false
`TypeUsage`	`asNullable()`	Return type usage object with just nullablity set to true
`boolean`	`canBeAssignedTo(TypeUsage targetType)`	Check if an instance can be assigned to another `TypeUsage` instance.
`<A extends java.lang.annotation.Annotation> java.util.Optional<A>`	`findAnnotation(java.lang.Class<A> annotationType)`	Return an `Optional` of the first instance of a specific `annotationType` if there is one (directly or indirectly through meta-annotations).
`static TypeUsage`	`forType(java.lang.reflect.Type type)`
`java.lang.reflect.AnnotatedType`	`getAnnotatedType()`
`java.util.List<java.lang.annotation.Annotation>`	`getAnnotations()`	Return all annotations of a parameter (or an annotated type argument).
`java.util.Optional<TypeUsage>`	`getComponentType()`	Return an `Optional` of an array's component type - if it is an array.
`java.util.List<TypeUsage>`	`getInterfaces()`	Return interfaces of this type.
`java.util.List<TypeUsage>`	`getLowerBounds()`	Return lower bounds if a generic type is a wildcard.
`java.util.Optional<java.lang.Object>`	`getMetaInfo(java.lang.String key)`	Get meta info for a certain key
`java.lang.Class<?>`	`getRawType()`	Return the raw type which is usually the class or interface you see in a parameters or return values specification.
`java.util.Optional<TypeUsage>`	`getSuperclass()`	Return superclass of this type.
`java.lang.reflect.Type`	`getType()`
`TypeUsage`	`getTypeArgument(int position)`	Return the type argument at a specific position.
`java.util.List<TypeUsage>`	`getTypeArguments()`	Return the type arguments of a generic type in the order of there appearance in a type's declaration.
`java.lang.String`	`getTypeVariable()`
`java.util.List<TypeUsage>`	`getUpperBounds()`	Return upper bounds if a generic type is a wildcard or type variable.
`<A extends java.lang.annotation.Annotation> boolean`	`isAnnotated(java.lang.Class<A> annotationType)`	Return true if the current instance is annotated (directly or indirectly through meta-annotations) with a specific `annotationType`.
`boolean`	`isArray()`	Return true if a type is an array type.
`boolean`	`isAssignableFrom(java.lang.Class<?> providedClass)`	Check if a given `providedClass` is assignable from this generic type.
`boolean`	`isEnum()`	Return true if a type is an `enum` type.
`boolean`	`isGeneric()`	Return true if a type has any type arguments itself.
`boolean`	`isNullable()`	Return optional true if this type is nullable.
`boolean`	`isOfType(java.lang.Class<?> aRawType)`	Check if an instance is of a specific raw type
`boolean`	`isTypeVariable()`	Return true if a generic type is a wildcard.
`boolean`	`isTypeVariableOrWildcard()`	Return true if a generic type is a type variable or a wildcard.
`boolean`	`isVoid()`	Return true if type is Void.
`boolean`	`isWildcard()`	Return true if a generic type is a wildcard.
`static TypeUsage`	`of(java.lang.Class<?> type, TypeUsage... typeParameters)`
`static TypeUsage`	`wildcard(TypeUsage upperBound)`
`<A extends java.lang.annotation.Annotation> TypeUsage`	`withAnnotation(A annotation)`	Return type usage object with additional annotation
`TypeUsage`	`withMetaInfo(java.lang.String key, java.lang.Object value)`	Return type usage object with additional meta info

- Method Detail
  - of
```
static TypeUsage of(java.lang.Class<?> type,
                    TypeUsage... typeParameters)
```
  - wildcard
```
static TypeUsage wildcard(TypeUsage upperBound)
```
  - forType
```
static TypeUsage forType(java.lang.reflect.Type type)
```
  - getRawType
```
java.lang.Class<?> getRawType()
```
    Return the raw type which is usually the class or interface you see in a parameters or return values specification.
    A raw type always exists.
  - getUpperBounds
```
java.util.List<TypeUsage> getUpperBounds()
```
    Return upper bounds if a generic type is a wildcard or type variable. TypeUsage.of(Object.class) is always included.
  - getLowerBounds
```
java.util.List<TypeUsage> getLowerBounds()
```
    Return lower bounds if a generic type is a wildcard.
  - isWildcard
```
boolean isWildcard()
```
    Return true if a generic type is a wildcard.
  - isTypeVariable
```
boolean isTypeVariable()
```
    Return true if a generic type is a wildcard.
  - isTypeVariableOrWildcard
```
boolean isTypeVariableOrWildcard()
```
    Return true if a generic type is a type variable or a wildcard.
  - getTypeArguments
```
java.util.List<TypeUsage> getTypeArguments()
```
    Return the type arguments of a generic type in the order of there appearance in a type's declaration.
  - getTypeArgument
```
TypeUsage getTypeArgument(int position)
```
    Return the type argument at a specific position.
  - isOfType
```
boolean isOfType(java.lang.Class<?> aRawType)
```
    Check if an instance is of a specific raw type
    Most of the time this is what you want to do when checking for applicability of a ArbitraryProvider.
  - canBeAssignedTo
```
boolean canBeAssignedTo(TypeUsage targetType)
```
    Check if an instance can be assigned to another TypeUsage instance.
  - isGeneric
```
boolean isGeneric()
```
    Return true if a type has any type arguments itself.
  - isEnum
```
boolean isEnum()
```
    Return true if a type is an enum type.
  - isArray
```
boolean isArray()
```
    Return true if a type is an array type.
  - getAnnotations
```
java.util.List<java.lang.annotation.Annotation> getAnnotations()
```
    Return all annotations of a parameter (or an annotated type argument).
    This list already contains all meta annotations, repeated annotations and annotations from annotated type arguments. Thus, it does much more than the usual Java reflection API.
  - findAnnotation
```
<A extends java.lang.annotation.Annotation> java.util.Optional<A> findAnnotation(java.lang.Class<A> annotationType)
```
    Return an Optional of the first instance of a specific annotationType if there is one (directly or indirectly through meta-annotations).
  - isAnnotated
```
<A extends java.lang.annotation.Annotation> boolean isAnnotated(java.lang.Class<A> annotationType)
```
    Return true if the current instance is annotated (directly or indirectly through meta-annotations) with a specific annotationType.
  - isAssignableFrom
```
boolean isAssignableFrom(java.lang.Class<?> providedClass)
```
    Check if a given providedClass is assignable from this generic type.
  - getComponentType
```
java.util.Optional<TypeUsage> getComponentType()
```
    Return an Optional of an array's component type - if it is an array.
  - isVoid
```
@API(status=EXPERIMENTAL,
     since="1.2.0")
boolean isVoid()
```
    Return true if type is Void.
  - getSuperclass
```
@API(status=EXPERIMENTAL,
     since="1.2.0")
java.util.Optional<TypeUsage> getSuperclass()
```
    Return superclass of this type.
  - getInterfaces
```
@API(status=EXPERIMENTAL,
     since="1.2.0")
java.util.List<TypeUsage> getInterfaces()
```
    Return interfaces of this type.
  - getType
```
@API(status=INTERNAL,
     since="1.2.0")
java.lang.reflect.Type getType()
```
  - getAnnotatedType
```
@API(status=INTERNAL,
     since="1.2.0")
java.lang.reflect.AnnotatedType getAnnotatedType()
```
  - isNullable
```
@API(status=EXPERIMENTAL,
     since="1.6.0")
boolean isNullable()
```
    Return optional true if this type is nullable.
    Plain Java types are never nullable. Nullability must be set explicitly using asNullable(). This is usually done in registered enhancers.
  - asNullable
```
@API(status=EXPERIMENTAL,
     since="1.6.0")
TypeUsage asNullable()
```
    Return type usage object with just nullablity set to true
  - asNotNullable
```
@API(status=EXPERIMENTAL,
     since="1.6.0")
TypeUsage asNotNullable()
```
    Return type usage object with just nullablity set to false
  - getTypeVariable
```
@API(status=EXPERIMENTAL,
     since="1.6.0")
java.lang.String getTypeVariable()
```
  - withAnnotation
```
@API(status=EXPERIMENTAL,
     since="1.6.0")
<A extends java.lang.annotation.Annotation> TypeUsage withAnnotation(A annotation)
```
    Return type usage object with additional annotation
  - getMetaInfo
```
@API(status=EXPERIMENTAL,
     since="1.6.0")
java.util.Optional<java.lang.Object> getMetaInfo(java.lang.String key)
```
    Get meta info for a certain key
  - withMetaInfo
```
@API(status=EXPERIMENTAL,
     since="1.6.0")
TypeUsage withMetaInfo(java.lang.String key,
                       java.lang.Object value)
```
    Return type usage object with additional meta info

Interface TypeUsage

Nested Class Summary

Method Summary

Method Detail

of

wildcard

forType

getRawType

getUpperBounds

getLowerBounds

isWildcard

isTypeVariable

isTypeVariableOrWildcard

getTypeArguments

getTypeArgument

isOfType

canBeAssignedTo

isGeneric

isEnum

isArray

getAnnotations

findAnnotation

isAnnotated

isAssignableFrom

getComponentType

isVoid

getSuperclass

getInterfaces

getType

getAnnotatedType

isNullable

asNullable

asNotNullable

getTypeVariable

withAnnotation

getMetaInfo

withMetaInfo