Uses of Interface
spoon.reflect.declaration.CtType

Packages that use CtType

Package	Description
spoon	This root package provides the default integrated launchers for Spoon program processing.
spoon.metamodel	Ready to go meta? This package contains classes that model the Spoon metamodel itself.
spoon.pattern
spoon.pattern.internal
spoon.refactoring
spoon.reflect	This package defines the Spoon's compile-time meta-model of Java programs.
spoon.reflect.declaration	This package contains the meta-model part that models the declarations (program's structures such as classes, fields, etc).
spoon.reflect.factory	This package defines all the sub-factories for the Spoon meta-model.
spoon.reflect.reference	This package defines the references to program elements for the meta-model.
spoon.reflect.visitor	This package defines visitor, scanner, and scanner-based query API for Java programs reified in the meta-model.
spoon.reflect.visitor.filter	This package contains a set of useful filters when querying the model.
spoon.support	This package contains some default implementations for commonly used processing tasks.
spoon.support.adaption
spoon.support.compiler
spoon.support.compiler.jdt
spoon.support.reflect.code
spoon.support.reflect.declaration
spoon.support.reflect.reference
spoon.support.sniper	This package provides support for the sniper mode: only the transformed part of classes is rewritten to disk.
spoon.support.visitor
spoon.support.visitor.clone
spoon.support.visitor.java
spoon.support.visitor.java.internal
spoon.template	This package defines a framework for well-typed pure-Java templates.
spoon.testing.utils

Uses of CtType in spoon

Method parameters in spoon with type arguments of type CtType

Modifier and Type	Method	Description
void	SpoonModelBuilder.generateProcessedSourceFiles(OutputType outputType, Filter<CtType<?>> typeFilter)	Generates the source code associated to the classes stored in this compiler's factory.
void	Launcher.setOutputFilter(Filter<CtType<?>> typeFilter)
void	SpoonAPI.setOutputFilter(Filter<CtType<?>> typeFilter)	Applies a filter when the output-type is defined on classes.

Uses of CtType in spoon.metamodel

Methods in spoon.metamodel that return types with arguments of type CtType

Modifier and Type	Method	Description
List<CtType<? extends CtElement>>	Metamodel.getAllInstantiableMetamodelInterfaces()
static Set<CtType<?>>	Metamodel.getAllMetamodelInterfaces()	Returns all interfaces of the Spoon metamodel.

Methods in spoon.metamodel with parameters of type CtType

Modifier and Type	Method	Description
static String	Metamodel.getConceptName(CtType<?> type)

Uses of CtType in spoon.pattern

Methods in spoon.pattern with type parameters of type CtType

Modifier and Type	Method	Description
<T extends CtType<?>> T	Generator.generate(String typeQualifiedName, Map<String,Object> params)	Generates a type with qualified name `typeQualifiedName` by replacing the generator parameters with the arguments given in `params`.

Methods in spoon.pattern with parameters of type CtType

Modifier and Type	Method	Description
PatternParameterConfigurator	PatternParameterConfigurator.byLocalType(CtType<?> searchScope, String localTypeSimpleName)	Searches for a type visible in scope `templateType`, whose simple name is equal to `localTypeSimpleName`

Constructors in spoon.pattern with parameters of type CtType

Modifier	Constructor	Description
	PatternBuilderHelper(CtType<?> templateTemplate)

Uses of CtType in spoon.pattern.internal

Methods in spoon.pattern.internal with type parameters of type CtType

Modifier and Type	Method	Description
<T extends CtType<?>> T	DefaultGenerator.generate(String typeQualifiedName, Map<String,Object> params)

Uses of CtType in spoon.refactoring

Methods in spoon.refactoring that return CtType

Modifier and Type	Method	Description
static CtType<?>	Refactoring.copyType(CtType<?> type)	See doc in copyType()

Methods in spoon.refactoring that return types with arguments of type CtType

Modifier and Type	Method	Description
Collection<CtType<?>>	MethodCallState.getCallerFields()	Returns a collection containing all types invoking the method with a field.

Methods in spoon.refactoring with parameters of type CtType

Modifier and Type	Method	Description
void	MethodCallState.add(CtType<?> type)	Adds a CtType to the fields invoking this method.
static void	Refactoring.changeTypeName(CtType<?> type, String name)	Changes name of a type element.
boolean	MethodCallState.contains(CtType<?> o)
static CtType<?>	Refactoring.copyType(CtType<?> type)	See doc in copyType()
void	MethodCallState.remove(CtType<?> o)

Uses of CtType in spoon.reflect

Methods in spoon.reflect that return types with arguments of type CtType

Modifier and Type	Method	Description
Collection<CtType<?>>	CtModel.getAllTypes()	returns all top-level types of the model
Collection<CtType<?>>	CtModelImpl.getAllTypes()

Uses of CtType in spoon.reflect.declaration

Subinterfaces of CtType in spoon.reflect.declaration

Modifier and Type	Interface	Description
interface	CtAnnotationType<T extends Annotation>	This element defines an annotation type.
interface	CtClass<T>	This element represents a class declaration.
interface	CtEnum<T extends Enum<?>>	This element represents an enumeration declaration.
interface	CtInterface<T>	This element defines an interface declaration.
interface	CtRecord	This element represents a record declaration.
interface	CtTypeParameter	This element defines a declaration of a type parameter (aka generics).

Methods in spoon.reflect.declaration with type parameters of type CtType

Modifier and Type	Method	Description
<F, C extends CtType<T>> C	CtType.addField(int index, CtField<F> field)	add a field at a given position.
<F, C extends CtType<T>> C	CtType.addField(CtField<F> field)	add a field at the end of the field list.
<F, C extends CtType<T>> C	CtType.addFieldAtTop(CtField<F> field)	Adds a field at the top of the type (before static block).
<F, C extends CtType<Object>> C	CtTypeParameter.addFieldAtTop(CtField<F> field)
<M, C extends CtType<T>> C	CtAnnotationType.addMethod(CtMethod<M> method)	Adds a method to this type.
<M, C extends CtType<T>> C	CtType.addMethod(CtMethod<M> method)	Adds a method to this type.
<M, C extends CtType<Object>> C	CtTypeParameter.addMethod(CtMethod<M> method)
<N, C extends CtType<T>> C	CtType.addNestedType(CtType<N> nestedType)	Add a nested type.
<N, C extends CtType<Object>> C	CtTypeParameter.addNestedType(CtType<N> nestedType)
<S, C extends CtType<T>> C	CtType.addSuperInterface(CtTypeReference<S> interfac)
<S, C extends CtType<Object>> C	CtTypeParameter.addSuperInterface(CtTypeReference<S> interfac)
<C extends CtType<T>> C	CtType.addTypeMember(CtTypeMember member)	Adds a type member at the end of all type member of the type.
<C extends CtType<T>> C	CtType.addTypeMemberAt(int position, CtTypeMember member)	Adds a type member at a given position.
<N extends CtType<?>> N	CtType.getNestedType(String name)	Gets a nested type from its name.
<T extends CtType<?>> T	CtPackage.getType(String simpleName)	Finds a top-level type by name.
<C extends CtType<T>> C	CtType.setFields(List<CtField<?>> fields)	Sets all fields in the type.
<C extends CtType<Object>> C	CtTypeParameter.setFields(List<CtField<?>> fields)
<C extends CtType<T>> C	CtAnnotationType.setMethods(Set<CtMethod<?>> methods)	Sets the methods of this type.
<C extends CtType<T>> C	CtType.setMethods(Set<CtMethod<?>> methods)	Sets the methods of this type.
<C extends CtType<Object>> C	CtTypeParameter.setMethods(Set<CtMethod<?>> methods)
<C extends CtType<T>> C	CtType.setNestedTypes(Set<CtType<?>> nestedTypes)	Sets all nested types.
<C extends CtType<Object>> C	CtTypeParameter.setNestedTypes(Set<CtType<?>> nestedTypes)
<C extends CtType<T>> C	CtAnnotationType.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtEnum.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtInterface.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<Object>> C	CtRecord.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtType.setSuperclass(CtTypeReference<?> superClass)	Sets the superclass type.
<C extends CtType<T>> C	CtAnnotationType.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<C extends CtType<T>> C	CtType.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)	Sets the super interfaces of this type.
<C extends CtType<Object>> C	CtTypeParameter.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<C extends CtType<T>> C	CtType.setTypeMembers(List<CtTypeMember> members)	Removes all types members with these new members.
<C extends CtType<Object>> C	CtTypeParameter.setTypeMembers(List<CtTypeMember> members)

