CtTypeReferenceImpl (Spoon Core 8.4.0-SNAPSHOT API)

java.lang.Object
- spoon.support.reflect.declaration.CtElementImpl
- - spoon.support.reflect.reference.CtReferenceImpl
  - - spoon.support.reflect.reference.CtTypeReferenceImpl<T>

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, FactoryAccessor, SourcePositionHolder, CtElement, CtShadowable, CtTypeInformation, CtActualTypeContainer, CtReference, CtTypeReference<T>, CtQueryable, CtVisitable

Direct Known Subclasses:

CtArrayTypeReferenceImpl, CtIntersectionTypeReferenceImpl, CtTypeParameterReferenceImpl
```
public class CtTypeReferenceImpl<T>
extends CtReferenceImpl
implements CtTypeReference<T>
```
See Also:

Serialized Form

Field Summary
- Fields inherited from class spoon.support.reflect.reference.CtReferenceImpl
  simplename
- Fields inherited from class spoon.support.reflect.declaration.CtElementImpl
  ERROR_MESSAGE_TO_STRING, factory, LOGGER, parent
- Fields inherited from interface spoon.reflect.reference.CtTypeReference
  NULL_TYPE_NAME, OMITTED_TYPE_ARG_NAME

Constructor Summary

Constructors
Constructor and Description

CtTypeReferenceImpl()

