Package spoon.support.reflect.reference

Class CtTypeParameterReferenceImpl

java.lang.Object

spoon.support.reflect.declaration.CtElementImpl

spoon.support.reflect.reference.CtReferenceImpl

spoon.support.reflect.reference.CtTypeReferenceImpl<Object>

spoon.support.reflect.reference.CtTypeParameterReferenceImpl

All Implemented Interfaces:

Serializable, Cloneable, FactoryAccessor, SourcePositionHolder, CtElement, CtShadowable, CtTypeInformation, CtActualTypeContainer, CtReference, CtTypeParameterReference, CtTypeReference<Object>, CtQueryable, CtVisitable

Direct Known Subclasses:

CtWildcardReferenceImpl

public class CtTypeParameterReferenceImpl
extends CtTypeReferenceImpl<Object>
implements CtTypeParameterReference

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	Description
CtTypeParameterReferenceImpl()

Method Summary

Modifier and Type	Method	Description
void	accept(CtVisitor visitor)	Accepts a visitor
<C extends CtActualTypeContainer> C	addActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Adds a type argument.
CtTypeParameterReference	clone()	Clone the element which calls this method in a new object.
protected AnnotatedElement	getActualAnnotatedElement()
Class<Object>	getActualClass()	Gets the Java runtime class of the referenced type.
List<CtTypeReference<?>>	getActualTypeArguments()	Gets the type arguments.
CtTypeReference<?>	getBoundingType()	A type parameter can have an extends clause which declare one (CtTypeReference or more (CtIntersectionTypeReference references.
CtTypeParameter	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 less often returns null.
CtType<Object>	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()	This method returns a reference to the erased type.
boolean	isDefaultBoundingType()	Returns true if this has the default bounding type that is java.lang.Object (which basically means that there is no bound)
boolean	isGenerics()	Returns true if it is not a concrete, resolvable class, it if refers to a type parameter directly or indirectly.
boolean	isPrimitive()	Checks if the referenced type is a primitive type.
boolean	isSimplyQualified()
boolean	isSubtypeOf(CtTypeReference<?> type)	Checks if this type is a subtype of the given type.
protected boolean	isWildcard()
boolean	removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Removes a type argument.
<C extends CtActualTypeContainer> C	setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)	Sets the type arguments.
CtTypeParameterReferenceImpl	setSimplyQualified(boolean isSimplyQualified)

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

asCtIntersectionTypeReference, box, canAccess, canAccess, findClass, getAccessType, getAllExecutables, getAllFields, getDeclaredExecutables, getDeclaredField, getDeclaredFields, getDeclaredOrInheritedField, getDeclaringType, getModifiers, getPackage, getQualifiedName, getSuperclass, getSuperInterfaces, getTopLevelType, getTypeParameterDeclaration, isAnnotationType, isAnonymous, isArray, isClass, isEnum, isInterface, isLocalType, isParameterized, isShadow, setDeclaringType, setPackage, setShadow, unbox

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.declaration.CtElement

addAnnotation, addComment, asIterable, delete, descendantIterator, getAllMetadata, getAnnotatedChildren, getAnnotation, getAnnotation, getAnnotations, getComments, getDirectChildren, getDocComment, getElements, getMetadata, getMetadataKeys, getOriginalSourceFragment, getParent, getParent, getParent, getPath, getPosition, getReferencedTypes, getRoleInParent, getShortRepresentation, getValueByRole, hasAnnotation, hasParent, isImplicit, isParentInitialized, prettyprint, putMetadata, removeAnnotation, removeComment, replace, replace, setAllMetadata, setAnnotations, setDocComment, setImplicit, setParent, setPosition, setPositions, setValueByRole, toString, toStringDebug, updateAllParentsBelow

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

filterChildren, map, map

Methods inherited from interface spoon.reflect.reference.CtReference

setComments, setSimpleName

Methods inherited from interface spoon.reflect.declaration.CtShadowable

isShadow, setShadow

Methods inherited from interface spoon.reflect.declaration.CtTypeInformation

getAllExecutables, getAllFields, getDeclaredExecutables, getDeclaredField, getDeclaredFields, getDeclaredOrInheritedField, getQualifiedName, isAnnotationType, isAnonymous, isArray, isClass, isEnum, isInterface, isLocalType, isParameterized

Methods inherited from interface spoon.reflect.reference.CtTypeReference

asCtIntersectionTypeReference, box, canAccess, canAccess, getAccessType, getDeclaringType, getModifiers, getPackage, getSimpleName, getSuperclass, getSuperInterfaces, getTopLevelType, getTypeParameterDeclaration, setDeclaringType, setPackage, unbox

Methods inherited from interface spoon.processing.FactoryAccessor

getFactory, setFactory

Constructor Details

CtTypeParameterReferenceImpl

public CtTypeParameterReferenceImpl()

Method Details

isDefaultBoundingType

public boolean isDefaultBoundingType()

Description copied from interface: CtTypeParameterReference

Returns true if this has the default bounding type that is java.lang.Object (which basically means that there is no bound)

Specified by:

isDefaultBoundingType in interface CtTypeParameterReference

accept

public void accept(CtVisitor visitor)

Description copied from interface: CtVisitable

Accepts a visitor

Specified by:

accept in interface CtVisitable

Overrides:

accept in class CtTypeReferenceImpl<Object>

isPrimitive

public boolean isPrimitive()

Description copied from interface: CtTypeInformation

Checks if the referenced type is a primitive type.

It is a primitive type, if it is one of the following types:

• byte
• short
• int
• long
• float
• double
• boolean
• char
• void

For boxed types like Integer this method returns false.

Specified by:

isPrimitive in interface CtTypeInformation

Overrides:

isPrimitive in class CtTypeReferenceImpl<Object>

Returns:

true if the referenced type is a primitive type

getActualClass

public Class<Object> 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, use CtTypeReference.getTypeDeclaration() instead in order to only stay in the Spoon world and manipulate CtType instead of java.lang.Class.

Note (these are artifacts of the current implementation and might change at any time):

1. it will return the version of the class your Environment.getInputClassLoader() loads. This might be a version spoon compiled (manually using SpoonModelBuilder.compile(spoon.SpoonModelBuilder.InputType...) or implicitly using Environment.shouldCompile()) or from your classpath (which might be null)
2. it will run static initializers (executing arbitrary code from the analyzed project in the process)
3. it will fail if the static initializers of the class fail
4. the Class object may not reflect the CtType in case you made recent changes to it based on point 1

Specified by:

getActualClass in interface CtTypeReference<Object>

Overrides:

getActualClass in class CtTypeReferenceImpl<Object>

Returns:

the Java class or throws a SpoonClassNotFoundException if the class is not found.

getActualTypeArguments

public List<CtTypeReference<?>> getActualTypeArguments()

Description copied from interface: CtActualTypeContainer

Gets the type arguments.

Specified by:

getActualTypeArguments in interface CtActualTypeContainer

Overrides:

getActualTypeArguments in class CtTypeReferenceImpl<Object>

setActualTypeArguments

public <C extends CtActualTypeContainer> C setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)