Methods in spoon.reflect.declaration that return CtType

Modifier and Type	Method	Description
CtType<T>	CtType.clone()
CtType<?>	CtType.copyType()	Copy the type, where copy means cloning + porting all the references in the clone from the old type to the new type.
CtType<?>	CtTypeMember.getDeclaringType()	Gets the type that declares this class member.
CtType<?>	CtCompilationUnit.getMainType()	Searches and returns the main type (the type which has the same name as the file).
<T> CtType<T>	CtTypeMember.getTopLevelType()	Returns the top level type declaring this type if an inner type or type member.

Methods in spoon.reflect.declaration that return types with arguments of type CtType

Modifier and Type	Method	Description
List<CtType<?>>	CtCompilationUnit.getDeclaredTypes()	Gets all the types declared in this compilation unit.
Set<CtType<?>>	CtType.getNestedTypes()	Returns the declarations of the nested classes and interfaces that are directly declared by this class or interface.
Set<CtType<?>>	CtPackage.getTypes()	Returns the set of the top-level types in this package.

Methods in spoon.reflect.declaration with parameters of type CtType

Modifier and Type	Method	Description
CtCompilationUnit	CtCompilationUnit.addDeclaredType(CtType<?> type)	Add a type to the list of declared types.
<N, C extends CtType<T>> C	CtType.addNestedType(CtType<N> nestedType)	Add a nested type.
<N, C extends CtType<Object>> C	CtTypeParameter.addNestedType(CtType<N> nestedType)
<T extends CtPackage> T	CtPackage.addType(CtType<?> type)	Adds a type to this package.
<N> boolean	CtType.removeNestedType(CtType<N> nestedType)	Remove a nested type.
void	CtPackage.removeType(CtType<?> type)	Removes a type from this package.