Constructors
Constructor and Description
`CtTypeReferenceImpl()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`accept(CtVisitor visitor)` Accepts a visitor
`<C extends CtActualTypeContainer> C`	`addActualTypeArgument(CtTypeReference<?> actualTypeArgument)` Adds a type argument.
`CtIntersectionTypeReference<T>`	`asCtIntersectionTypeReference()` Casts the type reference in `CtIntersectionTypeReference`.
`CtTypeReference<?>`	`box()` Returns the corresponding non-primitive type for a primitive type (the same type otherwise).
`boolean`	`canAccess(CtTypeMember typeMember)`
`boolean`	`canAccess(CtTypeReference<?> type)` Checks visibility based on public, protected, package protected and private modifiers of type
`CtTypeReference<T>`	`clone()` Clone the element which calls this method in a new object.
`protected java.lang.Class<T>`	`findClass()` Finds the class requested in `getActualClass()`.
`CtTypeReference<?>`	`getAccessType()` Computes nearest access path parent to this type from the context of this type reference.
`protected java.lang.reflect.AnnotatedElement`	`getActualAnnotatedElement()`
`java.lang.Class<T>`	`getActualClass()` Gets the Java runtime class of the referenced type.
`java.util.List<CtTypeReference<?>>`	`getActualTypeArguments()` Gets the type arguments.
`java.util.Collection<CtExecutableReference<?>>`	`getAllExecutables()` Gets the executables declared by this type and by all its supertypes (static/instance methods, constructors, anonymous static blocks) if applicable.
`java.util.Collection<CtFieldReference<?>>`	`getAllFields()` Gets the fields declared by this type and by all its supertypes if applicable.
`CtType<T>`	`getDeclaration()` Returns the `CtType`, that corresponds to the reference or `null` if the type declaration is not in the analyzed source files, `CtTypeReference.getTypeDeclaration()` is a newer and better alternative that never returns null.
`java.util.Collection<CtExecutableReference<?>>`	`getDeclaredExecutables()` Gets the executables declared by this type if applicable.
`CtFieldReference<?>`	`getDeclaredField(java.lang.String name)` Gets a field from its name.
`java.util.Collection<CtFieldReference<?>>`	`getDeclaredFields()` Gets the fields declared by this type.
`CtFieldReference<?>`	`getDeclaredOrInheritedField(java.lang.String fieldName)` Gets a field from this type or any super type or any implemented interface by field name.
`CtTypeReference<?>`	`getDeclaringType()` Gets the type that declares the referenced type.
`java.util.Set<ModifierKind>`	`getModifiers()` Gets modifiers of this type.
`CtPackageReference`	`getPackage()` Gets the package of the referenced type.
`java.lang.String`	`getQualifiedName()` Returns the fully qualified name of this type declaration.
`CtTypeReference<?>`	`getSuperclass()` Returns the class type directly extended by this class.
`java.util.Set<CtTypeReference<?>>`	`getSuperInterfaces()` Returns the interface types directly implemented by this class or extended by this interface.
`CtTypeReference<?>`	`getTopLevelType()` Returns this, or top level type of this, if this is an inner type
`CtType<T>`	`getTypeDeclaration()` Returns the `CtType` that corresponds to the reference even if the type isn't in the Spoon source path (in this case, the Spoon elements are built with runtime reflection, and the resulting CtType is called a "shadow" class, see `CtShadowable.isShadow()`).
`CtTypeReference<?>`	`getTypeErasure()`
`CtTypeParameter`	`getTypeParameterDeclaration()` If this type reference is used as a type argument (see `CtActualTypeContainer.getActualTypeArguments()`), returns the type parameter declaration in the target type, returns null otherwise.
`boolean`	`isAnnotationType()` Returns true if this type is an annotation type.
`boolean`	`isAnonymous()` Return `true` if the referenced type is a anonymous type
`boolean`	`isArray()`
`boolean`	`isClass()` Returns true if this type is a class.
`boolean`	`isEnum()` Returns true if this type is an enum.
`boolean`	`isGenerics()` Returns true if it is not a concrete, resolvable class, it if refers to a type parameter directly or indirectly.
`boolean`	`isInterface()` Returns true if this type is an interface.
`boolean`	`isLocalType()` Return `true` if the referenced type is declared in an executable.
`boolean`	`isParameterized()` Returns true if it has any type parameter (generic or not).
`boolean`	`isPrimitive()` Return `true` if the referenced type is a primitive type (int, double, boolean...).
`boolean`	`isShadow()` When an element isn't present in the factory (created in another factory), this element is considered as "shadow".
`boolean`	`isSimplyQualified()`
`boolean`	`isSubtypeOf(CtTypeReference<?> type)` Returns true if the referenced type is a sub-type of the given type.
`boolean`	`removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)` Removes a type argument.
`<C extends CtActualTypeContainer> C`	`setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments)` Sets the type arguments.
`<C extends CtTypeReference<T>> C`	`setDeclaringType(CtTypeReference<?> declaringType)` Sets the reference to the declaring type.
`<C extends CtTypeReference<T>> C`	`setPackage(CtPackageReference pack)` Sets the reference to the declaring package.
`<E extends CtShadowable> E`	`setShadow(boolean isShadow)` Marks an element as shadow.
`CtTypeReferenceImpl<T>`	`setSimplyQualified(boolean isSimplyQualified)`
`CtTypeReference<?>`	`unbox()` Returns the primitive type for a boxing type (unchanged if the type does not correspond to a boxing type).

Methods inherited from class spoon.support.reflect.reference.CtReferenceImpl
equals, getSimpleName, setComments, setSimpleName

Methods inherited from class spoon.support.reflect.declaration.CtElementImpl
addAnnotation, addComment, asIterable, comment, delete, descendantIterator, emptyList, emptySet, filterChildren, getAllMetadata, getAnnotatedChildren, getAnnotation, getAnnotation, getAnnotations, getComments, getDirectChildren, getDocComment, getElements, getFactory, getMetadata, getMetadataKeys, getOriginalSourceFragment, getParent, getParent, getParent, getPath, getPosition, getReferencedTypes, getRoleInParent, getShortRepresentation, getValueByRole, hasAnnotation, hashCode, hasParent, isImplicit, isParentInitialized, map, map, prettyprint, putMetadata, removeAnnotation, removeComment, replace, replace, setAllMetadata, setAnnotations, setDocComment, setFactory, setImplicit, setParent, setPosition, setPositions, setValueByRole, toString, toStringDebug, unmodifiableList, updateAllParentsBelow

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

Methods inherited from interface spoon.reflect.reference.CtTypeReference
getSimpleName

Methods inherited from interface spoon.reflect.reference.CtReference
setComments, setSimpleName

Methods inherited from interface spoon.processing.FactoryAccessor
getFactory, setFactory

Methods inherited from interface spoon.reflect.visitor.chain.CtQueryable
filterChildren, map, map

- Constructor Detail
  - CtTypeReferenceImpl
```
public CtTypeReferenceImpl()
```
- Method Detail
  - accept
```
public void accept(CtVisitor visitor)
```
    Description copied from interface: CtVisitable
    
    Accepts a visitor
    
    Specified by:
    
    accept in interface CtVisitable
    
    Specified by:
    
    accept in class CtReferenceImpl
  - box
```
public CtTypeReference<?> box()
```
    Description copied from interface: CtTypeReference
    
    Returns the corresponding non-primitive type for a primitive type (the same type otherwise).
    
    Specified by:
    
    box in interface CtTypeReference<T>
  - getActualClass
```
public java.lang.Class<T> getActualClass()
```
    Description copied from interface: CtTypeReference
    
    Gets the Java runtime class of the referenced type. This is a low-level feature, it should never been used. For CtTypeReference, use CtTypeReference.getTypeDeclaration() instead, in order to only stay in the Spoon world and manipulate CtType instead of java.lang.Class.
    
    Specified by:
    
    getActualClass in interface CtTypeReference<T>
    
    Returns:
    
    the Java class or throws a SpoonClassNotFoundException if the class is not found.
  - findClass
```
protected java.lang.Class<T> findClass()
```
    Finds the class requested in getActualClass(). Looks for the class in the standard Java classpath, but also in the sourceClassPath given as option.
  - getActualTypeArguments
```
public java.util.List<CtTypeReference<?>> getActualTypeArguments()
```
    Description copied from interface: CtActualTypeContainer
    
    Gets the type arguments.
    
    Specified by:
    
    getActualTypeArguments in interface CtActualTypeContainer
  - getActualAnnotatedElement
```
protected java.lang.reflect.AnnotatedElement getActualAnnotatedElement()
```
    Specified by:
    
    getActualAnnotatedElement in class CtReferenceImpl
  - getDeclaration
```
public CtType<T> getDeclaration()
```
    Description copied from interface: CtTypeReference
    
    Returns the CtType, that corresponds to the reference or null if the type declaration is not in the analyzed source files, CtTypeReference.getTypeDeclaration() is a newer and better alternative that never returns null.
    
    Specified by:
    
    getDeclaration in interface CtReference
    
    Specified by:
    
    getDeclaration in interface CtTypeReference<T>
    
    Returns:
    
    the referenced element or null if the type declaration is not the analyzed source files.
  - getTypeDeclaration
```
public CtType<T> getTypeDeclaration()
```
    Description copied from interface: CtTypeReference
    
    Returns the CtType that corresponds to the reference even if the type isn't in the Spoon source path (in this case, the Spoon elements are built with runtime reflection, and the resulting CtType is called a "shadow" class, see CtShadowable.isShadow()).
    
    Specified by:
    
    getTypeDeclaration in interface CtTypeReference<T>
    
    Returns:
    
    the type declaration that corresponds to the reference or null if the reference points to a class that is not in the classpath.
  - getDeclaringType
```
public CtTypeReference<?> getDeclaringType()
```
    Description copied from interface: CtTypeReference
    
    Gets the type that declares the referenced type.
    
    Specified by:
    
    getDeclaringType in interface CtTypeReference<T>
    
    Returns:
    
    the declaring type if this references an inner class; null in other cases
  - getPackage
```
public CtPackageReference getPackage()
```
    Description copied from interface: CtTypeReference
    
    Gets the package of the referenced type.
    
    Specified by:
    
    getPackage in interface CtTypeReference<T>
    
    Returns:
    
    the declaring package or null if this if a inner class
  - getQualifiedName
```
public java.lang.String getQualifiedName()
```
    Description copied from interface: CtTypeInformation
    
    Returns the fully qualified name of this type declaration.
    
    Specified by:
    
    getQualifiedName in interface CtTypeInformation
  - isPrimitive
```
public boolean isPrimitive()
```
    Description copied from interface: CtTypeInformation
    
    Return true if the referenced type is a primitive type (int, double, boolean...).
    
    Specified by:
    
    isPrimitive in interface CtTypeInformation
  - isSubtypeOf
```
public boolean isSubtypeOf(CtTypeReference<?> type)
```
    Description copied from interface: CtTypeInformation
    
    Returns true if the referenced type is a sub-type of the given type. Returns true is type is self, it means: typeX.isSubtypeOf(typeX) is true too
    
    Specified by:
    
    isSubtypeOf in interface CtTypeInformation
  - setActualTypeArguments
```
public <C extends CtActualTypeContainer> C setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments)
```
    Description copied from interface: CtActualTypeContainer
    
    Sets the type arguments.
    
    Specified by:
    
    setActualTypeArguments in interface CtActualTypeContainer
  - setDeclaringType
```
public <C extends CtTypeReference<T>> C setDeclaringType(CtTypeReference<?> declaringType)
```
    Description copied from interface: CtTypeReference
    
    Sets the reference to the declaring type. Should be set to null if the referenced type is not a inner type.
    
    Specified by:
    
    setDeclaringType in interface CtTypeReference<T>
  - setPackage
```
public <C extends CtTypeReference<T>> C setPackage(CtPackageReference pack)
```
    Description copied from interface: CtTypeReference
    
    Sets the reference to the declaring package.
    
    Specified by:
    
    setPackage in interface CtTypeReference<T>
  - asCtIntersectionTypeReference
```
public CtIntersectionTypeReference<T> asCtIntersectionTypeReference()
```
    Description copied from interface: CtTypeReference
    
    Casts the type reference in CtIntersectionTypeReference.
    
    Specified by:
    
    asCtIntersectionTypeReference in interface CtTypeReference<T>
  - unbox
```
public CtTypeReference<?> unbox()
```
    Description copied from interface: CtTypeReference
    
    Returns the primitive type for a boxing type (unchanged if the type does not correspond to a boxing type).
    
    Specified by:
    
    unbox in interface CtTypeReference<T>
  - getDeclaredFields
```
public java.util.Collection<CtFieldReference<?>> getDeclaredFields()
```
    Description copied from interface: CtTypeInformation
    
    Gets the fields declared by this type.
    
    Specified by:
    
    getDeclaredFields in interface CtTypeInformation
  - getDeclaredField
```
public CtFieldReference<?> getDeclaredField(java.lang.String name)
```
    Description copied from interface: CtTypeInformation
    
    Gets a field from its name.
    
    Specified by:
    
    getDeclaredField in interface CtTypeInformation
    
    Returns:
    
    null if does not exit
  - getDeclaredOrInheritedField
```
public CtFieldReference<?> getDeclaredOrInheritedField(java.lang.String fieldName)
```
    Description copied from interface: CtTypeInformation
    
    Gets a field from this type or any super type or any implemented interface by field name.
    
    Specified by:
    
    getDeclaredOrInheritedField in interface CtTypeInformation
    
    Returns:
    
    null if does not exit
  - getDeclaredExecutables
```
public java.util.Collection<CtExecutableReference<?>> getDeclaredExecutables()
```
    Description copied from interface: CtTypeInformation
    
    Gets the executables declared by this type if applicable.
    
    Specified by:
    
    getDeclaredExecutables in interface CtTypeInformation
  - getAllFields
```
public java.util.Collection<CtFieldReference<?>> getAllFields()
```
    Description copied from interface: CtTypeInformation
    
    Gets the fields declared by this type and by all its supertypes if applicable.
    
    Specified by:
    
    getAllFields in interface CtTypeInformation
  - getAllExecutables
```
public java.util.Collection<CtExecutableReference<?>> getAllExecutables()
```
    Description copied from interface: CtTypeInformation
    Gets the executables declared by this type and by all its supertypes (static/instance methods, constructors, anonymous static blocks) if applicable. This method returns:
    - static, instance and default methods
    - constructors
    If a method is overridden twice in the hierarchy, it counts for two different elements. The method can be abstract.
    Specified by:
    
    getAllExecutables in interface CtTypeInformation
  - getModifiers
```
public java.util.Set<ModifierKind> getModifiers()
```
    Description copied from interface: CtTypeInformation
    
    Gets modifiers of this type.
    
    Specified by:
    
    getModifiers in interface CtTypeInformation
    
    Specified by:
    
    getModifiers in interface CtTypeReference<T>
  - getSuperclass
```
public CtTypeReference<?> getSuperclass()
```
    Description copied from interface: CtTypeInformation
    
    Returns the class type directly extended by this class. getSuperClass().getDeclaration()/getTypeDeclaration() returns the corresponding CtType (if in the source folder of Spoon).
    
    Specified by:
    
    getSuperclass in interface CtTypeInformation
    
    Specified by:
    
    getSuperclass in interface CtTypeReference<T>
    
    Returns:
    
    the class type directly extended by this class, or null if there is none or if the super class is not in the classpath (in noclasspath mode)
  - getSuperInterfaces
```
public java.util.Set<CtTypeReference<?>> getSuperInterfaces()
```
    Description copied from interface: CtTypeInformation
    
    Returns the interface types directly implemented by this class or extended by this interface.
    
    Specified by:
    
    getSuperInterfaces in interface CtTypeInformation
    
    Specified by:
    
    getSuperInterfaces in interface CtTypeReference<T>
  - isAnonymous
```
public boolean isAnonymous()
```
    Description copied from interface: CtTypeInformation
    
    Return true if the referenced type is a anonymous type
    
    Specified by:
    
    isAnonymous in interface CtTypeInformation
  - isLocalType
```
public boolean isLocalType()
```
    Description copied from interface: CtTypeInformation
    Return true if the referenced type is declared in an executable. e.g. a type declared in a method or a lambda. This corresponds to isLocalClass of java.lang.Class.
```
     // Type declared in a method.
     public void make() {
         class Cook {
         }
     }
     // Type declared in a lambda.
     s -> {
         class Cook {
         }
     }
 
