java.lang.Object
- spoon.reflect.visitor.CtScanner

All Implemented Interfaces:

CtVisitor

Direct Known Subclasses:

AstParentConsistencyChecker, CloneVisitor, CtBFSIterator, CtDequeScanner, CtIterator, EarlyTerminatingScanner, ImportScannerImpl, InlinePartialEvaluator, MethodInvocationSearch, ModelConsistencyChecker, ProcessingVisitor, ReplacementVisitor, SignaturePrinter, SpoonifierVisitor, SpoonTreeBuilder, TypeReferenceScanner, VariableReferenceFunction.Visitor, VariableScopeFunction.Visitor, VisitorPartialEvaluator
```
public abstract class CtScanner
extends Object
implements CtVisitor
```
This visitor implements a deep-search scan on the model. Ensures that all children nodes are visited once, a visit means three method calls, one call to "enter", one call to "exit" and one call to scan. Is used by the processing and filtering engine.

Constructor Summary

Constructors
Constructor Description

CtScanner()
Default constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected void`	`enter(CtElement e)`	This method is upcalled by the scanner when entering a scanned element.
`protected void`	`exit(CtElement e)`	This method is upcalled by the scanner when exiting a scanned element.
`void`	`scan(Object o)`	Generically scans an object that can be an element, a reference, or a collection of those.
`void`	`scan(Collection<? extends CtElement> elements)`	Generically scans a collection of meta-model elements.
`void`	`scan(CtElement element)`	Generically scans a meta-model element.
`void`	`scan(CtRole role, Object o)`	Generically scans an object that can be an element, a reference, or a collection of those.
`void`	`scan(CtRole role, Collection<? extends CtElement> elements)`	Generically scans a collection of meta-model elements.
`void`	`scan(CtRole role, Map<String,? extends CtElement> elements)`	Generically scans a Map of meta-model elements.
`void`	`scan(CtRole role, CtElement element)`	Generically scans a meta-model element.
`<A extends Annotation> void`	`visitCtAnnotation(CtAnnotation<A> annotation)`	Visits an annotation.
`<T> void`	`visitCtAnnotationFieldAccess(CtAnnotationFieldAccess<T> annotationFieldAccess)`	Visits a field of an annotation.
`<T> void`	`visitCtAnnotationMethod(CtAnnotationMethod<T> annotationMethod)`	Visits an annotation method declaration.
`<A extends Annotation> void`	`visitCtAnnotationType(CtAnnotationType<A> annotationType)`	Visits an annotation type declaration.
`void`	`visitCtAnonymousExecutable(CtAnonymousExecutable anonymousExec)`	Visits an anonymous executable.
`<T> void`	`visitCtArrayRead(CtArrayRead<T> arrayRead)`	Visits an array read access.
`<T> void`	`visitCtArrayTypeReference(CtArrayTypeReference<T> reference)`	Visits a reference to an array type.
`<T> void`	`visitCtArrayWrite(CtArrayWrite<T> arrayWrite)`	Visits an array write access.
`<T> void`	`visitCtAssert(CtAssert<T> asserted)`	Visits an assert.
`<T,A extends T> void`	`visitCtAssignment(CtAssignment<T,A> assignement)`	Visits an assignment.
`<T> void`	`visitCtBinaryOperator(CtBinaryOperator<T> operator)`	Visits a binary operator.
`<R> void`	`visitCtBlock(CtBlock<R> block)`	Visits a block of code.
`void`	`visitCtBreak(CtBreak breakStatement)`	Visits a `break` statement.
`<S> void`	`visitCtCase(CtCase<S> caseStatement)`	Visits a `case` clause.
`void`	`visitCtCatch(CtCatch catchBlock)`	Visits a `catch` clause.
`<T> void`	`visitCtCatchVariable(CtCatchVariable<T> catchVariable)`	Visits a catch variable declaration.
`<T> void`	`visitCtCatchVariableReference(CtCatchVariableReference<T> reference)`	Visits a reference to a catch variable.
`<T> void`	`visitCtClass(CtClass<T> ctClass)`	Visits a class declaration.
`<T> void`	`visitCtCodeSnippetExpression(CtCodeSnippetExpression<T> expression)`	Visits a code snippet expression.
`void`	`visitCtCodeSnippetStatement(CtCodeSnippetStatement statement)`	Visits a code snippet statement.
`void`	`visitCtComment(CtComment comment)`	Visits a comment
`void`	`visitCtCompilationUnit(CtCompilationUnit compilationUnit)`	Visits a compilation unit
`<T> void`	`visitCtConditional(CtConditional<T> conditional)`	Visits a conditional expression
`<T> void`	`visitCtConstructor(CtConstructor<T> c)`	Visits a constructor declaration.
`<T> void`	`visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall)`	Visits a call to a constructor.
`void`	`visitCtContinue(CtContinue continueStatement)`	Visits a `continue` statement.
`void`	`visitCtDo(CtDo doLoop)`	Visits a `do` loop.
`<T extends Enum<?>> void`	`visitCtEnum(CtEnum<T> ctEnum)`	Visits an enumeration declaration.
`<T> void`	`visitCtEnumValue(CtEnumValue<T> enumValue)`	Visits an enum value declaration.
`<T> void`	`visitCtExecutableReference(CtExecutableReference<T> reference)`	Visits a reference to an executable.
`<T,E extends CtExpression<?>> void`	`visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)`	Visits a reference to an executable.
`<T> void`	`visitCtField(CtField<T> f)`	Visits a field declaration.
`<T> void`	`visitCtFieldRead(CtFieldRead<T> fieldRead)`	Visits a field read access.
`<T> void`	`visitCtFieldReference(CtFieldReference<T> reference)`	Visits a reference to a field.
`<T> void`	`visitCtFieldWrite(CtFieldWrite<T> fieldWrite)`	Visits a field write access.
`void`	`visitCtFor(CtFor forLoop)`	Visits a `for` loop.
`void`	`visitCtForEach(CtForEach foreach)`	Visits an enhanced `for` loop.
`void`	`visitCtIf(CtIf ifElement)`	Visits an `if` statement.
`void`	`visitCtImport(CtImport ctImport)`	Visits an import declaration
`<T> void`	`visitCtInterface(CtInterface<T> intrface)`	Visits an interface declaration.
`<T> void`	`visitCtIntersectionTypeReference(CtIntersectionTypeReference<T> reference)`	Visits an intersection type.
`<T> void`	`visitCtInvocation(CtInvocation<T> invocation)`	Visits an executable invocation.
`void`	`visitCtJavaDoc(CtJavaDoc javaDoc)`	Visits a javadoc comment
`void`	`visitCtJavaDocTag(CtJavaDocTag docTag)`	Visits a javadoc tag
`<T> void`	`visitCtLambda(CtLambda<T> lambda)`	Visits an anonymous method construction.
`<T> void`	`visitCtLiteral(CtLiteral<T> literal)`	Visits a literal expression.
`<T> void`	`visitCtLocalVariable(CtLocalVariable<T> localVariable)`	Visits a local variable declaration.
`<T> void`	`visitCtLocalVariableReference(CtLocalVariableReference<T> reference)`	Visits a reference to a local variable.
`<T> void`	`visitCtMethod(CtMethod<T> m)`	Visits a method declaration.
`void`	`visitCtModule(CtModule module)`	Visits a module declaration
`void`	`visitCtModuleReference(CtModuleReference moduleReference)`	Visits a module reference
`void`	`visitCtModuleRequirement(CtModuleRequirement moduleRequirement)`	Visits a "require" directive in a module declaration.
`<T> void`	`visitCtNewArray(CtNewArray<T> newArray)`	Visits an array construction.
`<T> void`	`visitCtNewClass(CtNewClass<T> newClass)`	Visits an anonymous class construction.
`<T,A extends T> void`	`visitCtOperatorAssignment(CtOperatorAssignment<T,A> assignment)`	Visits an operator assignment.
`void`	`visitCtPackage(CtPackage ctPackage)`	Visits a package declaration.
`void`	`visitCtPackageDeclaration(CtPackageDeclaration packageDeclaration)`	Visits a package declaration
`void`	`visitCtPackageExport(CtPackageExport moduleExport)`	Visits a package export in a module declaration.
`void`	`visitCtPackageReference(CtPackageReference reference)`	Visits a reference to a package.
`<T> void`	`visitCtParameter(CtParameter<T> parameter)`	Visits a parameter declaration.
`<T> void`	`visitCtParameterReference(CtParameterReference<T> reference)`	Visits a reference to a parameter.
`void`	`visitCtProvidedService(CtProvidedService moduleProvidedService)`	Visits a "provides" directive in a module declaration.
`void`	`visitCtRecord(CtRecord recordType)`	Visits a record.
`void`	`visitCtRecordComponent(CtRecordComponent recordType)`	Visits a record component.
`<R> void`	`visitCtReturn(CtReturn<R> returnStatement)`	Visits a `return` statement.
`<R> void`	`visitCtStatementList(CtStatementList statements)`	Visits a statement list.
`<T> void`	`visitCtSuperAccess(CtSuperAccess<T> f)`	Visits an access to a super invocation.
`<S> void`	`visitCtSwitch(CtSwitch<S> switchStatement)`	Visits a `switch` statement.
`<T,S> void`	`visitCtSwitchExpression(CtSwitchExpression<T,S> switchExpression)`	Visits a `switch` expression.
`void`	`visitCtSynchronized(CtSynchronized synchro)`	Visits a `synchronized` modifier.
`void`	`visitCtTextBlock(CtTextBlock literal)`	Visits a literal TextBlock string.
`<T> void`	`visitCtThisAccess(CtThisAccess<T> thisAccess)`	Visits a this access.
`void`	`visitCtThrow(CtThrow throwStatement)`	Visits a `throw` statement.
`void`	`visitCtTry(CtTry tryBlock)`	Visits a `try` statement.
`void`	`visitCtTryWithResource(CtTryWithResource tryWithResource)`	Visits a `try` with resource statement.
`<T> void`	`visitCtTypeAccess(CtTypeAccess<T> typeAccess)`	Visits a type access.
`void`	`visitCtTypeMemberWildcardImportReference(CtTypeMemberWildcardImportReference wildcardReference)`	Visits an import wildcard static type member reference
`void`	`visitCtTypeParameter(CtTypeParameter typeParameter)`	Visits a type parameter declaration.
`void`	`visitCtTypeParameterReference(CtTypeParameterReference ref)`	Visits a reference to a type parameter.
`void`	`visitCtTypePattern(CtTypePattern pattern)`	Visits a pattern.
`<T> void`	`visitCtTypeReference(CtTypeReference<T> reference)`	Visits a reference to a type.
`<T> void`	`visitCtUnaryOperator(CtUnaryOperator<T> operator)`	Visits a unary operator.
`<T> void`	`visitCtUnboundVariableReference(CtUnboundVariableReference<T> reference)`	Visits a reference to an unbound field
`void`	`visitCtUsedService(CtUsedService usedService)`	Visits a "uses" directive in a module declaration.
`<T> void`	`visitCtVariableRead(CtVariableRead<T> variableRead)`	Visits a variable read access.
`<T> void`	`visitCtVariableWrite(CtVariableWrite<T> variableWrite)`	Visits a variable write access.
`void`	`visitCtWhile(CtWhile whileLoop)`	Visits a `while` loop.
`void`	`visitCtWildcardReference(CtWildcardReference wildcardReference)`	Visits a reference to a wildcard.
`void`	`visitCtYieldStatement(CtYieldStatement statement)`	Visits a yield statement.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - CtScanner
```
public CtScanner()
```
    Default constructor.
- Method Detail
  - enter
```
protected void enter(CtElement e)
```
    This method is upcalled by the scanner when entering a scanned element. To be overridden to implement specific scanners.
  - exit
```
protected void exit(CtElement e)
```
    This method is upcalled by the scanner when exiting a scanned element. To be overridden to implement specific scanners.
  - scan
```
public void scan(CtRole role,
                 Collection<? extends CtElement> elements)