Method parameters in spoon.reflect.declaration with type arguments of type CtType

Modifier and Type	Method	Description
CtCompilationUnit	CtCompilationUnit.setDeclaredTypes(List<CtType<?>> types)	Sets the types declared in this compilation unit.
<C extends CtType<T>> C	CtType.setNestedTypes(Set<CtType<?>> nestedTypes)	Sets all nested types.
<C extends CtType<Object>> C	CtTypeParameter.setNestedTypes(Set<CtType<?>> nestedTypes)
<T extends CtPackage> T	CtPackage.setTypes(Set<CtType<?>> types)	Sets the types defined in the package.

Uses of CtType in spoon.reflect.factory

Methods in spoon.reflect.factory that return CtType

Modifier and Type	Method	Description
<T> CtType<T>	TypeFactory.get(Class<?> cl)	Gets a type from its runtime Java class.
<T> CtType<T>	TypeFactory.get(String qualifiedName)	Gets a created type from its qualified name if source in the source classpath.
<T extends Annotation> CtType<T>	AnnotationFactory.getAnnotationType(String qualifiedName)	Gets a annotation type from its name.

Methods in spoon.reflect.factory that return types with arguments of type CtType

Modifier and Type	Method	Description
List<CtType<?>>	TypeFactory.getAll()	Gets the list of all top-level created types.
List<CtType<?>>	TypeFactory.getAll(boolean includeNestedTypes)	Gets the list of all created types.

Methods in spoon.reflect.factory with parameters of type CtType

