Package net.jqwik.api.providers

Interface TypeUsage

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

  • Field Details

    • OBJECT_TYPE

      @API(status=INTERNAL) static final TypeUsage OBJECT_TYPE

  • Method Details

    • of

      static TypeUsage of(Class<?> type, TypeUsage... typeParameters)

    • wildcard

      static TypeUsage wildcard(TypeUsage upperBound)

    • forType

      static TypeUsage forType(Type type)

    • getRawType

      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

      List<TypeUsage> getUpperBounds()
      Return upper bounds if a generic type is a wildcard or type variable. TypeUsage.of(Object.class) is always included.

    • getLowerBounds

      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

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

      List<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 Annotation> Optional<A> findAnnotation(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 Annotation> boolean isAnnotated(Class<A> annotationType)
      Return true if the current instance is annotated (directly or indirectly through meta-annotations) with a specific annotationType.

    • isAssignableFrom

      boolean isAssignableFrom(Class<?> providedClass)
      Check if a given providedClass is assignable from this generic type.

    • getComponentType

      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") Optional<TypeUsage> getSuperclass()
      Return superclass of this type. With all type variables resolved.

    • getSuperTypes

      @API(status=EXPERIMENTAL, since="1.8.0") List<TypeUsage> getSuperTypes()
      List of superclass and interfaces. With all type variables resolved.

    • getInterfaces

      @API(status=EXPERIMENTAL, since="1.2.0") List<TypeUsage> getInterfaces()
      Return interfaces of this type. With all type variables resolved.

    • getType

      @API(status=INTERNAL, since="1.2.0") Type getType()

    • getAnnotatedType

      @API(status=INTERNAL, since="1.2.0") 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.

    • isParameterizedRaw

      @API(status=EXPERIMENTAL, since="1.8.0") boolean isParameterizedRaw()
      Return true if it is a parameterized type with no parameters, e.g. List.

    • isSuperWildcard

      @API(status=EXPERIMENTAL, since="1.8.0") boolean isSuperWildcard()
      Return true if it is a wildcard with super constraint, e.g. ? super String.

    • isExtendsConstraint

      @API(status=EXPERIMENTAL, since="1.8.0") boolean isExtendsConstraint()
      Return true if it is a wildcard with extends constraint, e.g. ? extends String.

    • 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") String getTypeVariable()

    • withAnnotation

      @API(status=EXPERIMENTAL, since="1.6.0") <A extends Annotation> TypeUsage withAnnotation(A annotation)
      Return type usage object with additional annotation

    • getMetaInfo

      @API(status=EXPERIMENTAL, since="1.6.0") Optional<Object> getMetaInfo(String key)
      Get meta info for a certain key

    • withMetaInfo

      @API(status=EXPERIMENTAL, since="1.6.0") TypeUsage withMetaInfo(String key, Object value)
      Return type usage object with additional meta info

    • hasSameTypeAs

      @API(status=EXPERIMENTAL, since="1.9.0") boolean hasSameTypeAs(TypeUsage other)
      Check for type equality, ie do not consider annotations.