Uses of Interface
spoon.reflect.visitor.CtVisitable

Packages that use CtVisitable

Package	Description
spoon.experimental	this is unstable code, subject to potential complete redesign, not only in snapshots but also in releases.
spoon.reflect	This package defines the Spoon's compile-time meta-model of Java programs.
spoon.reflect.code	This package contains the meta-model part that models the executable code (methods and constructors' bodies, field initializers).
spoon.reflect.cu	This package defines compilation units that hold the source code and some classes around them (in most cases, these features should be ignored by the programmers).
spoon.reflect.cu.position
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.support.reflect.code
spoon.support.reflect.cu
spoon.support.reflect.declaration
spoon.support.reflect.reference

Uses of CtVisitable in spoon.experimental

Classes in spoon.experimental that implement CtVisitable

Modifier and Type	Class	Description
class	CtUnresolvedImport

Uses of CtVisitable in spoon.reflect

Classes in spoon.reflect that implement CtVisitable

Modifier and Type	Class	Description
static class	CtModelImpl.CtRootPackage

Uses of CtVisitable in spoon.reflect.code

Subinterfaces of CtVisitable in spoon.reflect.code

Modifier and Type	Interface	Description
interface	CtAbstractInvocation<T>	This code element defines an abstract invocation on a CtExecutable.
interface	CtAbstractSwitch<S>	This code element defines an abstract switch (either switch statement or switch expression).
interface	CtAnnotationFieldAccess<T>	This code element defines an access to a annotation parameter variable.
interface	CtArrayAccess<T,E extends CtExpression<?>>	This code element defines a one-dimensional array access.
interface	CtArrayRead<T>	This code element defines a read access to an array.
interface	CtArrayWrite<T>	This code element defines a write access to an array.
interface	CtAssert<T>	This code element defines an assert clause.
interface	CtAssignment<T,A extends T>	This code element defines an assignment.
interface	CtBinaryOperator<T>	This interface defines a binary operator.
interface	CtBlock<R>	This code element represents a block of code, that is to say a list of statements enclosed in curly brackets.
interface	CtBodyHolder	This abstract code element defines an element, which contains a body
interface	CtBreak	This code element defines a break statement.
interface	CtCase<S>	This code element defines a case within a switch-case.
interface	CtCatch	This code element defines a catch of a try.
interface	CtCatchVariable<T>	This code element defines an exception variable in a catch.
interface	CtCFlowBreak	This abstract code element represents all the statements that break the control flow of the program.
interface	CtCodeElement	This interface is the root interface of the code elements.
interface	CtCodeSnippetExpression<T>	This element is a code snippet that must represent an expression and can thus be inserted in the program's model as is.
interface	CtCodeSnippetStatement	This element is a code snippet that must represent a statement and can thus be inserted in the program's model as is.
interface	CtComment	This code element defines a comment Example: int x = 0; // a comment
interface	CtConditional<T>	This code element defines conditional expressions using the ? (ternary expressions).
interface	CtConstructorCall<T>	This code element represents a constructor call.
interface	CtContinue	This code element defines the continue statement.
interface	CtDo	This code element defines a do loop.
interface	CtExecutableReferenceExpression<T,E extends CtExpression<?>>	This abstract code element defines an expression which represents an executable reference.
interface	CtExpression<T>	This abstract code element defines a typed expression.
interface	CtFieldAccess<T>	This code element defines an access to a field variable (read and write)
interface	CtFieldRead<T>	This code element defines a read access to a field.
interface	CtFieldWrite<T>	This code element defines a write access to a field.
interface	CtFor	This code element defines a for loop.
interface	CtForEach	This code element defines a foreach statement.
interface	CtIf	This code element represents an if statement.
interface	CtInvocation<T>	This code element defines a concrete invocation.
interface	CtJavaDoc	This code element defines a javadoc comment Example:
interface	CtJavaDocTag	This code element defines a javadoc tag Example:

Uses of CtVisitable in spoon.reflect.cu

Subinterfaces of CtVisitable in spoon.reflect.cu

Modifier and Type	Interface	Description
interface	CompilationUnit	Deprecated.

Uses of CtVisitable in spoon.reflect.cu.position

Classes in spoon.reflect.cu.position that implement CtVisitable

Modifier and Type	Class	Description
static class	NoSourcePosition.NullCompilationUnit

Uses of CtVisitable in spoon.reflect.declaration

Subinterfaces of CtVisitable in spoon.reflect.declaration

Modifier and Type	Interface	Description
interface	CtAnnotation<A extends Annotation>	This element represents an annotation on an element.
interface	CtAnnotationMethod<T>	This element defines an annotation method declared in an annotation type.
interface	CtAnnotationType<T extends Annotation>	This element defines an annotation type.
interface	CtAnonymousExecutable	This element defines an anonymous executable block declaration in a class.
interface	CtClass<T>	This element represents a class declaration.
interface	CtCompilationUnit	Defines a compilation unit.
interface	CtConstructor<T>	This element defines a constructor declaration.
interface	CtElement	This interface is the root interface for the metamodel elements (any program element).
interface	CtEnum<T extends Enum<?>>	This element represents an enumeration declaration.
interface	CtEnumValue<T>	Corresponds to one enum value specified in an enumeration.
interface	CtExecutable<R>	This element represents an executable element such as a method, a constructor, or an anonymous block.
interface	CtField<T>	This element defines a field declaration.
interface	CtFormalTypeDeclarer	This abstract element defines a declaration that accepts formal type parameters (aka generics), such as a CtType (class A<E>), CtMethod or CtConstructor.
interface	CtImport	This element represents an import declaration.
interface	CtInterface<T>	This element defines an interface declaration.
interface	CtMethod<T>	This element defines a method declaration.
interface	CtModifiable	This interface defines an element that accepts modifiers.
interface	CtModule	Represents a Java module as defined in Java 9.
interface	CtModuleDirective	Represents a directive of a CtModule The directives of a module declaration specify the module's dependences on other modules CtModuleRequirement, the packages it makes available to other modules CtPackageExport, the services it consumes CtUsedService, and the services it provides CtProvidedService.
interface	CtModuleRequirement	Represents a require module in a Java module definition The requires directive specifies the name of a module on which the current module has a dependence.
interface	CtMultiTypedElement	Defined an element with several types.
interface	CtNamedElement	Declares an element that has a name (a class, a method, a variable, etc).
interface	CtPackage	This element defines a package declaration.
interface	CtPackageDeclaration	This element represents an package declaration.
interface	CtPackageExport	Represents an exported or opened package in a Java module The exports directive specifies the name of a package to be exported by the current module.
interface	CtParameter<T>	This element defines an executable parameter declaration.
interface	CtProvidedService	Represents a provided service in a CtModule.
interface	CtRecord	This element represents a record declaration.
interface	CtRecordComponent	This element represents a record component.
interface	CtType<T>	This abstract element defines a super-type for classes and interfaces, which can declare methods.
interface	CtTypedElement<T>	This abstract element defines a typed element.
interface	CtTypeMember	This interface represents a member of a class (field, method, nested class or static/instance initializer).
interface	CtTypeParameter	This element defines a declaration of a type parameter (aka generics).
interface	CtUsedService	Represents the declaration of a used service in a CtModule The uses directive specifies a service for which the current module may discover providers via java.util.ServiceLoader.
interface	CtVariable<T>	This abstract element defines a variable declaration.

Uses of CtVisitable in spoon.reflect.factory

Classes in spoon.reflect.factory that implement CtVisitable

Modifier and Type	Class	Description
static class	ModuleFactory.CtUnnamedModule

Uses of CtVisitable in spoon.reflect.reference

Subinterfaces of CtVisitable in spoon.reflect.reference

Modifier and Type	Interface	Description
interface	CtArrayTypeReference<T>	This interface defines a reference to an array.
interface	CtCatchVariableReference<T>	This interface defines a reference to CtCatchVariable.
interface	CtExecutableReference<T>	This interface defines a reference to a CtExecutable.
interface	CtFieldReference<T>	This interface defines a reference to a CtField.
interface	CtIntersectionTypeReference<T>	This interface defines a reference to an intersection type in generics or in casts.
interface	CtLocalVariableReference<T>	This interface defines a reference to CtLocalVariable.
interface	CtModuleReference	Represents a reference to a CtModule
interface	CtPackageReference	This interface defines a reference to a CtPackage.
interface	CtParameterReference<T>	This interface defines a reference to a CtParameter of a method.
interface	CtReference	This is the root interface for named program element references, such as fields, types, variables, and so on.
interface	CtTypeMemberWildcardImportReference	This interface defines a import reference to all static type members of a type. Example: somePackage.Type.*;
interface	CtTypeParameterReference	This interface defines a reference to a type parameter (aka generics).
interface	CtTypeReference<T>	This interface defines a reference to a CtType or sub-type.
interface	CtUnboundVariableReference<T>	This interface defines a reference to an unbound CtVariable.
interface	CtVariableReference<T>	This interface defines a reference to a CtVariable or sub-type.
interface	CtWildcardReference	Represents a wildcard in generic type annotations, i.e.

Uses of CtVisitable in spoon.reflect.visitor

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

Modifier and Type	Method	Description
void	CtInheritanceScanner.scanCtVisitable(CtVisitable e)

Uses of CtVisitable in spoon.support.reflect.code

Classes in spoon.support.reflect.code that implement CtVisitable

Modifier and Type	Class	Description
class	CtAnnotationFieldAccessImpl<T>
class	CtArrayAccessImpl<T,V extends CtExpression<?>>
class	CtArrayReadImpl<T>
class	CtArrayWriteImpl<T>
class	CtAssertImpl<T>
class	CtAssignmentImpl<T,A extends T>
class	CtBinaryOperatorImpl<T>
class	CtBlockImpl<R>
class	CtBreakImpl
class	CtCaseImpl<E>
class	CtCatchImpl
class	CtCatchVariableImpl<T>
class	CtCodeElementImpl
class	CtCodeSnippetExpressionImpl<T>
class	CtCodeSnippetStatementImpl
class	CtCommentImpl
class	CtConditionalImpl<T>
class	CtConstructorCallImpl<T>
class	CtContinueImpl
class	CtDoImpl
class	CtExecutableReferenceExpressionImpl<T,E extends CtExpression<?>>
class	CtExpressionImpl<T>
class	CtFieldAccessImpl<T>
class	CtFieldReadImpl<T>
class	CtFieldWriteImpl<T>
class	CtForEachImpl
class	CtForImpl
class	CtIfImpl
class	CtInvocationImpl<T>
class	CtJavaDocImpl
class	CtJavaDocTagImpl
class	CtLambdaImpl<T>
class	CtLiteralImpl<T>
class	CtLocalVariableImpl<T>
class	CtLoopImpl
class	CtNewArrayImpl<T>
class	CtNewClassImpl<T>
class	CtOperatorAssignmentImpl<T,A extends T>
class	CtReturnImpl<R>
class	CtStatementImpl
class	CtStatementListImpl<R>
class	CtSuperAccessImpl<T>
class	CtSwitchExpressionImpl<T,S>
class	CtSwitchImpl<S>
class	CtSynchronizedImpl
class	CtTargetedExpressionImpl<E,T extends CtExpression<?>>
class	CtTextBlockImpl
class	CtThisAccessImpl<T>
class	CtThrowImpl
class	CtTryImpl
class	CtTryWithResourceImpl
class	CtTypeAccessImpl<A>
class	CtTypePatternImpl
class	CtUnaryOperatorImpl<T>
class	CtVariableAccessImpl<T>
class	CtVariableReadImpl<T>
class	CtVariableWriteImpl<T>
class	CtWhileImpl
class	CtYieldStatementImpl	CtYieldStatementImpl

Uses of CtVisitable in spoon.support.reflect.cu

Classes in spoon.support.reflect.cu that implement CtVisitable

Modifier and Type	Class	Description
class	CompilationUnitImpl	Implements a compilation unit.

Uses of CtVisitable in spoon.support.reflect.declaration

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

Modifier and Type	Class	Description
class	CtAnnotationImpl<A extends Annotation>	The implementation for CtAnnotation.
class	CtAnnotationMethodImpl<T>	The implementation for CtAnnotationMethod.
class	CtAnnotationTypeImpl<T extends Annotation>	The implementation for CtAnnotationType.
class	CtAnonymousExecutableImpl
class	CtClassImpl<T>	The implementation for CtClass.
class	CtCompilationUnitImpl	Implements a compilation unit.
class	CtConstructorImpl<T>
class	CtElementImpl	Contains the default implementation of most CtElement methods.
class	CtEnumImpl<T extends Enum<?>>
class	CtEnumValueImpl<T>
class	CtExecutableImpl<R>	The implementation for CtExecutable.
class	CtFieldImpl<T>	The implementation for CtField.
class	CtImportImpl
class	CtInterfaceImpl<T>
class	CtMethodImpl<T>	The implementation for CtMethod.
class	CtModuleImpl
class	CtModuleRequirementImpl
class	CtNamedElementImpl
class	CtPackageDeclarationImpl
class	CtPackageExportImpl
class	CtPackageImpl	The implementation for CtPackage.
class	CtParameterImpl<T>	The implementation for CtParameter.
class	CtProvidedServiceImpl
class	CtRecordComponentImpl
class	CtRecordImpl
class	CtTypeImpl<T>	The implementation for CtType.
class	CtTypeParameterImpl
class	CtUsedServiceImpl
class	InvisibleArrayConstructorImpl<T>	This class is used to represent the constructor of an array when calling with an expression like

Uses of CtVisitable in spoon.support.reflect.reference

Classes in spoon.support.reflect.reference that implement CtVisitable

Modifier and Type	Class	Description
class	CtArrayTypeReferenceImpl<T>
class	CtCatchVariableReferenceImpl<T>
class	CtExecutableReferenceImpl<T>
class	CtFieldReferenceImpl<T>
class	CtIntersectionTypeReferenceImpl<T>
class	CtLocalVariableReferenceImpl<T>	An implementation for CtLocalVariableReference.
class	CtModuleReferenceImpl
class	CtPackageReferenceImpl
class	CtParameterReferenceImpl<T>
class	CtReferenceImpl
class	CtTypeMemberWildcardImportReferenceImpl	This class intends to be used only to represent the reference of a static import of all members of a type: import static org.junit.Assert.*;
class	CtTypeParameterReferenceImpl
class	CtTypeReferenceImpl<T>
class	CtUnboundVariableReferenceImpl<T>	represents a reference to an unbound field (used when no full classpath is available
class	CtVariableReferenceImpl<T>
class	CtWildcardReferenceImpl