Modifier and Type	Method	Description
CompilationUnit	CompilationUnitFactory.addType(CtType type)	add a new type to be pretty-printed
<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.
<T> CtField<T>	FieldFactory.create(CtType<?> target, CtField<T> source)	Creates a field by copying an existing field.
<T> CtInterface<T>	InterfaceFactory.create(CtType<T> owner, String simpleName)	Creates an inner interface
<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.
<T> CtMethod<T>	MethodFactory.create(CtType<?> target, CtMethod<T> source, boolean redirectReferences)	Creates a method by copying an existing method.
<T> CtArrayTypeReference<T[]>	Factory.createArrayReference(CtType<T> type)
<T> CtArrayTypeReference<T[]>	FactoryImpl.createArrayReference(CtType<T> type)
<T> CtArrayTypeReference<T[]>	TypeFactory.createArrayReference(CtType<T> type)	Creates a reference to an array of given type.
CtField	Factory.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name)
CtField	Factory.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name, CtExpression defaultExpression)
CtField	Factory.createField(CtType<?> target, CtField source)
CtField	FactoryImpl.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name)
CtField	FactoryImpl.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name, CtExpression defaultExpression)
CtField	FactoryImpl.createField(CtType<?> target, CtField source)
CtInterface	Factory.createInterface(CtType owner, String simpleName)
CtInterface	FactoryImpl.createInterface(CtType owner, String simpleName)
CtMethod	Factory.createMethod(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
CtMethod	Factory.createMethod(CtType<?> target, CtMethod source, boolean redirectReferences)
CtMethod	FactoryImpl.createMethod(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
CtMethod	FactoryImpl.createMethod(CtType<?> target, CtMethod source, boolean redirectReferences)
<T> CtNewClass<T>	CodeFactory.createNewClass(CtType<T> superClass, CtExpression<?>... parameters)	Creates a new anonymous class.
CtNewClass<?>	Factory.createNewClass(CtType<?> superClass, CtExpression<?>... parameters)	Creates an anonymous class
CtNewClass<?>	FactoryImpl.createNewClass(CtType<?> superClass, CtExpression<?>... parameters)
<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)
CompilationUnit	CompilationUnitFactory.getOrCreate(CtType type)	Returns the compilation unit corresponding to this type.
void	CompilationUnitFactory.removeType(CtType<?> type)	remove a type from the list of types to be pretty-printed

Uses of CtType in spoon.reflect.reference

Methods in spoon.reflect.reference that return CtType

Modifier and Type	Method	Description
CtType<?>	CtTypeMemberWildcardImportReference.getDeclaration()
CtType<T>	CtTypeReference.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<T>	CtTypeReference.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()).

Uses of CtType in spoon.reflect.visitor

Methods in spoon.reflect.visitor with parameters of type CtType

Modifier and Type	Method	Description
String	DefaultJavaPrettyPrinter.printTypes(CtType<?>... type)
String	PrettyPrinter.printTypes(CtType<?>... type)	Prints the types of one compilation unit It always resets the printing context at the beginning of this process.
void	PrintingContext.pushCurrentThis(CtType<?> type)	Adds the given type to the stack of types.
<T> void	CtInheritanceScanner.scanCtType(CtType<T> type)	Scans an abstract type.
void	ElementPrinterHelper.writeExtendsClause(CtType<?> type)
void	ElementPrinterHelper.writeImplementsClause(CtType<?> type)	writes the implemented interfaces with a ListPrinter

Method parameters in spoon.reflect.visitor with type arguments of type CtType

Modifier and Type	Method	Description
void	DefaultJavaPrettyPrinter.calculate(CtCompilationUnit sourceCompilationUnit, List<CtType<?>> types)
void	PrettyPrinter.calculate(CtCompilationUnit sourceCompilationUnit, List<CtType<?>> types)	Calculates the resulting source file for a list of types.

Uses of CtType in spoon.reflect.visitor.filter

Methods in spoon.reflect.visitor.filter with parameters of type CtType

Modifier and Type	Method	Description
boolean	SubtypeFilter.matches(CtType<?> mayBeSubType)

Uses of CtType in spoon.support

Methods in spoon.support with parameters of type CtType

Modifier and Type	Method	Description
void	JavaOutputProcessor.createJavaFile(CtType<?> element)	Creates the Java file associated to the given element.
protected Path	DefaultOutputDestinationHandler.getDirectoryPath(CtModule module, CtPackage pack, CtType type)
protected String	DefaultOutputDestinationHandler.getFileName(CtPackage pack, CtType type)
Path	DefaultOutputDestinationHandler.getOutputPath(CtModule module, CtPackage pack, CtType type)
Path	OutputDestinationHandler.getOutputPath(CtModule module, CtPackage pack, CtType type)

Uses of CtType in spoon.support.adaption

Methods in spoon.support.adaption that return CtType

