Uses of Interface
spoon.reflect.reference.CtTypeReference
Package
Description
Ready to go meta?
This package contains classes that model the Spoon metamodel itself.
This package contains the meta-model part that models the executable code (methods and constructors' bodies, field initializers).
This package contains the meta-model part that models the declarations (program's structures such as classes, fields, etc).
This package defines all the sub-factories for the Spoon meta-model.
This package defines the references to program elements for the meta-model.
This package defines visitor, scanner, and scanner-based query API for Java programs reified in the meta-model.
This package contains a set of useful filters when querying the model.
This package contains some default implementations for commonly used processing tasks.
This package defines a framework for well-typed pure-Java templates.
-
Uses of CtTypeReference in spoon.metamodel
Modifier and TypeMethodDescriptionMMMethod.getReturnType()
MetamodelProperty.getTypeOfField()
Return the type of the field for List<String> field the ValueType is List for String field the ValueType is StringMetamodelProperty.getTypeofItems()
Returns the type of the property for List<String> field the ValueType is String for String field the ValueType is String (when getContainerKind ==ContainerKind.SINGLE
,MetamodelProperty.getTypeofItems()
==MetamodelProperty.getTypeOfField()
.MMMethod.getValueType()
-
Uses of CtTypeReference in spoon.pattern
Modifier and TypeMethodDescriptionPatternParameterConfigurator.byType(CtTypeReference<?> type)
type referred byCtTypeReference
`type` and all the references (with same actual type arguments) to that type are subject for substitution by current parameter -
Uses of CtTypeReference in spoon.reflect.code
Modifier and TypeMethodDescriptionCtTypeAccess.getAccessedType()
Returns type represented and contained in the type access.CtCatchVariable.getType()
Returns type reference of the exception variable in a catch.CtConstructorCall.getType()
CtInvocation.getType()
Return the type returned by the invocation.CtSuperAccess.getType()
CtTypeAccess.getType()
Returns always VOID.CtVariableAccess.getType()
Modifier and TypeMethodDescriptionList<CtTypeReference<?>>
CtConstructorCall.getActualTypeArguments()
Delegate to the executable reference of the constructor call.List<CtTypeReference<?>>
CtInvocation.getActualTypeArguments()
Delegate to the executable reference of the invocation.List<CtTypeReference<?>>
CtNewClass.getActualTypeArguments()
Delegate to the executable reference of the new class.List<CtTypeReference<?>>
CtExpression.getTypeCasts()
Returns the type casts if any.List<CtTypeReference<?>>
CtTypePattern.getTypeCasts()
Modifier and TypeMethodDescription<T extends CtActualTypeContainer>
TCtConstructorCall.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
Delegate to the executable reference of the constructor call.<T extends CtActualTypeContainer>
TCtInvocation.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
Delegate to the executable reference of the invocation.<T extends CtActualTypeContainer>
TCtNewClass.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
Delegate to the executable reference of the new class.<C extends CtExpression<T>>
CCtExpression.addTypeCast(CtTypeReference<?> type)
Adds a type cast.<C extends CtExpression<Void>>
CCtTypePattern.addTypeCast(CtTypeReference<?> type)
<C extends CtTypeAccess<A>>
CCtTypeAccess.setAccessedType(CtTypeReference<A> accessedType)
Set the accessed type.<C extends CtTypedElement>
CCtCatchVariable.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtTypeAccess.setType(CtTypeReference type)
Modifier and TypeMethodDescription<T extends CtActualTypeContainer>
TCtConstructorCall.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
Delegate to the executable reference of the constructor call.<T extends CtActualTypeContainer>
TCtInvocation.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
Delegate to the executable reference of the invocation.<T extends CtActualTypeContainer>
TCtNewClass.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
Delegate to the executable reference of the new class.<T1 extends CtExecutable<T>>
T1CtLambda.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<C extends CtExpression<T>>
CCtExpression.setTypeCasts(List<CtTypeReference<?>> types)
Sets the type casts.<C extends CtExpression<Void>>
CCtTypePattern.setTypeCasts(List<CtTypeReference<?>> types)
-
Uses of CtTypeReference in spoon.reflect.declaration
Modifier and TypeMethodDescriptionCtAnnotation.getAnnotationType()
Returns the annotation type of this annotation.CtType.getReference()
Returns the corresponding type reference.CtProvidedService.getServiceType()
CtUsedService.getServiceType()
CtTypeInformation.getSuperclass()
Returns a reference to the type directly extended by this type.CtTypedElement.getType()
Gets this element's type.CtTypeInformation.getTypeErasure()
This method returns a reference to the erased type.Modifier and TypeMethodDescriptionList<CtTypeReference<?>>
CtCompilationUnit.getDeclaredTypeReferences()
Gets references to all the types declared in this compilation unit.CtProvidedService.getImplementationTypes()
List<CtTypeReference<?>>
CtMultiTypedElement.getMultiTypes()
Gets all types of the element.Set<CtTypeReference<?>>
CtEnum.getPermittedTypes()
Set<CtTypeReference<?>>
CtRecord.getPermittedTypes()
Set<CtTypeReference<?>>
CtSealable.getPermittedTypes()
Returns the permitted types for this type.Set<CtTypeReference<?>>
CtElement.getReferencedTypes()
Calculates and returns the set of all the types referenced by this element (and sub-elements in the AST).Set<CtTypeReference<?>>
CtTypeInformation.getSuperInterfaces()
Returns the interface types directly implemented by this class or extended by this interface.Set<CtTypeReference<? extends Throwable>>
CtExecutable.getThrownTypes()
Returns the exceptions and other throwables listed in this method or constructor's throws clause.Set<CtTypeReference<?>>
CtType.getUsedTypes(boolean includeSamePackage)
Returns the types used by this type.Modifier and TypeMethodDescriptionCtCompilationUnit.addDeclaredTypeReference(CtTypeReference<?> type)
Add a type reference to the list of declared types<T extends CtProvidedService>
TCtProvidedService.addImplementationType(CtTypeReference usedType)
<T extends CtMultiTypedElement>
TCtMultiTypedElement.addMultiType(CtTypeReference<?> ref)
Adds a type for the element.CtEnum.addPermittedType(CtTypeReference<?> type)
CtRecord.addPermittedType(CtTypeReference<?> type)
CtSealable.addPermittedType(CtTypeReference<?> type)
Adds a permitted type to this type.CtType.addSuperInterface(CtTypeReference<S> interfac)
CtTypeParameter.addSuperInterface(CtTypeReference<S> interfac)
<T extends CtExecutable<Void>>
TCtAnonymousExecutable.addThrownType(CtTypeReference<? extends Throwable> throwType)
<T extends CtExecutable<R>>
TCtExecutable.addThrownType(CtTypeReference<? extends Throwable> throwType)
add a thrown type.<A extends Annotation>
CtAnnotation<A>CtElement.getAnnotation(CtTypeReference<A> annotationType)
Gets the annotation element for a given annotation type.CtClass.getConstructor(CtTypeReference<?>... parameterTypes)
Returns the constructor of the class that takes the given argument types.<R> CtMethod<R>
CtType.getMethod(String name, CtTypeReference<?>... parameterTypes)
Gets a method from its name and parameter types.<R> CtMethod<R>
CtType.getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes)
Gets a method from its return type, name, and parameter types.CtType.getMethodsAnnotatedWith(CtTypeReference<?>... annotationTypes)
Returns the methods that are directly declared by this class or interface and annotated with one of the given annotations.boolean
CtTypeInformation.isSubtypeOf(CtTypeReference<?> type)
Checks if this type is a subtype of the given type.boolean
CtMultiTypedElement.removeMultiType(CtTypeReference<?> ref)
Removes a type for the element.CtEnum.removePermittedType(CtTypeReference<?> type)
CtRecord.removePermittedType(CtTypeReference<?> type)
CtSealable.removePermittedType(CtTypeReference<?> type)
Adds a permitted type to this type.<S> boolean
CtType.removeSuperInterface(CtTypeReference<S> interfac)
boolean
CtExecutable.removeThrownType(CtTypeReference<? extends Throwable> throwType)
remove a thrown type.<T extends CtAnnotation<A>>
TCtAnnotation.setAnnotationType(CtTypeReference<? extends Annotation> type)
Sets the annotation's type.<T extends CtProvidedService>
TCtProvidedService.setServiceType(CtTypeReference providingType)
<T extends CtUsedService>
TCtUsedService.setServiceType(CtTypeReference providingType)
CtAnnotationType.setSuperclass(CtTypeReference<?> superClass)
CtEnum.setSuperclass(CtTypeReference<?> superClass)
CtInterface.setSuperclass(CtTypeReference<?> superClass)
CtRecord.setSuperclass(CtTypeReference<?> superClass)
CtType.setSuperclass(CtTypeReference<?> superClass)
Sets the superclass type.<C extends CtTypedElement>
CCtAnonymousExecutable.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtConstructor.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtTypedElement.setType(CtTypeReference type)
Sets this element's type.Modifier and TypeMethodDescriptionCtCompilationUnit.setDeclaredTypeReferences(List<CtTypeReference<?>> types)
Sets the references to types declared in this compilation unit.<T extends CtProvidedService>
TCtProvidedService.setImplementationTypes(List<CtTypeReference> usedTypes)
<T extends CtMultiTypedElement>
TCtMultiTypedElement.setMultiTypes(List<CtTypeReference<?>> types)
Adds a type for the element.CtEnum.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtRecord.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtSealable.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
Sets the permitted types for this type.CtAnnotationType.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
CtType.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
Sets the super interfaces of this type.CtTypeParameter.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<T1 extends CtExecutable<T>>
T1CtAnnotationMethod.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<T extends CtExecutable<Void>>
TCtAnonymousExecutable.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<T extends CtExecutable<R>>
TCtExecutable.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
Sets the thrown types.<C extends CtExpression<A>>
CCtAnnotation.setTypeCasts(List<CtTypeReference<?>> types)
-
Uses of CtTypeReference in spoon.reflect.factory
Modifier and TypeFieldDescriptionTypeFactory.BOOLEAN
TypeFactory.BOOLEAN_PRIMITIVE
TypeFactory.BYTE
TypeFactory.BYTE_PRIMITIVE
TypeFactory.CHARACTER
TypeFactory.CHARACTER_PRIMITIVE
TypeFactory.COLLECTION
TypeFactory.DATE
TypeFactory.DOUBLE
TypeFactory.DOUBLE_PRIMITIVE
TypeFactory.ENUM
TypeFactory.FLOAT
TypeFactory.FLOAT_PRIMITIVE
TypeFactory.INTEGER
TypeFactory.INTEGER_PRIMITIVE
TypeFactory.ITERABLE
TypeFactory.LIST
TypeFactory.LONG
TypeFactory.LONG_PRIMITIVE
TypeFactory.MAP
TypeFactory.NULL_TYPE
TypeFactory.OBJECT
TypeFactory.OMITTED_TYPE_ARG_TYPE
TypeFactory.SET
TypeFactory.SHORT
TypeFactory.SHORT_PRIMITIVE
TypeFactory.STRING
TypeFactory.VOID
TypeFactory.VOID_PRIMITIVE
Modifier and TypeMethodDescriptionTypeFactory.booleanPrimitiveType()
Returns a reference on the boolean primitive type.TypeFactory.booleanType()
Returns a reference on the boolean type.TypeFactory.bytePrimitiveType()
Returns a reference on the byte primitive type.TypeFactory.byteType()
Returns a reference on the byte type.TypeFactory.characterPrimitiveType()
Returns a reference on the character primitive type.TypeFactory.characterType()
Returns a reference on the character type.<T> CtTypeReference<T>
CodeFactory.createCtTypeReference(Class<?> originalClass)
Creates a type reference.<T> CtTypeReference<T>
Factory.createCtTypeReference(Class<?> originalClass)
<T> CtTypeReference<T>
FactoryImpl.createCtTypeReference(Class<?> originalClass)
<T> CtTypeReference<T>
Factory.createReference(String qualifiedName)
<T> CtTypeReference<T>
FactoryImpl.createReference(String qualifiedName)
<T> CtTypeReference<T>
TypeFactory.createReference(Class<T> type)
<T> CtTypeReference<T>
TypeFactory.createReference(Class<T> type, boolean includingFormalTypeParameter)
Creates a reference to a simple type<T> CtTypeReference<T>
TypeFactory.createReference(String qualifiedName)
Create a reference to a simple type<T> CtTypeReference<T>
TypeFactory.createReference(CtType<T> type)
Create a reference to a simple type<T> CtTypeReference<T>
TypeFactory.createReference(CtType<T> type, boolean includingFormalTypeParameter)
<T> CtTypeReference<T>
Factory.createSimplyQualifiedReference(String qualifiedName)
<T> CtTypeReference<T>
FactoryImpl.createSimplyQualifiedReference(String qualifiedName)
<T> CtTypeReference<T>
TypeFactory.createSimplyQualifiedReference(String qualifiedName)
Create a reference to a simple type, setting the beginning of its fully qualified name as implicit<T> CtTypeReference<T>
CoreFactory.createTypeReference()
Creates a type reference.<T> CtTypeReference<T>
Factory.createTypeReference()
<T> CtTypeReference<T>
FactoryImpl.createTypeReference()
TypeFactory.dateType()
Returns a reference on the date type.TypeFactory.doublePrimitiveType()
Returns a reference on the double primitive type.TypeFactory.doubleType()
Returns a reference on the double type.TypeFactory.floatPrimitiveType()
Returns a reference on the float primitive type.TypeFactory.floatType()
Returns a reference on the float type.TypeFactory.getDefaultBoundingType()
Returns the default bounding type valueTypeFactory.integerPrimitiveType()
Returns a reference on the integer primitive type.TypeFactory.integerType()
Returns a reference on the integer type.TypeFactory.longPrimitiveType()
Returns a reference on the long primitive type.TypeFactory.longType()
Returns a reference on the long type.TypeFactory.nullType()
Returns a reference on the null type (type of null).TypeFactory.objectType()
Returns a reference on the object type.TypeFactory.shortPrimitiveType()
Returns a reference on the short primitive type.TypeFactory.shortType()
Returns a reference on the short type.TypeFactory.stringType()
Returns a reference on the string type.TypeFactory.voidPrimitiveType()
Returns a reference on the void primitive type.TypeFactory.voidType()
Returns a reference on the void type.Modifier and TypeMethodDescriptionList<CtTypeReference<?>>
Factory.createReferences(List<Class<?>> classes)
List<CtTypeReference<?>>
FactoryImpl.createReferences(List<Class<?>> classes)
List<CtTypeReference<?>>
TypeFactory.createReferences(List<Class<?>> classes)
Creates a collection of type references from a collection of classes.Modifier and TypeMethodDescription<A extends Annotation>
CtAnnotation<A>AnnotationFactory.annotate(CtElement element, CtTypeReference<A> annotationType)
Adds an annotation to an element.<A extends Annotation>
CtAnnotation<A>AnnotationFactory.annotate(CtElement element, CtTypeReference<A> annotationType, String annotationElementName, Object value)
Creates/updates an element's annotation value.<T> CtField<T>
FieldFactory.create(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference<T> type, String name)
Creates a field.<T> CtField<T>
FieldFactory.create(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)
Creates a field.<R, B extends R>
CtMethod<R>MethodFactory.create(CtClass<?> target, Set<ModifierKind> modifiers, CtTypeReference<R> returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock<B> body)
Creates a method.<T> CtMethod<T>
MethodFactory.create(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference<T> returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
Creates an empty method.<A extends Annotation>
CtAnnotation<A>CodeFactory.createAnnotation(CtTypeReference<A> annotationType)
Creates an annotation.<A extends Annotation>
CtAnnotation<A>Factory.createAnnotation(CtTypeReference<A> annotationType)
<A extends Annotation>
CtAnnotation<A>FactoryImpl.createAnnotation(CtTypeReference<A> annotationType)
Factory.createArrayReference(CtTypeReference<?> reference, int n)
<T> CtArrayTypeReference<T[]>
Factory.createArrayReference(CtTypeReference<T> reference)
FactoryImpl.createArrayReference(CtTypeReference<?> reference, int n)
<T> CtArrayTypeReference<T[]>
FactoryImpl.createArrayReference(CtTypeReference<T> reference)
TypeFactory.createArrayReference(CtTypeReference<?> reference, int n)
Creates a reference to a n-dimension array of given type.<T> CtArrayTypeReference<T[]>
TypeFactory.createArrayReference(CtTypeReference<T> reference)
Creates a reference to a one-dimension array of given type.<T> CtCatchVariable<T>
CodeFactory.createCatchVariable(CtTypeReference<T> type, String name, ModifierKind... modifierKinds)
Creates a catch variable declaration.<T> CtCatchVariable<T>
Factory.createCatchVariable(CtTypeReference<T> type, String name, ModifierKind... modifierKinds)
<T> CtCatchVariable<T>
FactoryImpl.createCatchVariable(CtTypeReference<T> type, String name, ModifierKind... modifierKinds)
<T> CtFieldAccess<Class<T>>
CodeFactory.createClassAccess(CtTypeReference<T> type)
Creates a class access expression of the formC.class
.<T> CtFieldAccess<Class<T>>
Factory.createClassAccess(CtTypeReference<T> type)
<T> CtFieldAccess<Class<T>>
FactoryImpl.createClassAccess(CtTypeReference<T> type)
<T> CtConstructorCall<T>
CodeFactory.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)
Creates a constructor call.<T> CtConstructorCall<T>
Factory.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)
<T> CtConstructorCall<T>
FactoryImpl.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)
<T> CtField<T>
CodeFactory.createCtField(String name, CtTypeReference<T> type, String exp, ModifierKind... visibilities)
Creates a field.<T> CtField<T>
Factory.createCtField(String name, CtTypeReference<T> type, String exp, ModifierKind... visibilities)
<T> CtField<T>
FactoryImpl.createCtField(String name, CtTypeReference<T> type, String exp, ModifierKind... visibilities)
Factory.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name)
Factory.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name, CtExpression defaultExpression)
FactoryImpl.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name)
FactoryImpl.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name, CtExpression defaultExpression)
<T> CtLocalVariable<T>
CodeFactory.createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)
Creates a local variable declaration.<T> CtLocalVariable<T>
Factory.createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)
<T> CtLocalVariable<T>
FactoryImpl.createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)
<T> CtLocalVariableReference<T>
CodeFactory.createLocalVariableReference(CtTypeReference<T> type, String name)
Creates a local variable reference with its name an type (weak referencing).<T> CtLocalVariableReference<T>
Factory.createLocalVariableReference(CtTypeReference<T> type, String name)
<T> CtLocalVariableReference<T>
FactoryImpl.createLocalVariableReference(CtTypeReference<T> type, String name)
Factory.createMethod(CtClass<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock body)
Factory.createMethod(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
FactoryImpl.createMethod(CtClass<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock body)
FactoryImpl.createMethod(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
<T> CtParameter<T>
ExecutableFactory.createParameter(CtExecutable<?> parent, CtTypeReference<T> type, String name)
Creates a new parameter.<T> CtParameter<T>
Factory.createParameter(CtExecutable<?> parent, CtTypeReference<T> type, String name)
<T> CtParameter<T>
FactoryImpl.createParameter(CtExecutable<?> parent, CtTypeReference<T> type, String name)
Factory.createProvidedService(CtTypeReference ctTypeReference)
FactoryImpl.createProvidedService(CtTypeReference ctTypeReference)
ModuleFactory.createProvidedService(CtTypeReference typeReference)
<T> CtExecutableReference<T>
ConstructorFactory.createReference(CtTypeReference<T> type, CtExpression<?>... parameters)
Creates a constructor reference.<T> CtExecutableReference<T>
ExecutableFactory.createReference(CtTypeReference<?> declaringType, boolean isStatic, CtTypeReference<T> type, String methodName, List<CtTypeReference<?>> parameterTypes)
Creates an executable reference.<T> CtExecutableReference<T>
ExecutableFactory.createReference(CtTypeReference<?> declaringType, boolean isStatic, CtTypeReference<T> type, String methodName, CtTypeReference<?>... parameterTypes)
Creates an executable reference.<T> CtExecutableReference<T>
ExecutableFactory.createReference(CtTypeReference<?> declaringType, CtTypeReference<T> type, String methodName, List<CtTypeReference<?>> parameterTypes)
Creates an executable reference.<T> CtExecutableReference<T>
ExecutableFactory.createReference(CtTypeReference<?> declaringType, CtTypeReference<T> type, String methodName, CtTypeReference<?>... parameterTypes)
Creates an executable reference.<T> CtFieldReference<T>
FieldFactory.createReference(CtTypeReference<?> declaringType, CtTypeReference<T> type, String fieldName)
Creates a field reference.<T> CtThisAccess<T>
CodeFactory.createThisAccess(CtTypeReference<T> type)
Creates an explicit access to athis
variable (of the formtype.this
).<T> CtThisAccess<T>
CodeFactory.createThisAccess(CtTypeReference<T> type, boolean isImplicit)
Creates an access to athis
variable (of the formtype.this
).<T> CtThisAccess<T>
Factory.createThisAccess(CtTypeReference<T> type)
<T> CtThisAccess<T>
Factory.createThisAccess(CtTypeReference<T> type, boolean isImplicit)
<T> CtThisAccess<T>
FactoryImpl.createThisAccess(CtTypeReference<T> type)
<T> CtThisAccess<T>
FactoryImpl.createThisAccess(CtTypeReference<T> type, boolean isImplicit)
<T> CtTypeAccess<T>
CodeFactory.createTypeAccess(CtTypeReference<T> accessedType)
Creates a accessed type.<T> CtTypeAccess<T>
CodeFactory.createTypeAccess(CtTypeReference<T> accessedType, boolean isImplicit)
Creates a accessed type.<T> CtTypeAccess<T>
Factory.createTypeAccess(CtTypeReference<T> accessedType)
<T> CtTypeAccess<T>
Factory.createTypeAccess(CtTypeReference<T> accessedType, boolean isImplicit)
<T> CtTypeAccess<T>
FactoryImpl.createTypeAccess(CtTypeReference<T> accessedType)
<T> CtTypeAccess<T>
FactoryImpl.createTypeAccess(CtTypeReference<T> accessedType, boolean isImplicit)
<T> CtTypeAccess<T>
CodeFactory.createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType)
Creates a accessed type, seeCodeFactory.createTypeAccess(CtTypeReference)
for details.<T> CtTypeAccess<T>
Factory.createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType)
<T> CtTypeAccess<T>
FactoryImpl.createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType)
Factory.createTypeMemberWildcardImportReference(CtTypeReference<?> typeReference)
FactoryImpl.createTypeMemberWildcardImportReference(CtTypeReference typeReference)
TypeFactory.createTypeMemberWildcardImportReference(CtTypeReference typeReference)
Create a wildcard reference to a simple typeFactory.createUsedService(CtTypeReference typeReference)
FactoryImpl.createUsedService(CtTypeReference typeReference)
ModuleFactory.createUsedService(CtTypeReference typeReference)
Modifier and TypeMethodDescription<T> CtIntersectionTypeReference<T>
Factory.createIntersectionTypeReferenceWithBounds(List<CtTypeReference<?>> bounds)
<T> CtIntersectionTypeReference<T>
FactoryImpl.createIntersectionTypeReferenceWithBounds(List<CtTypeReference<?>> bounds)
<T> CtIntersectionTypeReference<T>
TypeFactory.createIntersectionTypeReferenceWithBounds(List<CtTypeReference<?>> bounds)
Creates an intersection type reference.<T> CtExecutableReference<T>
ExecutableFactory.createReference(CtTypeReference<?> declaringType, boolean isStatic, CtTypeReference<T> type, String methodName, List<CtTypeReference<?>> parameterTypes)
Creates an executable reference.<T> CtExecutableReference<T>
ExecutableFactory.createReference(CtTypeReference<?> declaringType, CtTypeReference<T> type, String methodName, List<CtTypeReference<?>> parameterTypes)
Creates an executable reference. -
Uses of CtTypeReference in spoon.reflect.reference
Modifier and TypeInterfaceDescriptioninterface
This interface defines a reference to an array.interface
This interface defines a reference to an intersection type in generics or in casts.interface
This interface defines a reference to a type parameter (aka generics).interface
Represents a wildcard in generic type annotations, i.e.Modifier and TypeMethodDescription<C extends CtTypeReference<T>>
CCtTypeReference.setDeclaringType(CtTypeReference<?> type)
Sets the reference to the declaring type.<C extends CtTypeReference<T>>
CCtTypeReference.setPackage(CtPackageReference pack)
Sets the reference to the declaring package.Modifier and TypeMethodDescriptionCtTypeReference.box()
Returns the corresponding non-primitive type for a primitive type (the same type otherwise).CtTypeReference.clone()
CtTypeReference.getAccessType()
Computes nearest access path parent to this type from the context of this type reference.CtArrayTypeReference.getArrayType()
Gets the type of the array elements at the finest grain.CtTypeParameterReference.getBoundingType()
A type parameter can have anextends
clause which declare one (CtTypeReference
or more (CtIntersectionTypeReference
references.CtWildcardReference.getBoundingType()
A type parameter can have anextends
clause which declare one (CtTypeReference
or more (CtIntersectionTypeReference
references.CtArrayTypeReference.getComponentType()
Gets the type of the elements contained in this array.CtExecutableReference.getDeclaringType()
Gets the reference to the type that declares this executable.CtFieldReference.getDeclaringType()
Gets the type in which the field is declared.CtTypeReference.getDeclaringType()
Gets the type that declares the referenced type.CtTypeReference.getSuperclass()
CtTypeReference.getTopLevelType()
Returns this, or top level type of this, if this is an inner typeCtExecutableReference.getType()
For methods, gets the return type of the executable (may be null in noclasspath mode).CtVariableReference.getType()
Gets the type of the variable.CtTypeMemberWildcardImportReference.getTypeReference()
CtTypeReference.setSimplyQualified(boolean isSimplyQualified)
CtTypeReference.unbox()
Returns the primitive type for a boxing type (unchanged if the type does not correspond to a boxing type).Modifier and TypeMethodDescriptionList<CtTypeReference<?>>
CtActualTypeContainer.getActualTypeArguments()
Gets the type arguments.List<CtTypeReference<?>>
CtIntersectionTypeReference.getBounds()
Gets the bounds of the intersection type.List<CtTypeReference<?>>
CtExecutableReference.getParameters()
Gets parameters of the executable.Set<CtTypeReference<?>>
CtTypeReference.getSuperInterfaces()
Modifier and TypeMethodDescription<T extends CtActualTypeContainer>
TCtActualTypeContainer.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
Adds a type argument.<C extends CtIntersectionTypeReference>
CCtIntersectionTypeReference.addBound(CtTypeReference<?> bound)
Adds a bound.boolean
CtTypeReference.canAccess(CtTypeReference<?> type)
Checks visibility based on public, protected, package protected and private modifiers of type<S extends T>
CtExecutableReference<S>CtExecutableReference.getOverridingExecutable(CtTypeReference<?> subType)
Gets an overriding executable for this executable from a given subtype, if exists.boolean
CtActualTypeContainer.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
Removes a type argument.boolean
CtIntersectionTypeReference.removeBound(CtTypeReference<?> bound)
Removes a bound.<T extends CtWildcardReference>
TCtWildcardReference.setBoundingType(CtTypeReference<?> superType)
Sets theextends
clause of the type parameter.<C extends CtArrayTypeReference<T>>
CCtArrayTypeReference.setComponentType(CtTypeReference<?> componentType)
Sets the type of the elements contained in this array.<C extends CtExecutableReference<T>>
CCtExecutableReference.setDeclaringType(CtTypeReference<?> declaringType)
Sets the declaring type.<C extends CtFieldReference<T>>
CCtFieldReference.setDeclaringType(CtTypeReference<?> declaringType)
Sets the type in which the field is declared.<C extends CtTypeReference<T>>
CCtTypeReference.setDeclaringType(CtTypeReference<?> type)
Sets the reference to the declaring type.<C extends CtExecutableReference<T>>
CCtExecutableReference.setType(CtTypeReference type)
Sets the type of the variable.<C extends CtVariableReference<T>>
CCtVariableReference.setType(CtTypeReference type)
Sets the type of the variable.CtTypeMemberWildcardImportReference.setTypeReference(CtTypeReference<?> typeReference)
Modifier and TypeMethodDescription<T extends CtActualTypeContainer>
TCtActualTypeContainer.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
Sets the type arguments.<T extends CtActualTypeContainer>
TCtTypeParameterReference.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<C extends CtIntersectionTypeReference>
CCtIntersectionTypeReference.setBounds(List<CtTypeReference<?>> bounds)
Sets the bounds of the intersection type.<C extends CtExecutableReference<T>>
CCtExecutableReference.setParameters(List<CtTypeReference<?>> parameters)
Sets parameters of the executable. -
Uses of CtTypeReference in spoon.reflect.visitor
Modifier and TypeFieldDescriptionprotected Map<String,CtTypeReference<?>>
ImportScannerImpl.classImports
Modifier and TypeMethodDescriptionstatic Optional<CtTypeReference<?>>
OperatorHelper.getPromotedType(BinaryOperatorKind operator, CtExpression<?> left, CtExpression<?> right)
Get the promoted type of the binary operator, as defined by the Java Language Specification.static Optional<CtTypeReference<?>>
OperatorHelper.getPromotedType(UnaryOperatorKind operator, CtExpression<?> operand)
Gets the promoted type of the unary operator, as defined by the Java Language Specification.Modifier and TypeMethodDescriptionprotected boolean
ImportScannerImpl.addClassImport(CtTypeReference<?> ref)
Adds a type to the classImports.protected boolean
ImportScannerImpl.classNamePresentInJavaLang(CtTypeReference<?> ref)
protected void
ForceFullyQualifiedProcessor.handleTypeReference(CtTypeReference<?> reference, LexicalScope nameScope, CtRole role)
protected void
ForceImportProcessor.handleTypeReference(CtTypeReference<?> reference, LexicalScope nameScope, CtRole role)
protected void
ImportCleaner.handleTypeReference(CtTypeReference<?> reference, ImportCleaner.Context context, CtRole role)
protected void
ImportConflictDetector.handleTypeReference(CtTypeReference<?> ref, LexicalScope nameScope, CtRole role)
protected boolean
ImportScannerImpl.isImportedInClassImports(CtTypeReference<?> ref)
boolean
PrintingContext.isInCurrentScope(CtTypeReference<?> typeRef)
protected boolean
ForceFullyQualifiedProcessor.isTypeReferenceToEnclosingType(LexicalScope nameScope, CtTypeReference<?> reference)
<T> void
CtAbstractVisitor.visitCtTypeReference(CtTypeReference<T> reference)
<T> void
CtBiScannerDefault.visitCtTypeReference(CtTypeReference<T> reference)
<T> void
CtInheritanceScanner.visitCtTypeReference(CtTypeReference<T> e)
<T> void
CtScanner.visitCtTypeReference(CtTypeReference<T> reference)
<T> void
CtVisitor.visitCtTypeReference(CtTypeReference<T> reference)
Visits a reference to a type.<T> void
DefaultJavaPrettyPrinter.visitCtTypeReference(CtTypeReference<T> ref)
<T> void
ImportScannerImpl.visitCtTypeReference(CtTypeReference<T> reference)
<T> void
CtAbstractImportVisitor.visitTypeImport(CtTypeReference<T> typeReference)
<T> void
CtImportVisitor.visitTypeImport(CtTypeReference<T> typeReference)
Called for import like:import apackage.Type;
-
Uses of CtTypeReference in spoon.reflect.visitor.filter
Modifier and TypeMethodDescriptionprotected void
SuperInheritanceHierarchyFunction.sendResult(CtTypeReference<?> typeRef, CtConsumer<Object> outputConsumer)
protected void
SuperInheritanceHierarchyFunction.visitSuperClasses(CtTypeReference<?> superTypeRef, CtConsumer<Object> outputConsumer, boolean includingInterfaces)
calls `outputConsumer.accept(superClass)` for all super classes of superType.protected void
SuperInheritanceHierarchyFunction.visitSuperInterfaces(CtTypeReference<?> type, CtConsumer<Object> outputConsumer)
calls `outputConsumer.accept(interface)` for all superInterfaces of type recursively.ModifierConstructorDescriptionLambdaFilter(CtTypeReference<?> iface)
Matches all lambdas implementing `iface` UseLambdaFilter.addImplementingInterface(CtTypeInformation)
to define set of interfaces whose lambdas it is search forSubtypeFilter(CtTypeReference<?> superType)
-
Uses of CtTypeReference in spoon.support
Modifier and TypeMethodDescription<T> CtTypeReference<T>
DefaultCoreFactory.createTypeReference()
-
Uses of CtTypeReference in spoon.support.adaption
Modifier and TypeMethodDescriptionAdapts a type from a supertype to the context of this adaptor.TypeAdaptor.adaptType(CtTypeReference<?> superRef)
Adapts a type from a supertype to the context of this adaptor.Modifier and TypeMethodDescriptionTypeAdaptor.adaptType(CtTypeReference<?> superRef)
Adapts a type from a supertype to the context of this adaptor.static boolean
TypeAdaptor.isSubtype(CtType<?> base, CtTypeReference<?> superRef)
Checks whether the base is a subtype of the passed superref.boolean
TypeAdaptor.isSubtypeOf(CtTypeReference<?> superRef)
Checks if the context of this type adapter is a subtype of the passed superRef.ModifierConstructorDescriptionTypeAdaptor(CtTypeReference<?> hierarchyStart)
Creates a new type adaptor using the given reference as the start of its hierarchy. -
Uses of CtTypeReference in spoon.support.compiler
Modifier and TypeMethodDescriptionstatic CtStatement
SnippetCompilationHelper.compileStatement(CtCodeSnippetStatement st, CtTypeReference returnType)
-
Uses of CtTypeReference in spoon.support.compiler.jdt
Modifier and TypeMethodDescription<T> CtTypeReference<T>
ReferenceBuilder.getTypeReference(String name)
Try to build a CtTypeReference from a simple name with specified generic types but returns null if the name doesn't correspond to a type (not start by an upper case). -
Uses of CtTypeReference in spoon.support.reflect.code
Modifier and TypeMethodDescriptionCtTypeAccessImpl.getAccessedType()
CtAssignmentImpl.getType()
CtCatchVariableImpl.getType()
CtConstructorCallImpl.getType()
CtExpressionImpl.getType()
CtInvocationImpl.getType()
CtLocalVariableImpl.getType()
CtTypeAccessImpl.getType()
CtVariableAccessImpl.getType()
Modifier and TypeMethodDescriptionList<CtTypeReference<?>>
CtConstructorCallImpl.getActualTypeArguments()
List<CtTypeReference<?>>
CtInvocationImpl.getActualTypeArguments()
List<CtTypeReference<?>>
CtCatchVariableImpl.getMultiTypes()
Set<CtTypeReference<? extends Throwable>>
CtLambdaImpl.getThrownTypes()
List<CtTypeReference<?>>
CtAssignmentImpl.getTypeCasts()
List<CtTypeReference<?>>
CtExpressionImpl.getTypeCasts()
Modifier and TypeMethodDescription<T extends CtActualTypeContainer>
TCtConstructorCallImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<T extends CtActualTypeContainer>
TCtInvocationImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<T extends CtMultiTypedElement>
TCtCatchVariableImpl.addMultiType(CtTypeReference<?> type)
<C extends CtExecutable<T>>
CCtLambdaImpl.addThrownType(CtTypeReference<? extends Throwable> throwType)
<C extends CtExpression<T>>
CCtAssignmentImpl.addTypeCast(CtTypeReference<?> type)
<C extends CtExpression<T>>
CCtExpressionImpl.addTypeCast(CtTypeReference<?> type)
boolean
CtConstructorCallImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean
CtInvocationImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean
CtCatchVariableImpl.removeMultiType(CtTypeReference<?> ref)
boolean
CtLambdaImpl.removeThrownType(CtTypeReference<? extends Throwable> throwType)
<C extends CtTypeAccess<A>>
CCtTypeAccessImpl.setAccessedType(CtTypeReference<A> accessedType)
<C extends CtTypedElement>
CCtAssignmentImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtCatchVariableImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtConstructorCallImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtExpressionImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtInvocationImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtLambdaImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtLocalVariableImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtTypeAccessImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtVariableAccessImpl.setType(CtTypeReference type)
Modifier and TypeMethodDescription<T extends CtActualTypeContainer>
TCtConstructorCallImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<T extends CtActualTypeContainer>
TCtInvocationImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<T extends CtMultiTypedElement>
TCtCatchVariableImpl.setMultiTypes(List<CtTypeReference<?>> types)
<C extends CtExecutable<T>>
CCtLambdaImpl.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<C extends CtExpression<T>>
CCtAssignmentImpl.setTypeCasts(List<CtTypeReference<?>> casts)
<C extends CtExpression<T>>
CCtExpressionImpl.setTypeCasts(List<CtTypeReference<?>> casts)
-
Uses of CtTypeReference in spoon.support.reflect.declaration
Modifier and TypeMethodDescriptionCtAnnotationImpl.getAnnotationType()
CtTypeImpl.getReference()
CtProvidedServiceImpl.getServiceType()
CtUsedServiceImpl.getServiceType()
CtAnnotationTypeImpl.getSuperclass()
CtClassImpl.getSuperclass()
CtEnumImpl.getSuperclass()
CtRecordImpl.getSuperclass()
CtTypeImpl.getSuperclass()
CtTypeParameterImpl.getSuperclass()
CtAnonymousExecutableImpl.getType()
CtConstructorImpl.getType()
CtFieldImpl.getType()
CtMethodImpl.getType()
CtParameterImpl.getType()
CtRecordComponentImpl.getType()
InvisibleArrayConstructorImpl.getType()
CtTypeImpl.getTypeErasure()
CtTypeParameterImpl.getTypeErasure()
Modifier and TypeMethodDescriptionList<CtTypeReference<?>>
CtCompilationUnitImpl.getDeclaredTypeReferences()
CtProvidedServiceImpl.getImplementationTypes()
Set<CtTypeReference<?>>
CtClassImpl.getPermittedTypes()
Set<CtTypeReference<?>>
CtEnumImpl.getPermittedTypes()
Set<CtTypeReference<?>>
CtInterfaceImpl.getPermittedTypes()
Set<CtTypeReference<?>>
CtRecordImpl.getPermittedTypes()
Set<CtTypeReference<?>>
CtElementImpl.getReferencedTypes()
Set<CtTypeReference<?>>
CtAnnotationTypeImpl.getSuperInterfaces()
Set<CtTypeReference<?>>
CtTypeImpl.getSuperInterfaces()
Set<CtTypeReference<?>>
CtTypeParameterImpl.getSuperInterfaces()
Set<CtTypeReference<? extends Throwable>>
CtAnnotationMethodImpl.getThrownTypes()
Set<CtTypeReference<? extends Throwable>>
CtAnonymousExecutableImpl.getThrownTypes()
Set<CtTypeReference<? extends Throwable>>
CtExecutableImpl.getThrownTypes()
List<CtTypeReference<?>>
CtAnnotationImpl.getTypeCasts()
Set<CtTypeReference<?>>
CtTypeImpl.getUsedTypes(boolean includeSamePackage)
Modifier and TypeMethodDescriptionCtCompilationUnitImpl.addDeclaredTypeReference(CtTypeReference<?> type)
<T extends CtProvidedService>
TCtProvidedServiceImpl.addImplementationType(CtTypeReference usedType)
CtClassImpl.addPermittedType(CtTypeReference<?> type)
CtEnumImpl.addPermittedType(CtTypeReference<?> type)
CtInterfaceImpl.addPermittedType(CtTypeReference<?> type)
CtRecordImpl.addPermittedType(CtTypeReference<?> type)
CtTypeImpl.addSuperInterface(CtTypeReference<S> interfac)
CtTypeParameterImpl.addSuperInterface(CtTypeReference<S> interfac)
CtAnonymousExecutableImpl.addThrownType(CtTypeReference throwType)
<T extends CtExecutable<R>>
TCtExecutableImpl.addThrownType(CtTypeReference<? extends Throwable> throwType)
<A extends Annotation>
CtAnnotation<A>CtElementImpl.getAnnotation(CtTypeReference<A> annotationType)
CtClassImpl.getConstructor(CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>
CtEnumImpl.getMethod(String name, CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>
CtEnumImpl.getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>
CtTypeImpl.getMethod(String name, CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>
CtTypeImpl.getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>
CtTypeParameterImpl.getMethod(String name, CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>
CtTypeParameterImpl.getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes)
CtTypeImpl.getMethodsAnnotatedWith(CtTypeReference<?>... annotationTypes)
CtTypeParameterImpl.getMethodsAnnotatedWith(CtTypeReference<?>... annotationTypes)
protected boolean
CtTypeImpl.hasSameParameters(CtExecutable<?> candidate, CtTypeReference<?>... parameterTypes)
boolean
CtAnnotationTypeImpl.isSubtypeOf(CtTypeReference<?> type)
boolean
CtClassImpl.isSubtypeOf(CtTypeReference<?> type)
boolean
CtEnumImpl.isSubtypeOf(CtTypeReference<?> type)
boolean
CtInterfaceImpl.isSubtypeOf(CtTypeReference<?> type)
boolean
CtTypeParameterImpl.isSubtypeOf(CtTypeReference<?> superTypeRef)
CtClassImpl.removePermittedType(CtTypeReference<?> type)
CtEnumImpl.removePermittedType(CtTypeReference<?> type)
CtInterfaceImpl.removePermittedType(CtTypeReference<?> type)
CtRecordImpl.removePermittedType(CtTypeReference<?> type)
<S> boolean
CtTypeImpl.removeSuperInterface(CtTypeReference<S> interfac)
<S> boolean
CtTypeParameterImpl.removeSuperInterface(CtTypeReference<S> interfac)
boolean
CtAnonymousExecutableImpl.removeThrownType(CtTypeReference throwType)
boolean
CtExecutableImpl.removeThrownType(CtTypeReference<? extends Throwable> throwType)
<T extends CtAnnotation<A>>
TCtAnnotationImpl.setAnnotationType(CtTypeReference<? extends Annotation> annotationType)
<T extends CtProvidedService>
TCtProvidedServiceImpl.setServiceType(CtTypeReference providingType)
<T extends CtUsedService>
TCtUsedServiceImpl.setServiceType(CtTypeReference usedService)
CtAnnotationTypeImpl.setSuperclass(CtTypeReference<?> superClass)
CtClassImpl.setSuperclass(CtTypeReference<?> superClass)
CtEnumImpl.setSuperclass(CtTypeReference<?> superClass)
CtInterfaceImpl.setSuperclass(CtTypeReference<?> superClass)
CtRecordImpl.setSuperclass(CtTypeReference<?> superClass)
CtTypeImpl.setSuperclass(CtTypeReference<?> superClass)
CtTypeParameterImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtTypedElement>
CCtAnonymousExecutableImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtConstructorImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtFieldImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtMethodImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtParameterImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CCtRecordComponentImpl.setType(CtTypeReference type)
<C extends CtTypedElement>
CInvisibleArrayConstructorImpl.setType(CtTypeReference type)
Modifier and TypeMethodDescriptionCtCompilationUnitImpl.setDeclaredTypeReferences(List<CtTypeReference<?>> types)
<T extends CtProvidedService>
TCtProvidedServiceImpl.setImplementationTypes(List<CtTypeReference> usedTypes)
CtClassImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtEnumImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtInterfaceImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtRecordImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtAnnotationTypeImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
CtTypeImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
CtTypeParameterImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<U extends CtExecutable<T>>
UCtAnnotationMethodImpl.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<T extends CtExecutable<R>>
TCtExecutableImpl.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<C extends CtExpression<A>>
CCtAnnotationImpl.setTypeCasts(List<CtTypeReference<?>> casts)
-
Uses of CtTypeReference in spoon.support.reflect.reference
Modifier and TypeClassDescriptionclass
class
class
class
class
Modifier and TypeMethodDescription<C extends CtTypeReference<T>>
CCtTypeReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType)
<C extends CtTypeReference<T>>
CCtTypeReferenceImpl.setPackage(CtPackageReference pack)
Modifier and TypeMethodDescriptionCtTypeReferenceImpl.box()
CtTypeReferenceImpl.clone()
CtTypeReferenceImpl.getAccessType()
CtArrayTypeReferenceImpl.getArrayType()
CtTypeParameterReferenceImpl.getBoundingType()
CtWildcardReferenceImpl.getBoundingType()
CtArrayTypeReferenceImpl.getComponentType()
CtExecutableReferenceImpl.getDeclaringType()
CtFieldReferenceImpl.getDeclaringType()
CtTypeReferenceImpl.getDeclaringType()
CtTypeReferenceImpl.getSuperclass()
CtTypeReferenceImpl.getTopLevelType()
CtExecutableReferenceImpl.getType()
CtVariableReferenceImpl.getType()
CtArrayTypeReferenceImpl.getTypeErasure()
CtIntersectionTypeReferenceImpl.getTypeErasure()
CtTypeParameterReferenceImpl.getTypeErasure()
CtTypeReferenceImpl.getTypeErasure()
CtTypeMemberWildcardImportReferenceImpl.getTypeReference()
CtTypeReferenceImpl.unbox()
Modifier and TypeMethodDescriptionList<CtTypeReference<?>>
CtExecutableReferenceImpl.getActualTypeArguments()
List<CtTypeReference<?>>
CtTypeParameterReferenceImpl.getActualTypeArguments()
List<CtTypeReference<?>>
CtTypeReferenceImpl.getActualTypeArguments()
List<CtTypeReference<?>>
CtIntersectionTypeReferenceImpl.getBounds()
List<CtTypeReference<?>>
CtExecutableReferenceImpl.getParameters()
Set<CtTypeReference<?>>
CtTypeReferenceImpl.getSuperInterfaces()
Modifier and TypeMethodDescription<C extends CtActualTypeContainer>
CCtExecutableReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<C extends CtActualTypeContainer>
CCtTypeParameterReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<C extends CtActualTypeContainer>
CCtTypeReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<C extends CtIntersectionTypeReference>
CCtIntersectionTypeReferenceImpl.addBound(CtTypeReference<?> bound)
boolean
CtTypeReferenceImpl.canAccess(CtTypeReference<?> type)
<S extends T>
CtExecutableReference<S>CtExecutableReferenceImpl.getOverridingExecutable(CtTypeReference<?> subType)
boolean
CtTypeParameterReferenceImpl.isSubtypeOf(CtTypeReference<?> type)
boolean
CtTypeReferenceImpl.isSubtypeOf(CtTypeReference<?> type)
boolean
CtExecutableReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean
CtTypeParameterReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean
CtTypeReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean
CtIntersectionTypeReferenceImpl.removeBound(CtTypeReference<?> bound)
<T extends CtWildcardReference>
TCtWildcardReferenceImpl.setBoundingType(CtTypeReference<?> superType)
<C extends CtArrayTypeReference<T>>
CCtArrayTypeReferenceImpl.setComponentType(CtTypeReference<?> componentType)
<C extends CtExecutableReference<T>>
CCtExecutableReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType)
<C extends CtFieldReference<T>>
CCtFieldReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType)
<C extends CtTypeReference<T>>
CCtTypeReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType)
<C extends CtExecutableReference<T>>
CCtExecutableReferenceImpl.setType(CtTypeReference type)
<C extends CtVariableReference<T>>
CCtVariableReferenceImpl.setType(CtTypeReference type)
CtTypeMemberWildcardImportReferenceImpl.setTypeReference(CtTypeReference<?> typeReference)
Modifier and TypeMethodDescription<C extends CtActualTypeContainer>
CCtExecutableReferenceImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<C extends CtActualTypeContainer>
CCtTypeParameterReferenceImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<C extends CtActualTypeContainer>
CCtTypeReferenceImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<C extends CtIntersectionTypeReference>
CCtIntersectionTypeReferenceImpl.setBounds(List<CtTypeReference<?>> bounds)
<C extends CtExecutableReference<T>>
CCtExecutableReferenceImpl.setParameters(List<CtTypeReference<?>> parameters)
-
Uses of CtTypeReference in spoon.support.visitor
Modifier and TypeMethodDescriptionGenericTypeAdapter.adaptType(CtTypeInformation type)
adapts `type` to theCtTypeReference
of the scope of thisGenericTypeAdapter
This mapping function is able to resolveCtTypeParameter
of:
A) input type or any super class or any enclosing class of input type or it's super class
B) super interfaces of input type or super interfaces of it's super classes.
The type reference is adapted recursive including all it's actual type arguments and bounds.protected @Nullable CtTypeReference<?>
ClassTypingContext.adaptTypeParameter(CtTypeParameter typeParam)
adapts `typeParam` to theCtTypeReference
of scope of thisClassTypingContext
In can beCtTypeParameterReference
again - depending actual type arguments of thisClassTypingContext
.protected @Nullable CtTypeReference<?>
MethodTypingContext.adaptTypeParameter(CtTypeParameter typeParam)
Adapts `typeParam` to theCtTypeReference
of scope of thisMethodTypingContext
In can beCtTypeParameterReference
again - depending actual type arguments of thisMethodTypingContext
.Modifier and TypeMethodDescriptionSet<CtTypeReference<?>>
TypeReferenceScanner.getReferences()
Returns the set of calculated references.@Nullable List<CtTypeReference<?>>
ClassTypingContext.resolveActualTypeArgumentsOf(CtTypeReference<?> typeRef)
resolve actual type argument values of the provided type referenceModifier and TypeMethodDescriptionprotected ClassTypingContext
ClassTypingContext.createEnclosingHierarchy(CtTypeReference<?> enclosingTypeRef)
might be used to create custom chain of super type hierarchiesboolean
ClassTypingContext.isSubtypeOf(CtTypeReference<?> superTypeRef)
detects if `superTypeRef` is a super type of the type or type reference, which was send to constructor of this instance.@Nullable List<CtTypeReference<?>>
ClassTypingContext.resolveActualTypeArgumentsOf(CtTypeReference<?> typeRef)
resolve actual type argument values of the provided type reference<T> void
SignaturePrinter.visitCtTypeReference(CtTypeReference<T> reference)
<T> void
TypeReferenceScanner.visitCtTypeReference(CtTypeReference<T> reference)
ModifierConstructorDescriptionTypeReferenceScanner(HashSet<CtTypeReference<?>> references)
Constructor. -
Uses of CtTypeReference in spoon.support.visitor.clone
Modifier and TypeMethodDescription<T> void
CloneBuilder.visitCtTypeReference(CtTypeReference<T> e)
<T> void
CloneVisitor.visitCtTypeReference(CtTypeReference<T> reference)
-
Uses of CtTypeReference in spoon.support.visitor.java.internal
Modifier and TypeMethodDescriptionvoid
AnnotationRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> typeReference)
void
ExecutableRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> typeReference)
void
RecordComponentRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)
void
RuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)
void
TypeReferenceRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)
void
TypeRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> typeReference)
void
VariableRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)
ModifierConstructorDescriptionTypeReferenceRuntimeBuilderContext(Type type, CtTypeReference<?> typeReference)
-
Uses of CtTypeReference in spoon.support.visitor.replace
Modifier and TypeMethodDescription<T> void
ReplacementVisitor.visitCtTypeReference(CtTypeReference<T> reference)
-
Uses of CtTypeReference in spoon.template
Modifier and TypeMethodDescriptionstatic void
Substitution.redirectTypeReferences(CtElement element, CtTypeReference<?> source, CtTypeReference<?> target)
A helper method that recursively redirects all the type references from a source type to a target type in the given element.static CtBlock<?>
Substitution.substituteMethodBody(CtClass<?> targetClass, Template<?> template, String executableName, CtTypeReference<?>... parameterTypes)
Gets a body from a template executable with all the template parameters substituted.static CtStatement
Substitution.substituteStatement(CtClass<?> targetClass, Template<?> template, int statementIndex, String executableName, CtTypeReference<?>... parameterTypes)
Gets a statement from a template executable with all the template parameters substituted.