```
    Specified by:
    
    isLocalType in interface CtTypeInformation
  - addActualTypeArgument
```
public <C extends CtActualTypeContainer> C addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
```
    Description copied from interface: CtActualTypeContainer
    
    Adds a type argument.
    
    Specified by:
    
    addActualTypeArgument in interface CtActualTypeContainer
  - removeActualTypeArgument
```
public boolean removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
```
    Description copied from interface: CtActualTypeContainer
    
    Removes a type argument.
    
    Specified by:
    
    removeActualTypeArgument in interface CtActualTypeContainer
  - isClass
```
public boolean isClass()
```
    Description copied from interface: CtTypeInformation
    
    Returns true if this type is a class. Returns false for others (enum, interface, generics, annotation).
    
    Specified by:
    
    isClass in interface CtTypeInformation
  - isInterface
```
public boolean isInterface()
```
    Description copied from interface: CtTypeInformation
    
    Returns true if this type is an interface.
    
    Specified by:
    
    isInterface in interface CtTypeInformation
  - isAnnotationType
```
public boolean isAnnotationType()
```
    Description copied from interface: CtTypeInformation
    
    Returns true if this type is an annotation type.
    
    Specified by:
    
    isAnnotationType in interface CtTypeInformation
  - isEnum
```
public boolean isEnum()
```
    Description copied from interface: CtTypeInformation
    
    Returns true if this type is an enum.
    
    Specified by:
    
    isEnum in interface CtTypeInformation
  - canAccess
```
public boolean canAccess(CtTypeReference<?> type)
```
    Description copied from interface: CtTypeReference
    
    Checks visibility based on public, protected, package protected and private modifiers of type
    
    Specified by:
    
    canAccess in interface CtTypeReference<T>
    
    Returns:
    
    true if this can access that type
  - canAccess
```
public boolean canAccess(CtTypeMember typeMember)
```
    Specified by:
    
    canAccess in interface CtTypeReference<T>
    
    Returns:
    
    true if this type can access that the `typeMember` in another type based on public, protected, package protected and private modifiers.
  - getTopLevelType
```
public CtTypeReference<?> getTopLevelType()
```
    Description copied from interface: CtTypeReference
    
    Returns this, or top level type of this, if this is an inner type
    
    Specified by:
    
    getTopLevelType in interface CtTypeReference<T>
  - getAccessType
```
public CtTypeReference<?> getAccessType()
```
    Description copied from interface: CtTypeReference
    Computes nearest access path parent to this type from the context of this type reference. The context is defined by this.getParent(CtType.class). Normally the declaring type can be used as access path. For example in this class hierarchy
```
 class A {
    class B {
       class C {}
    }
 }
 