```
    Generically scans a collection of meta-model elements.
    
    Parameters:
    
    role - Role of the collection in the parent element
    
    elements - A collection of elements to scan (generally sibling elements)
  - scan
```
public void scan(CtRole role,
                 Map<String,? extends CtElement> elements)
```
    Generically scans a Map of meta-model elements.
    
    Parameters:
    
    role - Role of the map in the parent element
    
    elements - A map of elements to scan (generally sibling elements)
  - scan
```
public void scan(Collection<? extends CtElement> elements)
```
    Generically scans a collection of meta-model elements.
    
    Parameters:
    
    elements - A collection of elements
  - scan
```
public void scan(CtRole role,
                 CtElement element)
```
    Generically scans a meta-model element.
    
    Parameters:
    
    role - Role of the element in its parent
    
    element - An element to scan
  - scan
```
public void scan(CtElement element)
```
    Generically scans a meta-model element.
    
    Parameters:
    
    element - An element to scan
  - visitCtAnnotation
```
public <A extends Annotation> void visitCtAnnotation(CtAnnotation<A> annotation)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation.
    
    Specified by:
    
    visitCtAnnotation in interface CtVisitor
  - scan
```
public void scan(Object o)
```
    Generically scans an object that can be an element, a reference, or a collection of those.
    
    Parameters:
    
    o - A CtElement, or a Map or Collection of elements
  - scan
