Package com.tngtech.archunit.core.domain

Class JavaWildcardType

java.lang.Object
com.tngtech.archunit.core.domain.JavaWildcardType
All Implemented Interfaces:
JavaType, HasName, HasUpperBounds
public class JavaWildcardType
extends java.lang.Object
implements JavaType, HasUpperBounds
Represents a wildcard type in a type signature (compare the JLS). Consider the generic type List<T>, then the parameterized type List<?> would have the wildcard ? as its type argument (also see JavaParameterizedType).
According to the JLS a wildcard may have upper and lower bounds.
An upper bound denotes a common supertype any substitution of this wildcard must be assignable to. It is denoted by ? extends SomeType.
A lower bound denotes a common subtype that must be assignable to all substitutions of this wildcard type. It is denoted by ? super SomeType.

  • Method Details

    • getName

      @PublicAPI(usage=ACCESS) public java.lang.String getName()
      Specified by:
      getName in interface HasName
      Returns:
      The name of this JavaWildcardType, which is always "?", followed by the respective bounds if any are present (e.g. "? extends java.lang.String")

    • getUpperBounds

      @PublicAPI(usage=ACCESS) public java.util.List<JavaType> getUpperBounds()
      Specified by:
      getUpperBounds in interface HasUpperBounds
      Returns:
      All upper bounds of this JavaWildcardType, i.e. supertypes any substitution of this variable must extend. E.g. for List<? extends SomeClass> the upper bounds would be [SomeClass]
      Note that the JLS currently only allows a single upper bound for a wildcard type, but we follow the Reflection API here and support a collection (compare WildcardType.getUpperBounds()).

    • getLowerBounds

      @PublicAPI(usage=ACCESS) public java.util.List<JavaType> getLowerBounds()
      Returns:
      All lower bounds of this JavaWildcardType, i.e. any substitution for this JavaWildcardType must be a supertype of all lower bounds. E.g. for Handler<? super SomeClass>> the lower bounds would be [SomeClass].
      Note that the JLS currently only allows a single lower bound for a wildcard type, but we follow the Reflection API here and support a collection (compare WildcardType.getLowerBounds()).

    • toErasure

      @PublicAPI(usage=ACCESS) public JavaClass toErasure()
      Description copied from interface: JavaType
      Converts this JavaType into the erased type (compare the Java Language Specification). In particular this will result in
      • the class itself, if this type is a JavaClass
      • the JavaClass equivalent to Object, if this type is an unbound JavaTypeVariable
      • the JavaClass equivalent to the erasure of the left most bound, if this type is a bound JavaTypeVariable
      • if this type is a JavaGenericArrayType, the erasure will be the JavaClass equivalent to the array type that has the erasure of the generic component type of this type as its component type; e.g. take the generic array type T[][] where T is unbound, then the erasure will be the array type Object[][]
      Specified by:
      toErasure in interface JavaType

    • toString

      public java.lang.String toString()
      Overrides:
      toString in class java.lang.Object