Modifier and Type	Method	Description
CtType<?>	TypeAdaptor.getHierarchyStart()

Methods in spoon.support.adaption with parameters of type CtType

Modifier and Type	Method	Description
CtTypeReference<?>	TypeAdaptor.adaptType(CtType<?> superType)	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.

Constructors in spoon.support.adaption with parameters of type CtType

Modifier	Constructor	Description
	TypeAdaptor(CtType<?> hierarchyStart)	Creates a new type adaptor using the given type as the start of its hierarchy.

Uses of CtType in spoon.support.compiler

Methods in spoon.support.compiler with parameters of type CtType

Modifier and Type	Method	Description
static void	SnippetCompilationHelper.compileAndReplaceSnippetsIn(CtType<?> initialClass)	Takes the class given as parameter, pretty-prints it, get the JDT'ast and the corrspondong Spoon AST and finally replace all children of initialClass by the the fresh ones.

Uses of CtType in spoon.support.compiler.jdt

Methods in spoon.support.compiler.jdt with parameters of type CtType

Modifier and Type	Method	Description
<T> void	ParentExiter.scanCtType(CtType<T> type)

Method parameters in spoon.support.compiler.jdt with type arguments of type CtType

Modifier and Type	Method	Description
void	JDTBasedSpoonCompiler.generateProcessedSourceFiles(OutputType outputType, Filter<CtType<?>> typeFilter)
protected void	JDTBasedSpoonCompiler.generateProcessedSourceFilesUsingTypes(Filter<CtType<?>> typeFilter)

Uses of CtType in spoon.support.reflect.code

Methods in spoon.support.reflect.code with parameters of type CtType

Modifier and Type	Method	Description
CtCodeElement	CtIfImpl.getSubstitution(CtType<?> targetType)
CtCodeElement	CtLoopImpl.getSubstitution(CtType<?> targetType)
CtCodeElement	CtReturnImpl.getSubstitution(CtType<?> targetType)
CtStatementList	CtStatementListImpl.getSubstitution(CtType<?> targetType)
CtCodeElement	CtThrowImpl.getSubstitution(CtType<?> targetType)
CtCodeElement	CtTryImpl.getSubstitution(CtType<?> targetType)

Uses of CtType in spoon.support.reflect.declaration

Classes in spoon.support.reflect.declaration that implement CtType

Modifier and Type	Class	Description
class	CtAnnotationTypeImpl<T extends Annotation>	The implementation for CtAnnotationType.
class	CtClassImpl<T>	The implementation for CtClass.
class	CtEnumImpl<T extends Enum<?>>
class	CtInterfaceImpl<T>
class	CtRecordImpl
class	CtTypeImpl<T>	The implementation for CtType.
class	CtTypeParameterImpl

Methods in spoon.support.reflect.declaration with type parameters of type CtType

