Package com.tngtech.archunit.core.domain

Class JavaWildcardType

java.lang.Object
com.tngtech.archunit.core.domain.JavaWildcardType
All Implemented Interfaces:
JavaType, HasName, HasUpperBounds
@PublicAPI(usage=ACCESS) public final class JavaWildcardType extends 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 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 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 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

    • getAllInvolvedRawTypes

      public Set<JavaClass> getAllInvolvedRawTypes()
      Description copied from interface: JavaType
      Returns the set of all raw types that are involved in this type. If this type is a JavaClass, then this method trivially returns only the class itself. If this type is a JavaParameterizedType, JavaTypeVariable, JavaWildcardType, etc., then this method returns all raw types involved in type arguments and upper and lower bounds recursively. If this type is an array type, then this method returns all raw types involved in the component type of the array type.

      Examples:
      For the parameterized type 
      
 List<String>
      the result would be the classes [List, String].
      For the parameterized type 
      
 Map<? extends Serializable, List<? super Integer[]>>
      the result would be [Map, Serializable, List, Integer].
      And for the type variable 
      
 T extends List<? super Integer>
      the result would be [List, Integer].
      Thus, this method offers a quick way to determine all types a (possibly complex) type depends on.
      Specified by:
      getAllInvolvedRawTypes in interface JavaType
      Returns:
      All raw types involved in this JavaType

    • toString

      public String toString()
      Overrides:
      toString in class Object