```
    The C.getAccessParentFrom(null) will return B, because B can be used to access C, using code like B.C
    But when some class (A or B) on the access path is not visible in type X, then we must found an alternative path. For example in case like, when A and B are invisible, e.g because of modifier protected:
```
 class D extends B {
 }
 class X extends D {
         class F extends C
 }
 
```
    The C.getAccessParentFrom(X) will return D, because D can be used to access C in scope of X.
    Specified by:
    
    getAccessType in interface CtTypeReference<T>
    
    Returns:
    
    type reference which can be used to access this type in scope of contextType.
  - isShadow
```
public boolean isShadow()
```
    Description copied from interface: CtShadowable
    
    When an element isn't present in the factory (created in another factory), this element is considered as "shadow". e.g., a shadow element can be a CtType of java.lang.Class built when we call CtTypeReference.getTypeDeclaration() on a reference of java.lang.Class.
    
    Specified by:
    
    isShadow in interface CtShadowable
    
    Returns:
    
    true if the element is a shadow element, otherwise false.
  - setShadow
```
public <E extends CtShadowable> E setShadow(boolean isShadow)
```
    Description copied from interface: CtShadowable
    
    Marks an element as shadow. To know what is a shadow element, see the javadoc of CtShadowable.isShadow().
    
    Specified by:
    
    setShadow in interface CtShadowable
  - clone
```
public CtTypeReference<T> clone()
```
    Description copied from interface: CtElement
    
    Clone the element which calls this method in a new object. Note that that references are kept as is, and thus, so if you clone whole classes or methods, some parts of the cloned element (eg executable references) may still point to the initial element. In this case, consider using methods Refactoring.copyType(CtType) and Refactoring.copyMethod(CtMethod) instead which does additional work beyond cloning.
    
    Specified by:
    
    clone in interface CtElement
    
    Specified by:
    
    clone in interface CtReference
    
    Specified by:
    
    clone in interface CtTypeReference<T>
    
    Overrides:
    
    clone in class CtReferenceImpl
  - getTypeParameterDeclaration
```
public CtTypeParameter getTypeParameterDeclaration()
```
    Description copied from interface: CtTypeReference
    If this type reference is used as a type argument (see CtActualTypeContainer.getActualTypeArguments()), returns the type parameter declaration in the target type, returns null otherwise. In the following example, getTypeParameterDeclaration of "String" returns the type parameter definition "X".
```
 class Dog<X>{}
 Dog<String>var = ...;
 