Modifier and Type	Method	Description
<F, C extends CtType<T>> C	CtTypeImpl.addField(int index, CtField<F> field)
<F, C extends CtType<T>> C	CtTypeImpl.addField(CtField<F> field)
<F, C extends CtType<Object>> C	CtTypeParameterImpl.addField(int index, CtField<F> field)
<F, C extends CtType<Object>> C	CtTypeParameterImpl.addField(CtField<F> field)
<F, C extends CtType<T>> C	CtTypeImpl.addFieldAtTop(CtField<F> field)
<F, C extends CtType<Object>> C	CtTypeParameterImpl.addFieldAtTop(CtField<F> field)
<M, C extends CtType<T>> C	CtAnnotationTypeImpl.addMethod(CtMethod<M> method)
<M, C extends CtType<T>> C	CtTypeImpl.addMethod(CtMethod<M> method)
<M, C extends CtType<Object>> C	CtTypeParameterImpl.addMethod(CtMethod<M> method)
<N, C extends CtType<T>> C	CtInterfaceImpl.addNestedType(CtType<N> nestedType)
<N, C extends CtType<T>> C	CtTypeImpl.addNestedType(CtType<N> nestedType)
<N, C extends CtType<Object>> C	CtTypeParameterImpl.addNestedType(CtType<N> nestedType)
<S, C extends CtType<T>> C	CtTypeImpl.addSuperInterface(CtTypeReference<S> interfac)
<S, C extends CtType<Object>> C	CtTypeParameterImpl.addSuperInterface(CtTypeReference<S> interfac)
<C extends CtType<T>> C	CtTypeImpl.addTypeMember(CtTypeMember member)	Adds a type member.
<C extends CtType<Object>> C	CtRecordImpl.addTypeMemberAt(int position, CtTypeMember member)
<C extends CtType<T>> C	CtTypeImpl.addTypeMemberAt(int position, CtTypeMember member)
<N extends CtType<?>> N	CtTypeImpl.getNestedType(String name)
<N extends CtType<?>> N	CtTypeParameterImpl.getNestedType(String name)
<T extends CtType<?>> T	CtPackageImpl.getType(String simpleName)
<C extends CtType<Object>> C	CtRecordImpl.setFields(List<CtField<?>> fields)
<C extends CtType<T>> C	CtTypeImpl.setFields(List<CtField<?>> fields)
<C extends CtType<Object>> C	CtTypeParameterImpl.setFields(List<CtField<?>> fields)
<C extends CtType<Object>> C	CtRecordImpl.setMethods(Set<CtMethod<?>> methods)
<C extends CtType<T>> C	CtTypeImpl.setMethods(Set<CtMethod<?>> methods)
<C extends CtType<Object>> C	CtTypeParameterImpl.setMethods(Set<CtMethod<?>> methods)
<C extends CtType<T>> C	CtTypeImpl.setNestedTypes(Set<CtType<?>> nestedTypes)
<C extends CtType<Object>> C	CtTypeParameterImpl.setNestedTypes(Set<CtType<?>> nestedTypes)
<C extends CtType<T>> C	CtAnnotationTypeImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtClassImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtEnumImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtInterfaceImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<Object>> C	CtRecordImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtTypeImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<Object>> C	CtTypeParameterImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtAnnotationTypeImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<C extends CtType<T>> C	CtTypeImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<C extends CtType<Object>> C	CtTypeParameterImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<C extends CtType<Object>> C	CtRecordImpl.setTypeMembers(List<CtTypeMember> members)
<C extends CtType<T>> C	CtTypeImpl.setTypeMembers(List<CtTypeMember> members)
<C extends CtType<Object>> C	CtTypeParameterImpl.setTypeMembers(List<CtTypeMember> members)

Methods in spoon.support.reflect.declaration that return CtType

Modifier and Type	Method	Description
CtType<T>	CtTypeImpl.clone()
CtType<?>	CtTypeImpl.copyType()
CtType<T>	CtConstructorImpl.getDeclaringType()
CtType<?>	CtExecutableImpl.getDeclaringType()
CtType<?>	CtFieldImpl.getDeclaringType()
CtType<?>	CtTypeImpl.getDeclaringType()
CtType<T>	InvisibleArrayConstructorImpl.getDeclaringType()
CtType<?>	CtCompilationUnitImpl.getMainType()
<T> CtType<T>	CtExecutableImpl.getTopLevelType()
<T> CtType<T>	CtFieldImpl.getTopLevelType()
<T> CtType<T>	CtTypeImpl.getTopLevelType()

Methods in spoon.support.reflect.declaration that return types with arguments of type CtType

Modifier and Type	Method	Description
List<CtType<?>>	CtCompilationUnitImpl.getDeclaredTypes()
Set<CtType<?>>	CtTypeImpl.getNestedTypes()
Set<CtType<?>>	CtTypeParameterImpl.getNestedTypes()
Set<CtType<?>>	CtPackageImpl.getTypes()

Methods in spoon.support.reflect.declaration with parameters of type CtType

Modifier and Type	Method	Description
CtCompilationUnitImpl	CtCompilationUnitImpl.addDeclaredType(CtType<?> type)
<N, C extends CtType<T>> C	CtInterfaceImpl.addNestedType(CtType<N> nestedType)
<N, C extends CtType<T>> C	CtTypeImpl.addNestedType(CtType<N> nestedType)
<N, C extends CtType<Object>> C	CtTypeParameterImpl.addNestedType(CtType<N> nestedType)
<T extends CtPackage> T	CtPackageImpl.addType(CtType<?> type)
<N> boolean	CtInterfaceImpl.removeNestedType(CtType<N> nestedType)
<N> boolean	CtTypeImpl.removeNestedType(CtType<N> nestedType)
<N> boolean	CtTypeParameterImpl.removeNestedType(CtType<N> nestedType)
void	CtPackageImpl.removeType(CtType<?> type)