```
public void scan(CtRole role,
                 Object o)
```
    Generically scans an object that can be an element, a reference, or a collection of those.
    
    Parameters:
    
    role - Role of the object in its parent
    
    o - A CtElement, or a Map or Collection of elements
  - visitCtAnnotationType
```
public <A extends Annotation> void visitCtAnnotationType(CtAnnotationType<A> annotationType)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation type declaration.
    
    Specified by:
    
    visitCtAnnotationType in interface CtVisitor
  - visitCtAnonymousExecutable
```
public void visitCtAnonymousExecutable(CtAnonymousExecutable anonymousExec)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous executable.
    
    Specified by:
    
    visitCtAnonymousExecutable in interface CtVisitor
  - visitCtArrayRead
```
public <T> void visitCtArrayRead(CtArrayRead<T> arrayRead)
```
    Description copied from interface: CtVisitor
    
    Visits an array read access.
    
    Specified by:
    
    visitCtArrayRead in interface CtVisitor
  - visitCtArrayWrite
```
public <T> void visitCtArrayWrite(CtArrayWrite<T> arrayWrite)
```
    Description copied from interface: CtVisitor
    
    Visits an array write access.
    
    Specified by:
    
    visitCtArrayWrite in interface CtVisitor
  - visitCtArrayTypeReference
