ClassOrInterfaceType (randoop 4.3.4 API)

java.lang.Object
- randoop.types.Type
- - randoop.types.ReferenceType
  - - randoop.types.ClassOrInterfaceType

All Implemented Interfaces:

java.lang.Comparable<Type>

Direct Known Subclasses:

NonParameterizedType, ParameterizedType
```
public abstract class ClassOrInterfaceType
extends ReferenceType
```
Represents a class or interface type as defined in JLS Section 4.3.
This abstract class corresponds to this grammar production in the JLS:
```
   ClassOrInterfaceType:
     ClassType
     InterfaceType
 
```
InterfaceType is syntactically the same as ClassType. Therefore, ClassType and InterfaceType do not exist as subclasses of this class, Rather, the subclasses of this type distinguish between types with parameters (ParameterizedType), and types without (NonParameterizedType).

Field Summary

Fields
Modifier and Type	Field and Description
`private static boolean`	`debug` Set to true to enable debug output to standard out.
`protected @Nullable ClassOrInterfaceType`	`enclosingType` The enclosing type.

Constructor Summary

Constructors
Constructor and Description

ClassOrInterfaceType()

Constructors
Constructor and Description
`ClassOrInterfaceType()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract ClassOrInterfaceType`	`applyCaptureConversion()` Applies a capture conversion to this type.
`(package private) ClassOrInterfaceType`	`applyCaptureConversion(ClassOrInterfaceType type)` Applies capture conversion to the enclosing type of this type and adds the result as the enclosing class of the given type.
`boolean`	`equals(@Nullable java.lang.Object obj)`
`static ClassOrInterfaceType`	`forClass(java.lang.Class<?> classType)` Translates a `Class` object that represents a class or interface into a `ClassOrInterfaceType` object.
`static ClassOrInterfaceType`	`forType(java.lang.reflect.Type type)` Creates a `ClassOrInterfaceType` object for a given `java.lang.reflect.Type` reference.
`java.util.Collection<ClassOrInterfaceType>`	`getAllSupertypesInclusive()` Return all supertypes of this type, including itself.
`java.lang.String`	`getBinaryName()` Returns the binary name of this type, including type arguments if this is a parameterized type (so, it isn't really a binary name).
`@Nullable java.lang.String`	`getCanonicalName()` Returns the name of this type as the "canonical name" of the underlying runtime class.
`java.lang.String`	`getFqName()` Returns the fully-qualified name of this type, including type arguments if this is a parameterized type.
`java.util.List<ClassOrInterfaceType>`	`getImmediateSupertypes()` Return the immediate supertypes of this type.
`@Nullable Substitution`	`getInstantiatingSubstitution(ReferenceType goalType)` Computes a substitution that can be applied to the type variables of the generic goal type to instantiate operations of this type, possibly inherited from from the goal type.
`abstract java.util.List<ClassOrInterfaceType>`	`getInterfaces()` Returns the interface types directly implemented by this class or interface type.
`@Nullable InstantiatedType`	`getMatchingSupertype(GenericClassType goalType)` Finds the parameterized type that is a supertype of this class that also matches the given generic class.
`@Nullable java.lang.Package`	`getPackage()` Returns the package of the runtime class of this type.
`(package private) java.lang.String`	`getPackagePrefix()` Return the package part of a type name, including the final period.
`abstract NonParameterizedType`	`getRawtype()` Returns the non-parameterized form of this class type.
`java.lang.String`	`getSimpleName()` Returns the name of this class type.
`abstract ClassOrInterfaceType`	`getSuperclass()` Return the type for the superclass for this class.
`java.util.Collection<ClassOrInterfaceType>`	`getSuperTypes()` Return the set of all of the supertypes of this type.
`java.util.List<TypeArgument>`	`getTypeArguments()` Returns the type arguments for this type.
`java.util.List<TypeVariable>`	`getTypeParameters()` Returns the list of type parameters for this type.
`java.lang.String`	`getUnqualifiedBinaryName()` Returns the name of this type without package name, but with type arguments if parameterized, and enclosing class if a member class.
`boolean`	`hasCaptureVariable()` Indicates whether this `ReferenceType` has a capture variable.
`int`	`hashCode()`
`boolean`	`hasWildcard()` Indicates whether this type has a wildcard anywhere within it.
`abstract boolean`	`isAbstract()` Indicate whether this class is abstract.
`boolean`	`isClassOrInterfaceType()` Indicate whether this type is a class or interface type.
`boolean`	`isGeneric(boolean ignoreWildcards)` Indicate whether this type is generic.
`boolean`	`isInstantiationOf(ReferenceType otherType)` Indicates whether this type is an instantiation of a more general type.
`boolean`	`isMemberClass()` Indicate whether this class is a member of another class.
`boolean`	`isNestedClass()` Indicate whether this class is a nested class.
`boolean`	`isParameterized()` Indicate whether this type is a parameterized type.
`abstract boolean`	`isStatic()` Indicates whether this class is static.
`boolean`	`isSubtypeOf(Type otherType)` Test whether this type is a subtype of the given type according to transitive closure of definition of the direct supertype relation in section 4.10.2 of JLS for JavaSE 8.
`abstract ClassOrInterfaceType`	`substitute(Substitution substitution)` Applies a substitution to a `ReferenceType`.
`(package private) ClassOrInterfaceType`	`substitute(Substitution substitution, ClassOrInterfaceType type)` Applies the substitution to the enclosing type of this type and adds the result as the enclosing class of the given type.

Methods inherited from class randoop.types.ReferenceType
getInstantiatingSubstitutionforTypeVariable, isAssignableFrom, isCaptureVariable, isReferenceType

Methods inherited from class randoop.types.Type
compareTo, forFullyQualifiedName, forName, forValue, getRuntimeClass, getTypeforFullyQualifiedName, isArray, isAssignableFromTypeOf, isBoxedPrimitive, isClass, isEnum, isGeneric, isInterface, isNonreceiverType, isObject, isPrimitive, isRawtype, isString, isVariable, isVoid, runtimeClassIs, toString

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - debug
```
private static boolean debug
```
    Set to true to enable debug output to standard out.
  - enclosingType
```
protected @Nullable ClassOrInterfaceType enclosingType
```
    The enclosing type. Non-null only if this is a nested type (either a member type or a nested static type).
- Constructor Detail
  - ClassOrInterfaceType
```
public ClassOrInterfaceType()
```
- Method Detail
  - forClass
```
public static ClassOrInterfaceType forClass(java.lang.Class<?> classType)
```
    Translates a Class object that represents a class or interface into a ClassOrInterfaceType object. If the object has parameters, then delegates to ParameterizedType.forClass(Class). Otherwise, creates a NonParameterizedType object from the given object.
    
    Parameters:
    
    classType - the class type to translate
    
    Returns:
    
    the ClassOrInterfaceType object created from the given class type
  - forType
```
public static ClassOrInterfaceType forType(java.lang.reflect.Type type)
```
    Creates a ClassOrInterfaceType object for a given java.lang.reflect.Type reference. If type is a java.lang.reflect.ParameterizedType, then calls ParameterizedType.forType(java.lang.reflect.Type). Otherwise, if type is a Class object, calls forClass(Class).
    
    Parameters:
    
    type - the type reference
    
    Returns:
    
    the ClassOrInterfaceType object for the given type
  - equals
```
public boolean equals(@Nullable java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - substitute
```
public abstract ClassOrInterfaceType substitute(Substitution substitution)
```
    Applies a substitution to a ReferenceType. If the type is parameterized then replaces type variables that occur, otherwise returns this type.
    This abstract method forces typing of substitutions applied to ReferenceType objects without an explicit cast.
    This abstract method allows substitutions to be applied to ClassOrInterfaceType objects without casting.
    
    Specified by:
    
    substitute in class ReferenceType
    
    Parameters:
    
    substitution - the type substitution
    
    Returns:
    
    the type created by applying the substitution to this type
  - substitute
```
final ClassOrInterfaceType substitute(Substitution substitution,
                                      ClassOrInterfaceType type)
```
    Applies the substitution to the enclosing type of this type and adds the result as the enclosing class of the given type.
    
    Parameters:
    
    substitution - the substitution to apply to the enclosing type
    
    type - the type to which resulting enclosing type is to be added; will be side-effected
    
    Returns:
    
    the type with enclosing type added if needed
  - applyCaptureConversion
```
public abstract ClassOrInterfaceType applyCaptureConversion()
```
    Description copied from class: Type
    
    Applies a capture conversion to this type.
    
    Overrides:
    
    applyCaptureConversion in class ReferenceType
    
    Returns:
    
    a copy of this type with wildcards replaced by type conversion
  - applyCaptureConversion
```
final ClassOrInterfaceType applyCaptureConversion(ClassOrInterfaceType type)
```
    Applies capture conversion to the enclosing type of this type and adds the result as the enclosing class of the given type.
    
    Parameters:
    
    type - this type with capture conversion applied; will be side-effected
    
    Returns:
    
    the type with converted enclosing type
  - getSimpleName
```
public java.lang.String getSimpleName()
```
    Returns the name of this class type. Does not include package, enclosing classes, or type arguments.
    
    Specified by:
    
    getSimpleName in class Type
    
    Returns:
    
    the name of this class
  - getCanonicalName
```
public @Nullable java.lang.String getCanonicalName()
```
    Description copied from class: Type
    
    Returns the name of this type as the "canonical name" of the underlying runtime class. Identical to Type.getFqName() except for types with type arguments. For java.util.List<T> returns "java.util.List". Returns null when Class<?>.getCanonicalName() does for the underlying Class<?> object (e.g., the type is a local or anonymous class, or array type where the component type that has no canonical name).
    
    Overrides:
    
    getCanonicalName in class Type
    
    Returns:
    
    the fully-qualified canonical name of this type
  - getFqName
```
public java.lang.String getFqName()
```
    Description copied from class: Type
    
    Returns the fully-qualified name of this type, including type arguments if this is a parameterized type. For java.util.List<T> return "java.util.List<T>".
    
    Specified by:
    
    getFqName in class Type
    
    Returns:
    
    the fully-qualified type name for this type
  - getBinaryName
```
public java.lang.String getBinaryName()
```
    Description copied from class: Type
    
    Returns the binary name of this type, including type arguments if this is a parameterized type (so, it isn't really a binary name). For java.util.List<T> return "java.util.List<T>".
    
    Specified by:
    
    getBinaryName in class Type
    
    Returns:
    
    the binary name for this type
  - getUnqualifiedBinaryName
```
public java.lang.String getUnqualifiedBinaryName()
```
    Description copied from class: Type
    
    Returns the name of this type without package name, but with type arguments if parameterized, and enclosing class if a member class. For instance, for java.util.List<T> would return "List<T>".
    
    Overrides:
    
    getUnqualifiedBinaryName in class Type
    
    Returns:
    
    the unqualified name of this type
  - getInterfaces
```
public abstract java.util.List<ClassOrInterfaceType> getInterfaces()
```
    Returns the interface types directly implemented by this class or interface type. Preserves the order in the reflection method Class.getGenericInterfaces(). If no interfaces are implemented, then returns the empty list.
    
    Returns:
    
    the list of interfaces directly implemented by this type
  - getPackage
```
public @Nullable java.lang.Package getPackage()
```
    Returns the package of the runtime class of this type.
    
    Returns:
    
    the package of the runtime class of this type, or null if there is none
  - getPackagePrefix
```
java.lang.String getPackagePrefix()
```
    Return the package part of a type name, including the final period. Returns the empty string for a type in the unnamed package.
    
    Returns:
    
    the package part of a type name, or ""
  - getRawtype
```
public abstract NonParameterizedType getRawtype()
```
    Returns the non-parameterized form of this class type.
    
    Overrides:
    
    getRawtype in class Type
    
    Returns:
    
    the non-parameterized form of this class type
  - getMatchingSupertype
```
public @Nullable InstantiatedType getMatchingSupertype(GenericClassType goalType)
```
    Finds the parameterized type that is a supertype of this class that also matches the given generic class. For example, if class C<T> implements Comparator<T> and class A extends C<String>, then when applied to A, this method would return C<String> when given C<T>, and Comparator<String> when given Comparator<E>. Returns null if there is no such type.
    Performs a depth-first search of the supertype relation for this type. If the goal type is an interface, then searches the interfaces of this type first.
    
    Parameters:
    
    goalType - the generic class type
    
    Returns:
    
    the instantiated type matching the goal type, or null
  - getInstantiatingSubstitution
```
public @Nullable Substitution getInstantiatingSubstitution(ReferenceType goalType)
```
    Description copied from class: ReferenceType
    
    Computes a substitution that can be applied to the type variables of the generic goal type to instantiate operations of this type, possibly inherited from from the goal type. The substitution will unify this type or a supertype of this type with the given goal type.
    If there is no unifying substitution, returns null.
    
    Overrides:
    
    getInstantiatingSubstitution in class ReferenceType
    
    Parameters:
    
    goalType - the generic type for which a substitution is needed
    
    Returns:
    
    a substitution unifying this type or a supertype of this type with the goal type
  - getSuperclass
```
public abstract ClassOrInterfaceType getSuperclass()
```
    Return the type for the superclass for this class.
    
    Returns:
    
    superclass of this type, or the Object type if this type has no superclass
  - getSuperTypes
```
public java.util.Collection<ClassOrInterfaceType> getSuperTypes()
```
    Return the set of all of the supertypes of this type.
    
    Returns:
    
    the set of all supertypes of this type
  - getImmediateSupertypes
```
public java.util.List<ClassOrInterfaceType> getImmediateSupertypes()
```
    Return the immediate supertypes of this type.
    
    Returns:
    
    the immediate supertypes of this type
  - getAllSupertypesInclusive
```
public java.util.Collection<ClassOrInterfaceType> getAllSupertypesInclusive()
```
    Return all supertypes of this type, including itself.
    
    Returns:
    
    all supertypes of this type, including itself
  - isAbstract
```
public abstract boolean isAbstract()
```
    Indicate whether this class is abstract.
    
    Returns:
    
    true if this class is abstract, false otherwise
  - isGeneric
```
public boolean isGeneric(boolean ignoreWildcards)
```
    Description copied from class: Type
    
    Indicate whether this type is generic. A type is generic if it has one or more type variables.
    
    Overrides:
    
    isGeneric in class Type
    
    Parameters:
    
    ignoreWildcards - if true, ignore wildcards; that is, treat wildcards as not making the operation generic
    
    Returns:
    
    true if this type is generic, false otherwise
  - isInstantiationOf
```
public boolean isInstantiationOf(ReferenceType otherType)
```
    Indicates whether this type is an instantiation of a more general type.
    For a general ReferenceType, this is only true if the other type is the same, or the other type is a type variable for which this type satisfies the bounds. Other cases are handled by the overriding implementations isInstantiationOf(ReferenceType), InstantiatedType.isInstantiationOf(ReferenceType), and TypeVariable.isInstantiationOf(ReferenceType).
    For a ClassOrInterfaceType that is a member class, if otherType is also a member class, then the enclosing type of this type must instantiate the enclosing type of otherType.
    
    Overrides:
    
    isInstantiationOf in class ReferenceType
    
    Parameters:
    
    otherType - the general reference type
    
    Returns:
    
    true if this type instantiates the other reference type, false otherwise
  - isNestedClass
```
public final boolean isNestedClass()
```
    Indicate whether this class is a nested class.
    
    Returns:
    
    true iff this class is a nested class
  - isMemberClass
```
public final boolean isMemberClass()
```
    Indicate whether this class is a member of another class. (see JLS section 8.5).
    
    Returns:
    
    true if this class is a member class, false otherwise
  - isParameterized
```
public boolean isParameterized()
```
    Description copied from class: Type
    
    Indicate whether this type is a parameterized type. A parameterized type is a type C<T1,...,Tk> that instantiates a generic class C<F1,...,Fk>.
    If inputType.isParameterized returns true, there are two possibilities: inputType instanceof InstantiatedType, or inputType is a member class and the enclosing type is a parameterized type
    
    Overrides:
    
    isParameterized in class Type
    
    Returns:
    
    true if this type is a parameterized type, false otherwise
  - isStatic
```
public abstract boolean isStatic()
```
    Indicates whether this class is static.
    
    Returns:
    
    true if this class is static, false otherwise
  - isSubtypeOf
```
public boolean isSubtypeOf(Type otherType)
```
    Test whether this type is a subtype of the given type according to transitive closure of definition of the direct supertype relation in section 4.10.2 of JLS for JavaSE 8.
    
    Overrides:
    
    isSubtypeOf in class ReferenceType
    
    Parameters:
    
    otherType - the possible supertype
    
    Returns:
    
    true if this type is a subtype of the given type, false otherwise
    
    See Also:
    
    ReferenceType.isAssignableFrom(Type), isSubtypeOf(Type)
  - hasWildcard
```
public boolean hasWildcard()
```
    Description copied from class: Type
    
    Indicates whether this type has a wildcard anywhere within it.
    
    Overrides:
    
    hasWildcard in class Type
    
    Returns:
    
    true if this type has a wildcard, false otherwise
  - hasCaptureVariable
```
public boolean hasCaptureVariable()
```
    Description copied from class: Type
    
    Indicates whether this ReferenceType has a capture variable.
    
    Overrides:
    
    hasCaptureVariable in class Type
    
    Returns:
    
    true iff this type has a capture variable
  - getTypeArguments
```
public java.util.List<TypeArgument> getTypeArguments()
```
    Returns the type arguments for this type.
    
    Returns:
    
    the list of type arguments
  - getTypeParameters
```
public java.util.List<TypeVariable> getTypeParameters()
```
    Description copied from class: ReferenceType
    
    Returns the list of type parameters for this type. Reference types that may have type parameters include ArrayType (such as E[]), and subclasses of ParameterizedType.
    
    Overrides:
    
    getTypeParameters in class ReferenceType
    
    Returns:
    
    the type parameters for this type
  - isClassOrInterfaceType
```
public boolean isClassOrInterfaceType()
```
    Description copied from class: Type
    
    Indicate whether this type is a class or interface type.
    
    Overrides:
    
    isClassOrInterfaceType in class Type
    
    Returns:
    
    true if this type is a class or interface type; false, otherwise

Class ClassOrInterfaceType

Field Summary

Constructor Summary

Method Summary

Methods inherited from class randoop.types.ReferenceType

Methods inherited from class randoop.types.Type

Methods inherited from class java.lang.Object

Field Detail

debug

enclosingType

Constructor Detail

ClassOrInterfaceType

Method Detail

forClass

forType

equals

hashCode

substitute

substitute

applyCaptureConversion

applyCaptureConversion

getSimpleName

getCanonicalName

getFqName

getBinaryName

getUnqualifiedBinaryName

getInterfaces

getPackage

getPackagePrefix

getRawtype

getMatchingSupertype

getInstantiatingSubstitution

getSuperclass

getSuperTypes

getImmediateSupertypes

getAllSupertypesInclusive

isAbstract

isGeneric

isInstantiationOf

isNestedClass

isMemberClass

isParameterized

isStatic

isSubtypeOf

hasWildcard

hasCaptureVariable

getTypeArguments

getTypeParameters

isClassOrInterfaceType