Method parameters in spoon.support.reflect.declaration with type arguments of type CtType

Modifier and Type	Method	Description
CtCompilationUnit	CtCompilationUnitImpl.setDeclaredTypes(List<CtType<?>> types)
<C extends CtType<T>> C	CtTypeImpl.setNestedTypes(Set<CtType<?>> nestedTypes)
<C extends CtType<Object>> C	CtTypeParameterImpl.setNestedTypes(Set<CtType<?>> nestedTypes)
<T extends CtPackage> T	CtPackageImpl.setTypes(Set<CtType<?>> types)

Uses of CtType in spoon.support.reflect.reference

Methods in spoon.support.reflect.reference that return CtType

Modifier and Type	Method	Description
CtType<?>	CtTypeMemberWildcardImportReferenceImpl.getDeclaration()
CtType<T>	CtTypeReferenceImpl.getDeclaration()
CtType<Object>	CtTypeParameterReferenceImpl.getTypeDeclaration()
CtType<T>	CtTypeReferenceImpl.getTypeDeclaration()
CtType<Object>	CtWildcardReferenceImpl.getTypeDeclaration()

Uses of CtType in spoon.support.sniper

Methods in spoon.support.sniper with parameters of type CtType

Modifier and Type	Method	Description
String	SniperJavaPrettyPrinter.printTypes(CtType<?>... type)

Method parameters in spoon.support.sniper with type arguments of type CtType

Modifier and Type	Method	Description
void	SniperJavaPrettyPrinter.calculate(CtCompilationUnit compilationUnit, List<CtType<?>> types)

Uses of CtType in spoon.support.visitor

Methods in spoon.support.visitor with type parameters of type CtType

Modifier and Type	Method	Description
<T extends CtType<?>> void	SubInheritanceHierarchyResolver.forEachSubTypeInPackage(CtConsumer<T> outputConsumer)	Calls `outputConsumer.apply(subType)` for each sub type of the targetSuperTypes that are found in `inputPackage`.

Methods in spoon.support.visitor that return CtType

Modifier and Type	Method	Description
CtType<?>	ClassTypingContext.getAdaptationScope()

Methods in spoon.support.visitor with parameters of type CtType

Modifier and Type	Method	Description
protected ClassTypingContext	ClassTypingContext.createEnclosingHierarchy(CtType<?> enclosingType)	might be used to create custom chain of super type hierarchies

Constructors in spoon.support.visitor with parameters of type CtType

Modifier	Constructor	Description
	ClassTypingContext(CtType<?> type)

Uses of CtType in spoon.support.visitor.clone

Methods in spoon.support.visitor.clone with parameters of type CtType

Modifier and Type	Method	Description
<T> void	CloneBuilder.scanCtType(CtType<T> type)	Scans an abstract type.

Uses of CtType in spoon.support.visitor.java

Methods in spoon.support.visitor.java with type parameters of type CtType