```
public <T> void visitCtArrayTypeReference(CtArrayTypeReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an array type.
    
    Specified by:
    
    visitCtArrayTypeReference in interface CtVisitor
  - visitCtAssert
```
public <T> void visitCtAssert(CtAssert<T> asserted)
```
    Description copied from interface: CtVisitor
    
    Visits an assert.
    
    Specified by:
    
    visitCtAssert in interface CtVisitor
  - visitCtAssignment
```
public <T,A extends T> void visitCtAssignment(CtAssignment<T,A> assignement)
```
    Description copied from interface: CtVisitor
    
    Visits an assignment.
    
    Specified by:
    
    visitCtAssignment in interface CtVisitor
  - visitCtBinaryOperator
```
public <T> void visitCtBinaryOperator(CtBinaryOperator<T> operator)
```
    Description copied from interface: CtVisitor
    
    Visits a binary operator.
    
    Specified by:
    
    visitCtBinaryOperator in interface CtVisitor
  - visitCtBlock
```
public <R> void visitCtBlock(CtBlock<R> block)
```
    Description copied from interface: CtVisitor
    
    Visits a block of code.
    
    Specified by:
    
    visitCtBlock in interface CtVisitor
  - visitCtBreak
```
public void visitCtBreak(CtBreak breakStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a break statement.
    
    Specified by:
    
    visitCtBreak in interface CtVisitor
  - visitCtCase
```
public <S> void visitCtCase(CtCase<S> caseStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a case clause.
    
    Specified by:
    
    visitCtCase in interface CtVisitor
  - visitCtCatch
```
public void visitCtCatch(CtCatch catchBlock)
```
    Description copied from interface: CtVisitor
    
    Visits a catch clause.
    
    Specified by:
    
    visitCtCatch in interface CtVisitor
  - visitCtClass
```
public <T> void visitCtClass(CtClass<T> ctClass)
```
    Description copied from interface: CtVisitor
    
    Visits a class declaration.
    
    Specified by:
    
    visitCtClass in interface CtVisitor
  - visitCtTypeParameter
```
public void visitCtTypeParameter(CtTypeParameter typeParameter)
```
    Description copied from interface: CtVisitor
    
    Visits a type parameter declaration.
    
    Specified by:
    
    visitCtTypeParameter in interface CtVisitor
  - visitCtConditional
```
public <T> void visitCtConditional(CtConditional<T> conditional)
```
    Description copied from interface: CtVisitor
    
    Visits a conditional expression
    
    Specified by:
    
    visitCtConditional in interface CtVisitor
  - visitCtConstructor
```
public <T> void visitCtConstructor(CtConstructor<T> c)
```
    Description copied from interface: CtVisitor
    
    Visits a constructor declaration.
    
    Specified by:
    
    visitCtConstructor in interface CtVisitor
  - visitCtContinue
```
public void visitCtContinue(CtContinue continueStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a continue statement.
    
    Specified by:
    
    visitCtContinue in interface CtVisitor
  - visitCtDo
```
public void visitCtDo(CtDo doLoop)
```
    Description copied from interface: CtVisitor
    
    Visits a do loop.
    
    Specified by:
    
    visitCtDo in interface CtVisitor
  - visitCtEnum
```
public <T extends Enum<?>> void visitCtEnum(CtEnum<T> ctEnum)
```
    Description copied from interface: CtVisitor
    
    Visits an enumeration declaration.
    
    Specified by:
    
    visitCtEnum in interface CtVisitor
  - visitCtExecutableReference
```
public <T> void visitCtExecutableReference(CtExecutableReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an executable.
    
    Specified by:
    
    visitCtExecutableReference in interface CtVisitor
  - visitCtField
```
public <T> void visitCtField(CtField<T> f)
```
    Description copied from interface: CtVisitor
    
    Visits a field declaration.
    
    Specified by:
    
    visitCtField in interface CtVisitor
  - visitCtEnumValue
```
public <T> void visitCtEnumValue(CtEnumValue<T> enumValue)
```
    Description copied from interface: CtVisitor
    
    Visits an enum value declaration.
    
    Specified by:
    
    visitCtEnumValue in interface CtVisitor
  - visitCtThisAccess
```
public <T> void visitCtThisAccess(CtThisAccess<T> thisAccess)
```
    Description copied from interface: CtVisitor
    
    Visits a this access.
    
    Specified by:
    
    visitCtThisAccess in interface CtVisitor
  - visitCtAnnotationFieldAccess
```
public <T> void visitCtAnnotationFieldAccess(CtAnnotationFieldAccess<T> annotationFieldAccess)
```
    Description copied from interface: CtVisitor
    
    Visits a field of an annotation.
    
    Specified by:
    
    visitCtAnnotationFieldAccess in interface CtVisitor
  - visitCtFieldReference
```
public <T> void visitCtFieldReference(CtFieldReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a field.
    
    Specified by:
    
    visitCtFieldReference in interface CtVisitor
  - visitCtFor
```
public void visitCtFor(CtFor forLoop)
```
    Description copied from interface: CtVisitor
    
    Visits a for loop.
    
    Specified by:
    
    visitCtFor in interface CtVisitor
  - visitCtForEach
```
public void visitCtForEach(CtForEach foreach)
```
    Description copied from interface: CtVisitor
    
    Visits an enhanced for loop.
    
    Specified by:
    
    visitCtForEach in interface CtVisitor
  - visitCtIf
```
public void visitCtIf(CtIf ifElement)
```
    Description copied from interface: CtVisitor
    
    Visits an if statement.
    
    Specified by:
    
    visitCtIf in interface CtVisitor
  - visitCtInterface
```
public <T> void visitCtInterface(CtInterface<T> intrface)
```
    Description copied from interface: CtVisitor
    
    Visits an interface declaration.
    
    Specified by:
    
    visitCtInterface in interface CtVisitor
  - visitCtInvocation
```
public <T> void visitCtInvocation(CtInvocation<T> invocation)
```
    Description copied from interface: CtVisitor
    
    Visits an executable invocation.
    
    Specified by:
    
    visitCtInvocation in interface CtVisitor
  - visitCtLiteral
```
public <T> void visitCtLiteral(CtLiteral<T> literal)
```
    Description copied from interface: CtVisitor
    
    Visits a literal expression.
    
    Specified by:
    
    visitCtLiteral in interface CtVisitor
  - visitCtTextBlock
```
public void visitCtTextBlock(CtTextBlock literal)
```
    Description copied from interface: CtVisitor
    
    Visits a literal TextBlock string.
    
    Specified by:
    
    visitCtTextBlock in interface CtVisitor
  - visitCtLocalVariable
```
public <T> void visitCtLocalVariable(CtLocalVariable<T> localVariable)
```
    Description copied from interface: CtVisitor
    
    Visits a local variable declaration.
    
    Specified by:
    
    visitCtLocalVariable in interface CtVisitor
  - visitCtLocalVariableReference
```
public <T> void visitCtLocalVariableReference(CtLocalVariableReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a local variable.
    
    Specified by:
    
    visitCtLocalVariableReference in interface CtVisitor
  - visitCtCatchVariable
```
public <T> void visitCtCatchVariable(CtCatchVariable<T> catchVariable)
```
    Description copied from interface: CtVisitor
    
    Visits a catch variable declaration.
    
    Specified by:
    
    visitCtCatchVariable in interface CtVisitor
  - visitCtCatchVariableReference
```
public <T> void visitCtCatchVariableReference(CtCatchVariableReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a catch variable.
    
    Specified by:
    
    visitCtCatchVariableReference in interface CtVisitor
  - visitCtMethod
```
public <T> void visitCtMethod(CtMethod<T> m)
```
    Description copied from interface: CtVisitor
    
    Visits a method declaration.
    
    Specified by:
    
    visitCtMethod in interface CtVisitor
  - visitCtAnnotationMethod
```
public <T> void visitCtAnnotationMethod(CtAnnotationMethod<T> annotationMethod)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation method declaration.
    
    Specified by:
    
    visitCtAnnotationMethod in interface CtVisitor
  - visitCtNewArray
```
public <T> void visitCtNewArray(CtNewArray<T> newArray)
```
    Description copied from interface: CtVisitor
    
    Visits an array construction.
    
    Specified by:
    
    visitCtNewArray in interface CtVisitor
  - visitCtConstructorCall
```
public <T> void visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall)
```
    Description copied from interface: CtVisitor
    
    Visits a call to a constructor.
    
    Specified by:
    
    visitCtConstructorCall in interface CtVisitor
  - visitCtNewClass
```
public <T> void visitCtNewClass(CtNewClass<T> newClass)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous class construction.
    
    Specified by:
    
    visitCtNewClass in interface CtVisitor
  - visitCtLambda
```
public <T> void visitCtLambda(CtLambda<T> lambda)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous method construction.
    
    Specified by:
    
    visitCtLambda in interface CtVisitor
  - visitCtExecutableReferenceExpression
```
public <T,E extends CtExpression<?>> void visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an executable.
    
    Specified by:
    
    visitCtExecutableReferenceExpression in interface CtVisitor
  - visitCtOperatorAssignment
```
public <T,A extends T> void visitCtOperatorAssignment(CtOperatorAssignment<T,A> assignment)
```
    Description copied from interface: CtVisitor
    
    Visits an operator assignment.
    
    Specified by:
    
    visitCtOperatorAssignment in interface CtVisitor
  - visitCtPackage
```
public void visitCtPackage(CtPackage ctPackage)
```
    Description copied from interface: CtVisitor
    
    Visits a package declaration.
    
    Specified by:
    
    visitCtPackage in interface CtVisitor
  - visitCtPackageReference
```
public void visitCtPackageReference(CtPackageReference reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a package.
    
    Specified by:
    
    visitCtPackageReference in interface CtVisitor
  - visitCtParameter
```
public <T> void visitCtParameter(CtParameter<T> parameter)
```
    Description copied from interface: CtVisitor
    
    Visits a parameter declaration.
    
    Specified by:
    
    visitCtParameter in interface CtVisitor
  - visitCtParameterReference
```
public <T> void visitCtParameterReference(CtParameterReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a parameter.
    
    Specified by:
    
    visitCtParameterReference in interface CtVisitor
  - visitCtReturn
```
public <R> void visitCtReturn(CtReturn<R> returnStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a return statement.
    
    Specified by:
    
    visitCtReturn in interface CtVisitor
  - visitCtStatementList
```
public <R> void visitCtStatementList(CtStatementList statements)
```
    Description copied from interface: CtVisitor
    
    Visits a statement list.
    
    Specified by:
    
    visitCtStatementList in interface CtVisitor
  - visitCtSwitch
```
public <S> void visitCtSwitch(CtSwitch<S> switchStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a switch statement.
    
    Specified by:
    
    visitCtSwitch in interface CtVisitor
  - visitCtSwitchExpression
```
public <T,S> void visitCtSwitchExpression(CtSwitchExpression<T,S> switchExpression)
```
    Description copied from interface: CtVisitor
    
    Visits a switch expression.
    
    Specified by:
    
    visitCtSwitchExpression in interface CtVisitor
  - visitCtSynchronized
```
public void visitCtSynchronized(CtSynchronized synchro)
```
    Description copied from interface: CtVisitor
    
    Visits a synchronized modifier.
    
    Specified by:
    
    visitCtSynchronized in interface CtVisitor
  - visitCtThrow
```
public void visitCtThrow(CtThrow throwStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a throw statement.
    
    Specified by:
    
    visitCtThrow in interface CtVisitor
  - visitCtTry
```
public void visitCtTry(CtTry tryBlock)
```
    Description copied from interface: CtVisitor
    
    Visits a try statement.
    
    Specified by:
    
    visitCtTry in interface CtVisitor
  - visitCtTryWithResource
```
public void visitCtTryWithResource(CtTryWithResource tryWithResource)
```
    Description copied from interface: CtVisitor
    
    Visits a try with resource statement.
    
    Specified by:
    
    visitCtTryWithResource in interface CtVisitor
  - visitCtTypeParameterReference
```
public void visitCtTypeParameterReference(CtTypeParameterReference ref)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a type parameter.
    
    Specified by:
    
    visitCtTypeParameterReference in interface CtVisitor
  - visitCtWildcardReference
```
public void visitCtWildcardReference(CtWildcardReference wildcardReference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a wildcard.
    
    Specified by:
    
    visitCtWildcardReference in interface CtVisitor
  - visitCtIntersectionTypeReference
```
public <T> void visitCtIntersectionTypeReference(CtIntersectionTypeReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits an intersection type.
    
    Specified by:
    
    visitCtIntersectionTypeReference in interface CtVisitor
  - visitCtTypeReference
```
public <T> void visitCtTypeReference(CtTypeReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a type.
    
    Specified by:
    
    visitCtTypeReference in interface CtVisitor
  - visitCtTypeAccess
```
public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess)
```
    Description copied from interface: CtVisitor
    
    Visits a type access.
    
    Specified by:
    
    visitCtTypeAccess in interface CtVisitor
  - visitCtUnaryOperator
```
public <T> void visitCtUnaryOperator(CtUnaryOperator<T> operator)
```
    Description copied from interface: CtVisitor
    
    Visits a unary operator.
    
    Specified by:
    
    visitCtUnaryOperator in interface CtVisitor
  - visitCtVariableRead
```
public <T> void visitCtVariableRead(CtVariableRead<T> variableRead)
```
    Description copied from interface: CtVisitor
    
    Visits a variable read access.
    
    Specified by:
    
    visitCtVariableRead in interface CtVisitor
  - visitCtVariableWrite
```
public <T> void visitCtVariableWrite(CtVariableWrite<T> variableWrite)
```
    Description copied from interface: CtVisitor
    
    Visits a variable write access.
    
    Specified by:
    
    visitCtVariableWrite in interface CtVisitor
  - visitCtWhile
```
public void visitCtWhile(CtWhile whileLoop)
```
    Description copied from interface: CtVisitor
    
    Visits a while loop.
    
    Specified by:
    
    visitCtWhile in interface CtVisitor
  - visitCtCodeSnippetExpression
```
public <T> void visitCtCodeSnippetExpression(CtCodeSnippetExpression<T> expression)
```
    Description copied from interface: CtVisitor
    
    Visits a code snippet expression.
    
    Specified by:
    
    visitCtCodeSnippetExpression in interface CtVisitor
  - visitCtCodeSnippetStatement
```
public void visitCtCodeSnippetStatement(CtCodeSnippetStatement statement)
```
    Description copied from interface: CtVisitor
    
    Visits a code snippet statement.
    
    Specified by:
    
    visitCtCodeSnippetStatement in interface CtVisitor
  - visitCtUnboundVariableReference
```
public <T> void visitCtUnboundVariableReference(CtUnboundVariableReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to an unbound field
    
    Specified by:
    
    visitCtUnboundVariableReference in interface CtVisitor
  - visitCtFieldRead
```
public <T> void visitCtFieldRead(CtFieldRead<T> fieldRead)
```
    Description copied from interface: CtVisitor
    
    Visits a field read access.
    
    Specified by:
    
    visitCtFieldRead in interface CtVisitor
  - visitCtFieldWrite
```
public <T> void visitCtFieldWrite(CtFieldWrite<T> fieldWrite)
```
    Description copied from interface: CtVisitor
    
    Visits a field write access.
    
    Specified by:
    
    visitCtFieldWrite in interface CtVisitor
  - visitCtSuperAccess
```
public <T> void visitCtSuperAccess(CtSuperAccess<T> f)
```
    Description copied from interface: CtVisitor
    
    Visits an access to a super invocation.
    
    Specified by:
    
    visitCtSuperAccess in interface CtVisitor
  - visitCtComment
```
public void visitCtComment(CtComment comment)
```
    Description copied from interface: CtVisitor
    
    Visits a comment
    
    Specified by:
    
    visitCtComment in interface CtVisitor
  - visitCtJavaDoc
```
public void visitCtJavaDoc(CtJavaDoc javaDoc)
```
    Description copied from interface: CtVisitor
    
    Visits a javadoc comment
    
    Specified by:
    
    visitCtJavaDoc in interface CtVisitor
  - visitCtJavaDocTag
```
public void visitCtJavaDocTag(CtJavaDocTag docTag)
```
    Description copied from interface: CtVisitor
    
    Visits a javadoc tag
    
    Specified by:
    
    visitCtJavaDocTag in interface CtVisitor
  - visitCtImport
```
public void visitCtImport(CtImport ctImport)
```
    Description copied from interface: CtVisitor
    
    Visits an import declaration
    
    Specified by:
    
    visitCtImport in interface CtVisitor
  - visitCtModule
```
public void visitCtModule(CtModule module)
```
    Description copied from interface: CtVisitor
    
    Visits a module declaration
    
    Specified by:
    
    visitCtModule in interface CtVisitor
  - visitCtModuleReference
```
public void visitCtModuleReference(CtModuleReference moduleReference)
```
    Description copied from interface: CtVisitor
    
    Visits a module reference
    
    Specified by:
    
    visitCtModuleReference in interface CtVisitor
  - visitCtPackageExport
```
public void visitCtPackageExport(CtPackageExport moduleExport)
```
    Description copied from interface: CtVisitor
    
    Visits a package export in a module declaration.
    
    Specified by:
    
    visitCtPackageExport in interface CtVisitor
  - visitCtModuleRequirement
```
public void visitCtModuleRequirement(CtModuleRequirement moduleRequirement)
```
    Description copied from interface: CtVisitor
    
    Visits a "require" directive in a module declaration.
    
    Specified by:
    
    visitCtModuleRequirement in interface CtVisitor
  - visitCtProvidedService
```
public void visitCtProvidedService(CtProvidedService moduleProvidedService)
```
    Description copied from interface: CtVisitor
    
    Visits a "provides" directive in a module declaration.
    
    Specified by:
    
    visitCtProvidedService in interface CtVisitor
  - visitCtUsedService
```
public void visitCtUsedService(CtUsedService usedService)
```
    Description copied from interface: CtVisitor
    
    Visits a "uses" directive in a module declaration.
    
    Specified by:
    
    visitCtUsedService in interface CtVisitor
  - visitCtCompilationUnit
```
public void visitCtCompilationUnit(CtCompilationUnit compilationUnit)
```
    Description copied from interface: CtVisitor
    
    Visits a compilation unit
    
    Specified by:
    
    visitCtCompilationUnit in interface CtVisitor
  - visitCtPackageDeclaration
```
public void visitCtPackageDeclaration(CtPackageDeclaration packageDeclaration)
```
    Description copied from interface: CtVisitor
    
    Visits a package declaration
    
    Specified by:
    
    visitCtPackageDeclaration in interface CtVisitor
  - visitCtTypeMemberWildcardImportReference
```
public void visitCtTypeMemberWildcardImportReference(CtTypeMemberWildcardImportReference wildcardReference)
```
    Description copied from interface: CtVisitor
    
    Visits an import wildcard static type member reference
    
    Specified by:
    
    visitCtTypeMemberWildcardImportReference in interface CtVisitor
  - visitCtYieldStatement
```
public void visitCtYieldStatement(CtYieldStatement statement)
```
    Description copied from interface: CtVisitor
    
    Visits a yield statement.
    
    Specified by:
    
    visitCtYieldStatement in interface CtVisitor
  - visitCtTypePattern
```
public void visitCtTypePattern(CtTypePattern pattern)
```
    Description copied from interface: CtVisitor
    
    Visits a pattern.
    
    Specified by:
    
    visitCtTypePattern in interface CtVisitor
    
    Parameters:
    
    pattern - the pattern to visit.
  - visitCtRecord
```
public void visitCtRecord(CtRecord recordType)
```
    Description copied from interface: CtVisitor
    
    Visits a record.
    
    Specified by:
    
    visitCtRecord in interface CtVisitor
    
    Parameters:
    
    recordType - the record to visit.
  - visitCtRecordComponent
```
public void visitCtRecordComponent(CtRecordComponent recordType)
```
    Description copied from interface: CtVisitor
    
    Visits a record component.
    
    Specified by:
    
    visitCtRecordComponent in interface CtVisitor
    
    Parameters:
    
    recordType - the record component to visit.

Class CtScanner

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CtScanner

Method Detail

enter

exit

scan

scan

scan

scan

scan

visitCtAnnotation

scan

scan

visitCtAnnotationType

visitCtAnonymousExecutable

visitCtArrayRead

visitCtArrayWrite

visitCtArrayTypeReference

visitCtAssert

visitCtAssignment

visitCtBinaryOperator

visitCtBlock

visitCtBreak

visitCtCase

visitCtCatch

visitCtClass

visitCtTypeParameter

visitCtConditional

visitCtConstructor

visitCtContinue

visitCtDo

visitCtEnum

visitCtExecutableReference

visitCtField

visitCtEnumValue

visitCtThisAccess

visitCtAnnotationFieldAccess

visitCtFieldReference

visitCtFor

visitCtForEach

visitCtIf

visitCtInterface

visitCtInvocation

visitCtLiteral

visitCtTextBlock

visitCtLocalVariable

visitCtLocalVariableReference

visitCtCatchVariable

visitCtCatchVariableReference

visitCtMethod

visitCtAnnotationMethod

visitCtNewArray

visitCtConstructorCall

visitCtNewClass

visitCtLambda

visitCtExecutableReferenceExpression

visitCtOperatorAssignment

visitCtPackage

visitCtPackageReference

visitCtParameter

visitCtParameterReference

visitCtReturn

visitCtStatementList

visitCtSwitch

visitCtSwitchExpression

visitCtSynchronized

visitCtThrow

visitCtTry

visitCtTryWithResource

visitCtTypeParameterReference

visitCtWildcardReference

visitCtIntersectionTypeReference

visitCtTypeReference

visitCtTypeAccess

visitCtUnaryOperator

visitCtVariableRead