Uses of Interface
spoon.reflect.declaration.CtClass

Packages that use CtClass

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.reflect.code	This package contains the meta-model part that models the executable code (methods and constructors' bodies, field initializers).
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.visitor	This package defines visitor, scanner, and scanner-based query API for Java programs reified in the meta-model.
spoon.support	This package contains some default implementations for commonly used processing tasks.
spoon.support.compiler.jdt
spoon.support.reflect.code
spoon.support.reflect.declaration
spoon.support.template	This package defines the substitution and matching engines for Java templates.
spoon.support.visitor
spoon.support.visitor.clone
spoon.support.visitor.replace
spoon.template	This package defines a framework for well-typed pure-Java templates.

Uses of CtClass in spoon

Methods in spoon that return CtClass

Modifier and Type	Method	Description
static CtClass<?>	Launcher.parseClass(String code)	returns the AST of an inline class

Uses of CtClass in spoon.metamodel

Methods in spoon.metamodel that return CtClass

Modifier and Type	Method	Description
CtClass<?>	MetamodelConcept.getImplementationClass()
static @Nullable CtClass<?>	Metamodel.getImplementationOfInterface(CtInterface<?> iface)

Methods in spoon.metamodel with parameters of type CtClass

Modifier and Type	Method	Description
static @Nullable CtInterface<?>	Metamodel.getInterfaceOfImplementation(CtClass<?> impl)

Uses of CtClass in spoon.reflect.code

Methods in spoon.reflect.code that return CtClass

Modifier and Type	Method	Description
CtClass<?>	CtNewClass.getAnonymousClass()	Gets the created class.

Methods in spoon.reflect.code with parameters of type CtClass

Modifier and Type	Method	Description
<N extends CtNewClass> N	CtNewClass.setAnonymousClass(CtClass<?> anonymousClass)	Sets the created class.

Uses of CtClass in spoon.reflect.declaration

Subinterfaces of CtClass in spoon.reflect.declaration

Modifier and Type	Interface	Description
interface	CtEnum<T extends Enum<?>>	This element represents an enumeration declaration.
interface	CtRecord	This element represents a record declaration.

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

Modifier and Type	Method	Description
<C extends CtClass<T>> C	CtClass.addAnonymousExecutable(CtAnonymousExecutable e)	Add an anonymous block to this class.
<C extends CtClass<T>> C	CtClass.addConstructor(CtConstructor<T> constructor)	Adds a constructor to this class.
<C extends CtClass<T>> C	CtClass.setAnonymousExecutables(List<CtAnonymousExecutable> e)	Sets the anonymous blocks of this class.
<C extends CtClass<T>> C	CtClass.setConstructors(Set<CtConstructor<T>> constructors)	Sets the constructors for this class.

Methods in spoon.reflect.declaration that return CtClass

Modifier and Type	Method	Description
CtClass<T>	CtClass.clone()

Uses of CtClass in spoon.reflect.factory

Methods in spoon.reflect.factory that return CtClass

Modifier and Type	Method	Description
<T> CtClass<T>	ClassFactory.create(String qualifiedName)	Creates a class from its qualified name.
<T> CtClass<T>	ClassFactory.create(CtClass<?> declaringClass, String simpleName)	Creates an inner class.
<T> CtClass<T>	ClassFactory.create(CtPackage owner, String simpleName)	Creates a top-level class.
<T> CtClass<T>	CoreFactory.createClass()	Creates a class.
<T> CtClass<T>	Factory.createClass()
CtClass	Factory.createClass(String qualifiedName)
CtClass	Factory.createClass(CtClass<?> declaringClass, String simpleName)
CtClass	Factory.createClass(CtPackage owner, String simpleName)
<T> CtClass<T>	FactoryImpl.createClass()
CtClass	FactoryImpl.createClass(String qualifiedName)
CtClass	FactoryImpl.createClass(CtClass<?> declaringClass, String simpleName)
CtClass	FactoryImpl.createClass(CtPackage owner, String simpleName)
<T> CtClass<T>	ClassFactory.get(Class<?> cl)	Gets a class from its runtime Java class.
<T> CtClass<T>	ClassFactory.get(String qualifiedName)	Searches for a class from his qualified name.

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

Modifier and Type	Method	Description
<T> CtClass<T>	ClassFactory.create(CtClass<?> declaringClass, String simpleName)	Creates an inner class.
<T> CtConstructor<T>	ConstructorFactory.create(CtClass<T> target, Set<ModifierKind> modifiers, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)	Creates an empty constructor.
<T> CtConstructor<T>	ConstructorFactory.create(CtClass<T> target, Set<ModifierKind> modifiers, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock<T> body)	Creates a constructor.
<T> CtConstructor<T>	ConstructorFactory.create(CtClass<T> target, CtConstructor<?> source)	Copies a constructor into a target class.
<T> CtConstructor<T>	ConstructorFactory.create(CtClass<T> target, CtMethod<?> source)	Creates a constructor into a target class by copying it from a source method.
<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.
CtAnonymousExecutable	ExecutableFactory.createAnonymous(CtClass<?> target, CtBlock<Void> body)	Creates an anonymous executable (initializer block) in a target class).
CtAnonymousExecutable	Factory.createAnonymous(CtClass<?> target, CtBlock<Void> body)
CtAnonymousExecutable	FactoryImpl.createAnonymous(CtClass<?> target, CtBlock<Void> body)
CtClass	Factory.createClass(CtClass<?> declaringClass, String simpleName)
CtClass	FactoryImpl.createClass(CtClass<?> declaringClass, String simpleName)
CtConstructor	Factory.createConstructor(CtClass target, Set<ModifierKind> modifiers, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
CtConstructor	Factory.createConstructor(CtClass target, Set<ModifierKind> modifiers, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock body)
CtConstructor	Factory.createConstructor(CtClass target, CtConstructor<?> source)
CtConstructor	Factory.createConstructor(CtClass target, CtMethod<?> source)
CtConstructor	FactoryImpl.createConstructor(CtClass target, Set<ModifierKind> modifiers, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
CtConstructor	FactoryImpl.createConstructor(CtClass target, Set<ModifierKind> modifiers, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock body)
CtConstructor	FactoryImpl.createConstructor(CtClass target, CtConstructor<?> source)
CtConstructor	FactoryImpl.createConstructor(CtClass target, CtMethod<?> source)
<T> CtConstructor<T>	ConstructorFactory.createDefault(CtClass<T> target)	Create the default empty constructor.
<T> CtConstructor<T>	Factory.createDefault(CtClass<T> target)
<T> CtConstructor<T>	FactoryImpl.createDefault(CtClass<T> target)
CtMethod	Factory.createMethod(CtClass<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock body)
CtMethod	FactoryImpl.createMethod(CtClass<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock body)

Uses of CtClass in spoon.reflect.visitor

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

Modifier and Type	Method	Description
<T> void	CtAbstractVisitor.visitCtClass(CtClass<T> ctClass)
<T> void	CtBiScannerDefault.visitCtClass(CtClass<T> ctClass)
<T> void	CtInheritanceScanner.visitCtClass(CtClass<T> e)
<T> void	CtScanner.visitCtClass(CtClass<T> ctClass)
<T> void	CtVisitor.visitCtClass(CtClass<T> ctClass)	Visits a class declaration.
<T> void	DefaultJavaPrettyPrinter.visitCtClass(CtClass<T> ctClass)
<T> void	ImportScannerImpl.visitCtClass(CtClass<T> ctClass)

Uses of CtClass in spoon.support

Methods in spoon.support that return CtClass

Modifier and Type	Method	Description
<T> CtClass<T>	DefaultCoreFactory.createClass()

Uses of CtClass in spoon.support.compiler.jdt

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

Modifier and Type	Method	Description
<T> void	ParentExiter.visitCtClass(CtClass<T> ctClass)

Uses of CtClass in spoon.support.reflect.code

Methods in spoon.support.reflect.code that return CtClass

Modifier and Type	Method	Description
CtClass<?>	CtNewClassImpl.getAnonymousClass()

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

Modifier and Type	Method	Description
<N extends CtNewClass> N	CtNewClassImpl.setAnonymousClass(CtClass<?> anonymousClass)

Uses of CtClass in spoon.support.reflect.declaration

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

Modifier and Type	Class	Description
class	CtClassImpl<T>	The implementation for CtClass.
class	CtEnumImpl<T extends Enum<?>>
class	CtRecordImpl

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

Modifier and Type	Method	Description
<C extends CtClass<T>> C	CtClassImpl.addAnonymousExecutable(CtAnonymousExecutable e)
<C extends CtClass<T>> C	CtClassImpl.addConstructor(CtConstructor<T> constructor)
<C extends CtClass<T>> C	CtClassImpl.setAnonymousExecutables(List<CtAnonymousExecutable> anonymousExecutables)
<C extends CtClass<T>> C	CtClassImpl.setConstructors(Set<CtConstructor<T>> constructors)

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

Modifier and Type	Method	Description
CtClass<T>	CtClassImpl.addPermittedType(CtTypeReference<?> type)
CtClass<T>	CtClassImpl.clone()
CtClass<T>	CtClassImpl.removePermittedType(CtTypeReference<?> type)
CtClass<T>	CtClassImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)

Uses of CtClass in spoon.support.template

Methods in spoon.support.template with parameters of type CtClass

Modifier and Type	Method	Description
static List<String>	Parameters.getNames(CtClass<? extends Template<?>> templateType)	Gets the names of all the template parameters of a given template type (including the ones defined by the super types).
static Map<String,Object>	Parameters.getNamesToValues(Template<?> template, CtClass<? extends Template<?>> templateType)	Gets the Map of names to template parameter value for all the template parameters of a given template type (including the ones defined by the super types).
static CtField<?>	Parameters.getParameterField(CtClass<? extends Template<?>> templateClass, String parameterName)

Uses of CtClass in spoon.support.visitor

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

Modifier and Type	Method	Description
<T> void	TypeReferenceScanner.visitCtClass(CtClass<T> ctClass)

Uses of CtClass in spoon.support.visitor.clone

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

Modifier and Type	Method	Description
<T> void	CloneVisitor.visitCtClass(CtClass<T> ctClass)

Uses of CtClass in spoon.support.visitor.replace

Methods in spoon.support.visitor.replace with parameters of type CtClass

Modifier and Type	Method	Description
<T> void	ReplacementVisitor.visitCtClass(CtClass<T> ctClass)

Uses of CtClass in spoon.template

Methods in spoon.template that return CtClass

Modifier and Type	Method	Description
static <T> CtClass<T>	Substitution.getTemplateCtClass(Factory factory, Template<?> template)

Methods in spoon.template with parameters of type CtClass

Modifier and Type	Method	Description
static CtBlock<?>	BlockTemplate.getBlock(CtClass<? extends BlockTemplate> p)	Returns the block.
static <T> CtExpression<T>	ExpressionTemplate.getExpression(CtClass<? extends ExpressionTemplate<?>> p)	Returns the expression.
static <T> CtConstructor<T>	Substitution.insertConstructor(CtClass<T> targetClass, Template<?> template, CtConstructor<?> sourceConstructor)	Generates a constructor from a template constructor by substituting all the template parameters by their values.
static <T> CtConstructor<T>	Substitution.insertConstructor(CtClass<T> targetClass, Template<?> template, CtMethod<?> sourceMethod)	Generates a constructor from a template method by substituting all the template parameters by their values.
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.

Constructors in spoon.template with parameters of type CtClass

Modifier	Constructor	Description
	TemplateMatcher(CtElement templateRoot, CtClass<?> templateType)	Constructs a matcher for a given template.