Package com.tngtech.archunit.core.domain

Class JavaTypeVariable<OWNER extends HasDescription>

java.lang.Object
com.tngtech.archunit.core.domain.JavaTypeVariable<OWNER>
All Implemented Interfaces:
JavaType, HasName, HasOwner<OWNER>, HasUpperBounds
@PublicAPI(usage=ACCESS)
public final class JavaTypeVariable<OWNER extends HasDescription>
extends java.lang.Object
implements JavaType, HasOwner<OWNER>, HasUpperBounds
Represents a type variable used by generic types and members.
E.g. class MyClass<T> would have one JavaTypeVariable with name "T" and unbound, i.e. only bound by Object.
A type variable can have several bounds, where only one bound may be a class bound while all further bounds must be interfaces (compare the JLS).
Example: class MyClass<T extends SomeClass & SomeInterfaceOne & SomeInterfaceTwo> would declare one JavaTypeVariable T which is bound by SomeClass, SomeInterfaceOne and SomeInterfaceTwo. I.e. any concrete class substituted for the type variable must extend SomeClass and implement SomeInterfaceOne and SomeInterfaceTwo.

  • Method Details

    • getName

      @PublicAPI(usage=ACCESS) public java.lang.String getName()
      Specified by:
      getName in interface HasName
      Returns:
      The name of this JavaTypeVariable, e.g. for class MyClass<T> the name would be "T"

    • getGenericDeclaration

      @PublicAPI(usage=ACCESS) public OWNER getGenericDeclaration()
      This method is simply an alias for getOwner() that is more familiar to users of the Java Reflection API.
      See Also:
      TypeVariable.getGenericDeclaration()

    • getOwner

      public OWNER getOwner()
      Specified by:
      getOwner in interface HasOwner<OWNER extends HasDescription>
      Returns:
      The 'owner' of this type parameter, i.e. the Java object that declared this TypeVariable as a type parameter. For type parameter T of SomeClass<T> this would be the JavaClass representing SomeClass

    • getBounds

      @PublicAPI(usage=ACCESS) public java.util.List<JavaType> getBounds()
      This method is simply an alias for getUpperBounds() that is more familiar to users of the Java Reflection API.
      See Also:
      TypeVariable.getBounds()

    • getUpperBounds

      @PublicAPI(usage=ACCESS) public java.util.List<JavaType> getUpperBounds()
      Specified by:
      getUpperBounds in interface HasUpperBounds
      Returns:
      All upper bounds of this JavaTypeVariable, i.e. super types any substitution of this variable must extend. E.g. for class MyClass<T extends SomeClass & SomeInterface> the upper bounds would be SomeClass and SomeInterface

    • 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