Description copied from interface: CtActualTypeContainer

Sets the type arguments.

Specified by:

setActualTypeArguments in interface CtActualTypeContainer

Specified by:

setActualTypeArguments in interface CtTypeParameterReference

Overrides:

setActualTypeArguments in class CtTypeReferenceImpl<Object>

addActualTypeArgument

public <C extends CtActualTypeContainer> C addActualTypeArgument(CtTypeReference<?> actualTypeArgument)

Description copied from interface: CtActualTypeContainer

Adds a type argument.

Specified by:

addActualTypeArgument in interface CtActualTypeContainer

Overrides:

addActualTypeArgument in class CtTypeReferenceImpl<Object>

removeActualTypeArgument

public boolean removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)

Description copied from interface: CtActualTypeContainer

Removes a type argument.

Specified by:

removeActualTypeArgument in interface CtActualTypeContainer

Overrides:

removeActualTypeArgument in class CtTypeReferenceImpl<Object>

getBoundingType

public CtTypeReference<?> getBoundingType()

Description copied from interface: CtTypeParameterReference

A type parameter can have an extends clause which declare one (CtTypeReference or more (CtIntersectionTypeReference references.

     // Extends with generics.
     T extends Interface1
     // Intersection type with generics.
     T extends Interface1 & Interface2
 

Specified by:

getBoundingType in interface CtTypeParameterReference

getActualAnnotatedElement

protected AnnotatedElement getActualAnnotatedElement()

Overrides:

getActualAnnotatedElement in class CtTypeReferenceImpl<Object>

getDeclaration

public CtTypeParameter 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 less often returns null.

Specified by:

getDeclaration in interface CtReference

Specified by:

getDeclaration in interface CtTypeParameterReference

Specified by:

getDeclaration in interface CtTypeReference<Object>

Overrides:

getDeclaration in class CtTypeReferenceImpl<Object>

Returns:

the referenced element or null if the type declaration is not the analyzed source files.

getTypeDeclaration

public CtType<Object> 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<Object>

Overrides:

getTypeDeclaration in class CtTypeReferenceImpl<Object>

Returns:

the type declaration that corresponds to the reference or null if the reference points to a class that is not in the classpath.

getTypeErasure

public CtTypeReference<?> getTypeErasure()

Description copied from interface: CtTypeInformation

This method returns a reference to the erased type.

For example, this will return List for List<String>, or Enum for the type parameter E in the enum declaration.

Specified by:

getTypeErasure in interface CtTypeInformation

Overrides:

getTypeErasure in class CtTypeReferenceImpl<Object>

Returns:

a reference to the erased type

See Also:

• Type Erasure

isSubtypeOf

public boolean isSubtypeOf(CtTypeReference<?> type)

Description copied from interface: CtTypeInformation

Checks if this type is a subtype of the given type.

Specified by:

isSubtypeOf in interface CtTypeInformation

Overrides:

isSubtypeOf in class CtTypeReferenceImpl<Object>

Parameters:

type - the type that might be a parent of this type.

Returns:

true if the referenced type is a subtype of the given type, otherwise false. If this type is the same as the given type (typeX.isSubtypeOf(typeX)), this method returns true.

clone

public CtTypeParameterReference 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 CtTypeParameterReference

Specified by:

clone in interface CtTypeReference<Object>

Overrides:

clone in class CtTypeReferenceImpl<Object>

Returns:

a clone of this element. All children are cloned, but the parent of the returned clone is set to null.

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

Overrides:

isGenerics in class CtTypeReferenceImpl<Object>

isWildcard

protected boolean isWildcard()

isSimplyQualified

public boolean isSimplyQualified()

Specified by:

isSimplyQualified in interface CtTypeReference<Object>

Overrides:

isSimplyQualified in class CtTypeReferenceImpl<Object>

Returns:

false then fully qualified name is printed. true then type simple name is printed.

setSimplyQualified

public CtTypeParameterReferenceImpl setSimplyQualified(boolean isSimplyQualified)

Specified by:

setSimplyQualified in interface CtTypeReference<Object>

Overrides:

setSimplyQualified in class CtTypeReferenceImpl<Object>

Parameters:

isSimplyQualified - false then the reference is printed fully qualified name. true then only the type name is printed.