Modifier and Type	Method	Description
<T, R extends CtType<T>> R	JavaReflectionTreeBuilder.scan(Class<T> clazz)	transforms a java.lang.Class into a CtType (ie a shadow type in Spoon's parlance)

Uses of CtType in spoon.support.visitor.java.internal

Fields in spoon.support.visitor.java.internal declared as CtType

Modifier and Type	Field	Description
protected CtType	TypeRuntimeBuilderContext.type

Methods in spoon.support.visitor.java.internal with parameters of type CtType

Modifier and Type	Method	Description
void	PackageRuntimeBuilderContext.addType(CtType<?> aType)
void	RuntimeBuilderContext.addType(CtType<?> aType)
void	TypeRuntimeBuilderContext.addType(CtType<?> aType)

Constructors in spoon.support.visitor.java.internal with parameters of type CtType

Modifier	Constructor	Description
	TypeRuntimeBuilderContext(Type rtType, CtType type)

Uses of CtType in spoon.template

Methods in spoon.template with type parameters of type CtType

Modifier and Type	Method	Description
static <T extends CtType<?>> T	Substitution.createTypeFromTemplate(String qualifiedTypeName, CtType<?> templateOfType, Map<String,Object> templateParameters)	Generates a type (class, interface, enum, ...) from the template model `templateOfType` by by substituting all the template parameters by their values.
static <T extends CtType<?>> T	Substitution.substitute(Template<?> template, T templateType)	Substitutes all the template parameters in a given template type and returns the resulting type.

Methods in spoon.template that return CtType

Modifier and Type	Method	Description
CtType<?>	ExtensionTemplate.apply(CtType<?> target)

Methods in spoon.template with parameters of type CtType

Modifier and Type	Method	Description
CtBlock<?>	BlockTemplate.apply(CtType<?> targetType)
CtExpression<T>	ExpressionTemplate.apply(CtType<?> targetType)
CtType<?>	ExtensionTemplate.apply(CtType<?> target)
CtStatement	StatementTemplate.apply(CtType<?> targetType)
T	Template.apply(CtType<?> targetType)	Returns the code which results from applying the template.
static <T extends CtType<?>> T	Substitution.createTypeFromTemplate(String qualifiedTypeName, CtType<?> templateOfType, Map<String,Object> templateParameters)	Generates a type (class, interface, enum, ...) from the template model `templateOfType` by by substituting all the template parameters by their values.
static <T extends Template<?>> void	Substitution.insertAll(CtType<?> targetType, T template)	Inserts all the methods, fields, constructors, initialization blocks (if target is a class), inner types, and super interfaces (except Template) from a given template by substituting all the template parameters by their values.
static void	Substitution.insertAllConstructors(CtType<?> targetType, Template<?> template)	Inserts all constructors and initialization blocks from a given template by substituting all the template parameters by their values.
static void	Substitution.insertAllFields(CtType<?> targetType, Template<?> template)	Inserts all the fields from a given template by substituting all the template parameters by their values.
static void	Substitution.insertAllMethods(CtType<?> targetType, Template<?> template)	Inserts all the methods from a given template by substituting all the template parameters by their values.
static void	Substitution.insertAllNestedTypes(CtType<?> targetType, Template<?> template)	Inserts all the nested types from a given template by substituting all the template parameters by their values.
static void	Substitution.insertAllSuperInterfaces(CtType<?> targetType, Template<?> template)	Inserts all the super interfaces (except Template) from a given template by substituting all the template parameters by their values.
static <T> CtField<T>	Substitution.insertField(CtType<?> targetType, Template<?> template, CtField<T> sourceField)	Generates a field (and its initialization expression) from a template field by substituting all the template parameters by their values.
static <T> CtMethod<T>	Substitution.insertMethod(CtType<?> targetType, Template<?> template, CtMethod<T> sourceMethod)	Generates a method from a template method by substituting all the template parameters by their values.
static <E extends CtElement> E	Substitution.substitute(CtType<?> targetType, Template<?> template, E code)	Substitutes all the template parameters in a random piece of code.
static CtExpression<?>	Substitution.substituteFieldDefaultExpression(CtType<?> targetType, Template<?> template, String fieldName)	Gets a default expression from a template field with all the template parameters substituted.

Uses of CtType in spoon.testing.utils

Methods in spoon.testing.utils with type parameters of type CtType

Modifier and Type	Method	Description
static <T extends CtType<?>> T	ModelUtils.build(String packageName, String className)	Utility method for testing: creates the model of `packageName` from src/test/java and returns the CtType corresponding to `className`
static <T extends CtType<?>> T	ModelUtils.build(String packageName, String className, Factory f)	Utility method for testing: creates the model of `packageName` and the factory from src/test/java and returns the CtType corresponding to `className`

Methods in spoon.testing.utils that return CtType

Modifier and Type	Method	Description
static <T> CtType<T>	ModelUtils.buildClass(Class<T> classToBuild)
static <T> CtType<T>	ModelUtils.buildClass(Class<T> classToBuild, boolean ensureFullclasspath)	Builds and returns the Spoon model of `` classToBuild
static <T> CtType<T>	ModelUtils.buildClass(Consumer<Launcher> config, Class<T> classToBuild)