```
    In this other example, getTypeParameterDeclaration of T in Dog<T> returns the type parameter definition "X" (while CtTypeReference.getDeclaration() returns the "T" of Cat).
```
 class Dog<X>{}
 class Cat<T> {
 Dog<T> dog;
 }
 
```
    Specified by:
    
    getTypeParameterDeclaration in interface CtTypeReference<T>
  - isGenerics
```
public boolean isGenerics()
```
    Description copied from interface: CtTypeInformation
    
    Returns true if it is not a concrete, resolvable class, it if refers to a type parameter directly or indirectly. Direct: "T foo" isGenerics returns true. Indirect: List<T>, or Set<List<T>> isGenerics returns true
    
    Specified by:
    
    isGenerics in interface CtTypeInformation
  - isParameterized
```
public boolean isParameterized()
```
    Description copied from interface: CtTypeInformation
    
    Returns true if it has any type parameter (generic or not).
    
    Specified by:
    
    isParameterized in interface CtTypeInformation
  - getTypeErasure
```
public CtTypeReference<?> getTypeErasure()
```
    Specified by:
    
    getTypeErasure in interface CtTypeInformation
    
    Returns:
    
    the type erasure, which is computed by the java compiler to ensure that no new classes are created for parametrized types so that generics incur no runtime overhead. See https://docs.oracle.com/javase/tutorial/java/generics/erasure.html
  - isSimplyQualified
```
public boolean isSimplyQualified()
```
    Specified by:
    
    isSimplyQualified in interface CtTypeReference<T>
    
    Returns:
    
    false then fully qualified name is printed. true then type simple name is printed.
  - setSimplyQualified
```
public CtTypeReferenceImpl<T> setSimplyQualified(boolean isSimplyQualified)
```
    Specified by:
    
    setSimplyQualified in interface CtTypeReference<T>
    
    Parameters:
    
    isSimplyQualified - false then the reference is printed fully qualified name. true then only the type name is printed.
  - isArray
```
public boolean isArray()
```
    Specified by:
    
    isArray in interface CtTypeInformation
    
    Returns:
    
    true if this represents an array e.g. Object[] or int[]

Class CtTypeReferenceImpl<T>

Field Summary

Fields inherited from class spoon.support.reflect.reference.CtReferenceImpl

Fields inherited from class spoon.support.reflect.declaration.CtElementImpl

Fields inherited from interface spoon.reflect.reference.CtTypeReference

Constructor Summary

Method Summary

Methods inherited from class spoon.support.reflect.reference.CtReferenceImpl

Methods inherited from class spoon.support.reflect.declaration.CtElementImpl

Methods inherited from class java.lang.Object

Methods inherited from interface spoon.reflect.reference.CtTypeReference

Methods inherited from interface spoon.reflect.reference.CtReference

Methods inherited from interface spoon.reflect.declaration.CtElement

Methods inherited from interface spoon.processing.FactoryAccessor

Methods inherited from interface spoon.reflect.visitor.chain.CtQueryable

Constructor Detail

CtTypeReferenceImpl

Method Detail

accept

box

getActualClass

findClass

getActualTypeArguments

getActualAnnotatedElement

getDeclaration

getTypeDeclaration

getDeclaringType

getPackage

getQualifiedName

isPrimitive

isSubtypeOf

setActualTypeArguments

setDeclaringType

setPackage

asCtIntersectionTypeReference

unbox

getDeclaredFields

getDeclaredField

getDeclaredOrInheritedField

getDeclaredExecutables

getAllFields

getAllExecutables

getModifiers

getSuperclass

getSuperInterfaces

isAnonymous

isLocalType

addActualTypeArgument

removeActualTypeArgument

isClass

isInterface

isAnnotationType

isEnum

canAccess

canAccess

getTopLevelType

getAccessType

isShadow

setShadow

clone

getTypeParameterDeclaration

isGenerics

isParameterized

getTypeErasure

isSimplyQualified

setSimplyQualified

isArray