ReplacementVisitor (Spoon Core 9.1.0-SNAPSHOT API)

java.lang.Object
- spoon.reflect.visitor.CtScanner
- - spoon.support.visitor.replace.ReplacementVisitor

All Implemented Interfaces:

CtVisitor
```
public class ReplacementVisitor
extends CtScanner
```
Used to replace an element by another one. This class is generated automatically by the processor spoon.generating.ReplacementVisitorGenerator.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static <E extends CtElement> void`	`replace(CtElement original, java.util.Collection<E> replaces)`
`static void`	`replace(CtElement original, CtElement replace)`
`<A extends java.lang.annotation.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 java.lang.annotation.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 java.lang.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.
`<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.
`<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 spoon.reflect.visitor.CtScanner
enter, exit, scan, scan, scan, scan, scan, scan, scan

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

- Method Detail
  - replace
```
public static void replace(CtElement original,
                           CtElement replace)
```
  - replace
```
public static <E extends CtElement> void replace(CtElement original,
                                                 java.util.Collection<E> replaces)
```
  - visitCtAnnotation
```
public <A extends java.lang.annotation.Annotation> void visitCtAnnotation(CtAnnotation<A> annotation)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation.
    
    Specified by:
    
    visitCtAnnotation in interface CtVisitor
    
    Overrides:
    
    visitCtAnnotation in class CtScanner
  - visitCtAnnotationType
```
public <A extends java.lang.annotation.Annotation> void visitCtAnnotationType(CtAnnotationType<A> annotationType)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation type declaration.
    
    Specified by:
    
    visitCtAnnotationType in interface CtVisitor
    
    Overrides:
    
    visitCtAnnotationType in class CtScanner
  - visitCtAnonymousExecutable
```
public void visitCtAnonymousExecutable(CtAnonymousExecutable anonymousExec)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous executable.
    
    Specified by:
    
    visitCtAnonymousExecutable in interface CtVisitor
    
    Overrides:
    
    visitCtAnonymousExecutable in class CtScanner
  - visitCtArrayRead
```
public <T> void visitCtArrayRead(CtArrayRead<T> arrayRead)
```
    Description copied from interface: CtVisitor
    
    Visits an array read access.
    
    Specified by:
    
    visitCtArrayRead in interface CtVisitor
    
    Overrides:
    
    visitCtArrayRead in class CtScanner
  - visitCtArrayWrite
```
public <T> void visitCtArrayWrite(CtArrayWrite<T> arrayWrite)
```
    Description copied from interface: CtVisitor
    
    Visits an array write access.
    
    Specified by:
    
    visitCtArrayWrite in interface CtVisitor
    
    Overrides:
    
    visitCtArrayWrite in class CtScanner
  - 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
    
    Overrides:
    
    visitCtArrayTypeReference in class CtScanner
  - visitCtAssert
```
public <T> void visitCtAssert(CtAssert<T> asserted)
```
    Description copied from interface: CtVisitor
    
    Visits an assert.
    
    Specified by:
    
    visitCtAssert in interface CtVisitor
    
    Overrides:
    
    visitCtAssert in class CtScanner
  - 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
    
    Overrides:
    
    visitCtAssignment in class CtScanner
  - visitCtBinaryOperator
```
public <T> void visitCtBinaryOperator(CtBinaryOperator<T> operator)
```
    Description copied from interface: CtVisitor
    
    Visits a binary operator.
    
    Specified by:
    
    visitCtBinaryOperator in interface CtVisitor
    
    Overrides:
    
    visitCtBinaryOperator in class CtScanner
  - visitCtBlock
```
public <R> void visitCtBlock(CtBlock<R> block)
```
    Description copied from interface: CtVisitor
    
    Visits a block of code.
    
    Specified by:
    
    visitCtBlock in interface CtVisitor
    
    Overrides:
    
    visitCtBlock in class CtScanner
  - visitCtBreak
```
public void visitCtBreak(CtBreak breakStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a break statement.
    
    Specified by:
    
    visitCtBreak in interface CtVisitor
    
    Overrides:
    
    visitCtBreak in class CtScanner
  - visitCtCase
```
public <S> void visitCtCase(CtCase<S> caseStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a case clause.
    
    Specified by:
    
    visitCtCase in interface CtVisitor
    
    Overrides:
    
    visitCtCase in class CtScanner
  - visitCtCatch
```
public void visitCtCatch(CtCatch catchBlock)
```
    Description copied from interface: CtVisitor
    
    Visits a catch clause.
    
    Specified by:
    
    visitCtCatch in interface CtVisitor
    
    Overrides:
    
    visitCtCatch in class CtScanner
  - visitCtClass
```
public <T> void visitCtClass(CtClass<T> ctClass)
```
    Description copied from interface: CtVisitor
    
    Visits a class declaration.
    
    Specified by:
    
    visitCtClass in interface CtVisitor
    
    Overrides:
    
    visitCtClass in class CtScanner
  - visitCtTypeParameter
```
public void visitCtTypeParameter(CtTypeParameter typeParameter)
```
    Description copied from interface: CtVisitor
    
    Visits a type parameter declaration.
    
    Specified by:
    
    visitCtTypeParameter in interface CtVisitor
    
    Overrides:
    
    visitCtTypeParameter in class CtScanner
  - visitCtConditional
```
public <T> void visitCtConditional(CtConditional<T> conditional)
```
    Description copied from interface: CtVisitor
    
    Visits a conditional expression
    
    Specified by:
    
    visitCtConditional in interface CtVisitor
    
    Overrides:
    
    visitCtConditional in class CtScanner
  - visitCtConstructor
```
public <T> void visitCtConstructor(CtConstructor<T> c)
```
    Description copied from interface: CtVisitor
    
    Visits a constructor declaration.
    
    Specified by:
    
    visitCtConstructor in interface CtVisitor
    
    Overrides:
    
    visitCtConstructor in class CtScanner
  - visitCtContinue
```
public void visitCtContinue(CtContinue continueStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a continue statement.
    
    Specified by:
    
    visitCtContinue in interface CtVisitor
    
    Overrides:
    
    visitCtContinue in class CtScanner
  - visitCtDo
```
public void visitCtDo(CtDo doLoop)
```
    Description copied from interface: CtVisitor
    
    Visits a do loop.
    
    Specified by:
    
    visitCtDo in interface CtVisitor
    
    Overrides:
    
    visitCtDo in class CtScanner
  - visitCtEnum
```
public <T extends java.lang.Enum<?>> void visitCtEnum(CtEnum<T> ctEnum)
```
    Description copied from interface: CtVisitor
    
    Visits an enumeration declaration.
    
    Specified by:
    
    visitCtEnum in interface CtVisitor
    
    Overrides:
    
    visitCtEnum in class CtScanner
  - 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
    
    Overrides:
    
    visitCtExecutableReference in class CtScanner
  - visitCtField
```
public <T> void visitCtField(CtField<T> f)
```
    Description copied from interface: CtVisitor
    
    Visits a field declaration.
    
    Specified by:
    
    visitCtField in interface CtVisitor
    
    Overrides:
    
    visitCtField in class CtScanner
  - visitCtEnumValue
```
public <T> void visitCtEnumValue(CtEnumValue<T> enumValue)
```
    Description copied from interface: CtVisitor
    
    Visits an enum value declaration.
    
    Specified by:
    
    visitCtEnumValue in interface CtVisitor
    
    Overrides:
    
    visitCtEnumValue in class CtScanner
  - visitCtThisAccess
```
public <T> void visitCtThisAccess(CtThisAccess<T> thisAccess)
```
    Description copied from interface: CtVisitor
    
    Visits a this access.
    
    Specified by:
    
    visitCtThisAccess in interface CtVisitor
    
    Overrides:
    
    visitCtThisAccess in class CtScanner
  - 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
    
    Overrides:
    
    visitCtAnnotationFieldAccess in class CtScanner
  - 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
    
    Overrides:
    
    visitCtFieldReference in class CtScanner
  - visitCtFor
```
public void visitCtFor(CtFor forLoop)
```
    Description copied from interface: CtVisitor
    
    Visits a for loop.
    
    Specified by:
    
    visitCtFor in interface CtVisitor
    
    Overrides:
    
    visitCtFor in class CtScanner
  - visitCtForEach
```
public void visitCtForEach(CtForEach foreach)
```
    Description copied from interface: CtVisitor
    
    Visits an enhanced for loop.
    
    Specified by:
    
    visitCtForEach in interface CtVisitor
    
    Overrides:
    
    visitCtForEach in class CtScanner
  - visitCtIf
```
public void visitCtIf(CtIf ifElement)
```
    Description copied from interface: CtVisitor
    
    Visits an if statement.
    
    Specified by:
    
    visitCtIf in interface CtVisitor
    
    Overrides:
    
    visitCtIf in class CtScanner
  - visitCtInterface
```
public <T> void visitCtInterface(CtInterface<T> intrface)
```
    Description copied from interface: CtVisitor
    
    Visits an interface declaration.
    
    Specified by:
    
    visitCtInterface in interface CtVisitor
    
    Overrides:
    
    visitCtInterface in class CtScanner
  - visitCtInvocation
```
public <T> void visitCtInvocation(CtInvocation<T> invocation)
```
    Description copied from interface: CtVisitor
    
    Visits an executable invocation.
    
    Specified by:
    
    visitCtInvocation in interface CtVisitor
    
    Overrides:
    
    visitCtInvocation in class CtScanner
  - visitCtLiteral
```
public <T> void visitCtLiteral(CtLiteral<T> literal)
```
    Description copied from interface: CtVisitor
    
    Visits a literal expression.
    
    Specified by:
    
    visitCtLiteral in interface CtVisitor
    
    Overrides:
    
    visitCtLiteral in class CtScanner
  - visitCtTextBlock
```
public void visitCtTextBlock(CtTextBlock literal)
```
    Description copied from interface: CtVisitor
    
    Visits a literal TextBlock string.
    
    Specified by:
    
    visitCtTextBlock in interface CtVisitor
    
    Overrides:
    
    visitCtTextBlock in class CtScanner
  - visitCtLocalVariable
```
public <T> void visitCtLocalVariable(CtLocalVariable<T> localVariable)
```
    Description copied from interface: CtVisitor
    
    Visits a local variable declaration.
    
    Specified by:
    
    visitCtLocalVariable in interface CtVisitor
    
    Overrides:
    
    visitCtLocalVariable in class CtScanner
  - 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
    
    Overrides:
    
    visitCtLocalVariableReference in class CtScanner
  - visitCtCatchVariable
```
public <T> void visitCtCatchVariable(CtCatchVariable<T> catchVariable)
```
    Description copied from interface: CtVisitor
    
    Visits a catch variable declaration.
    
    Specified by:
    
    visitCtCatchVariable in interface CtVisitor
    
    Overrides:
    
    visitCtCatchVariable in class CtScanner
  - 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
    
    Overrides:
    
    visitCtCatchVariableReference in class CtScanner
  - visitCtMethod
```
public <T> void visitCtMethod(CtMethod<T> m)
```
    Description copied from interface: CtVisitor
    
    Visits a method declaration.
    
    Specified by:
    
    visitCtMethod in interface CtVisitor
    
    Overrides:
    
    visitCtMethod in class CtScanner
  - visitCtAnnotationMethod
```
public <T> void visitCtAnnotationMethod(CtAnnotationMethod<T> annotationMethod)
```
    Description copied from interface: CtVisitor
    
    Visits an annotation method declaration.
    
    Specified by:
    
    visitCtAnnotationMethod in interface CtVisitor
    
    Overrides:
    
    visitCtAnnotationMethod in class CtScanner
  - visitCtNewArray
```
public <T> void visitCtNewArray(CtNewArray<T> newArray)
```
    Description copied from interface: CtVisitor
    
    Visits an array construction.
    
    Specified by:
    
    visitCtNewArray in interface CtVisitor
    
    Overrides:
    
    visitCtNewArray in class CtScanner
  - 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
    
    Overrides:
    
    visitCtConstructorCall in class CtScanner
  - visitCtNewClass
```
public <T> void visitCtNewClass(CtNewClass<T> newClass)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous class construction.
    
    Specified by:
    
    visitCtNewClass in interface CtVisitor
    
    Overrides:
    
    visitCtNewClass in class CtScanner
  - visitCtLambda
```
public <T> void visitCtLambda(CtLambda<T> lambda)
```
    Description copied from interface: CtVisitor
    
    Visits an anonymous method construction.
    
    Specified by:
    
    visitCtLambda in interface CtVisitor
    
    Overrides:
    
    visitCtLambda in class CtScanner
  - 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
    
    Overrides:
    
    visitCtExecutableReferenceExpression in class CtScanner
  - 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
    
    Overrides:
    
    visitCtOperatorAssignment in class CtScanner
  - visitCtPackage
```
public void visitCtPackage(CtPackage ctPackage)
```
    Description copied from interface: CtVisitor
    
    Visits a package declaration.
    
    Specified by:
    
    visitCtPackage in interface CtVisitor
    
    Overrides:
    
    visitCtPackage in class CtScanner
  - visitCtPackageReference
```
public void visitCtPackageReference(CtPackageReference reference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a package.
    
    Specified by:
    
    visitCtPackageReference in interface CtVisitor
    
    Overrides:
    
    visitCtPackageReference in class CtScanner
  - visitCtParameter
```
public <T> void visitCtParameter(CtParameter<T> parameter)
```
    Description copied from interface: CtVisitor
    
    Visits a parameter declaration.
    
    Specified by:
    
    visitCtParameter in interface CtVisitor
    
    Overrides:
    
    visitCtParameter in class CtScanner
  - 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
    
    Overrides:
    
    visitCtParameterReference in class CtScanner
  - visitCtReturn
```
public <R> void visitCtReturn(CtReturn<R> returnStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a return statement.
    
    Specified by:
    
    visitCtReturn in interface CtVisitor
    
    Overrides:
    
    visitCtReturn in class CtScanner
  - visitCtStatementList
```
public <R> void visitCtStatementList(CtStatementList statements)
```
    Description copied from interface: CtVisitor
    
    Visits a statement list.
    
    Specified by:
    
    visitCtStatementList in interface CtVisitor
    
    Overrides:
    
    visitCtStatementList in class CtScanner
  - visitCtSwitch
```
public <S> void visitCtSwitch(CtSwitch<S> switchStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a switch statement.
    
    Specified by:
    
    visitCtSwitch in interface CtVisitor
    
    Overrides:
    
    visitCtSwitch in class CtScanner
  - 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
    
    Overrides:
    
    visitCtSwitchExpression in class CtScanner
  - visitCtSynchronized
```
public void visitCtSynchronized(CtSynchronized synchro)
```
    Description copied from interface: CtVisitor
    
    Visits a synchronized modifier.
    
    Specified by:
    
    visitCtSynchronized in interface CtVisitor
    
    Overrides:
    
    visitCtSynchronized in class CtScanner
  - visitCtThrow
```
public void visitCtThrow(CtThrow throwStatement)
```
    Description copied from interface: CtVisitor
    
    Visits a throw statement.
    
    Specified by:
    
    visitCtThrow in interface CtVisitor
    
    Overrides:
    
    visitCtThrow in class CtScanner
  - visitCtTry
```
public void visitCtTry(CtTry tryBlock)
```
    Description copied from interface: CtVisitor
    
    Visits a try statement.
    
    Specified by:
    
    visitCtTry in interface CtVisitor
    
    Overrides:
    
    visitCtTry in class CtScanner
  - visitCtTryWithResource
```
public void visitCtTryWithResource(CtTryWithResource tryWithResource)
```
    Description copied from interface: CtVisitor
    
    Visits a try with resource statement.
    
    Specified by:
    
    visitCtTryWithResource in interface CtVisitor
    
    Overrides:
    
    visitCtTryWithResource in class CtScanner
  - visitCtTypeParameterReference
```
public void visitCtTypeParameterReference(CtTypeParameterReference ref)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a type parameter.
    
    Specified by:
    
    visitCtTypeParameterReference in interface CtVisitor
    
    Overrides:
    
    visitCtTypeParameterReference in class CtScanner
  - visitCtWildcardReference
```
public void visitCtWildcardReference(CtWildcardReference wildcardReference)
```
    Description copied from interface: CtVisitor
    
    Visits a reference to a wildcard.
    
    Specified by:
    
    visitCtWildcardReference in interface CtVisitor
    
    Overrides:
    
    visitCtWildcardReference in class CtScanner
  - visitCtIntersectionTypeReference
```
public <T> void visitCtIntersectionTypeReference(CtIntersectionTypeReference<T> reference)
```
    Description copied from interface: CtVisitor
    
    Visits an intersection type.
    
    Specified by:
    
    visitCtIntersectionTypeReference in interface CtVisitor
    
    Overrides:
    
    visitCtIntersectionTypeReference in class CtScanner
  - 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
    
    Overrides:
    
    visitCtTypeReference in class CtScanner
  - visitCtTypeAccess
```
public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess)
```
    Description copied from interface: CtVisitor
    
    Visits a type access.
    
    Specified by:
    
    visitCtTypeAccess in interface CtVisitor
    
    Overrides:
    
    visitCtTypeAccess in class CtScanner
  - visitCtUnaryOperator
```
public <T> void visitCtUnaryOperator(CtUnaryOperator<T> operator)
```
    Description copied from interface: CtVisitor
    
    Visits a unary operator.
    
    Specified by:
    
    visitCtUnaryOperator in interface CtVisitor
    
    Overrides:
    
    visitCtUnaryOperator in class CtScanner
  - visitCtVariableRead
```
public <T> void visitCtVariableRead(CtVariableRead<T> variableRead)
```
    Description copied from interface: CtVisitor
    
    Visits a variable read access.
    
    Specified by:
    
    visitCtVariableRead in interface CtVisitor
    
    Overrides:
    
    visitCtVariableRead in class CtScanner
  - visitCtVariableWrite
```
public <T> void visitCtVariableWrite(CtVariableWrite<T> variableWrite)
```
    Description copied from interface: CtVisitor
    
    Visits a variable write access.
    
    Specified by:
    
    visitCtVariableWrite in interface CtVisitor
    
    Overrides:
    
    visitCtVariableWrite in class CtScanner
  - visitCtWhile
```
public void visitCtWhile(CtWhile whileLoop)
```
    Description copied from interface: CtVisitor
    
    Visits a while loop.
    
    Specified by:
    
    visitCtWhile in interface CtVisitor
    
    Overrides:
    
    visitCtWhile in class CtScanner
  - visitCtCodeSnippetExpression
```
public <T> void visitCtCodeSnippetExpression(CtCodeSnippetExpression<T> expression)
```
    Description copied from interface: CtVisitor
    
    Visits a code snippet expression.
    
    Specified by:
    
    visitCtCodeSnippetExpression in interface CtVisitor
    
    Overrides:
    
    visitCtCodeSnippetExpression in class CtScanner
  - visitCtCodeSnippetStatement
```
public void visitCtCodeSnippetStatement(CtCodeSnippetStatement statement)
```
    Description copied from interface: CtVisitor
    
    Visits a code snippet statement.
    
    Specified by:
    
    visitCtCodeSnippetStatement in interface CtVisitor
    
    Overrides:
    
    visitCtCodeSnippetStatement in class CtScanner
  - 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
    
    Overrides:
    
    visitCtUnboundVariableReference in class CtScanner
  - visitCtFieldRead
```
public <T> void visitCtFieldRead(CtFieldRead<T> fieldRead)
```
    Description copied from interface: CtVisitor
    
    Visits a field read access.
    
    Specified by:
    
    visitCtFieldRead in interface CtVisitor
    
    Overrides:
    
    visitCtFieldRead in class CtScanner
  - visitCtFieldWrite
```
public <T> void visitCtFieldWrite(CtFieldWrite<T> fieldWrite)
```
    Description copied from interface: CtVisitor
    
    Visits a field write access.
    
    Specified by:
    
    visitCtFieldWrite in interface CtVisitor
    
    Overrides:
    
    visitCtFieldWrite in class CtScanner
  - 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
    
    Overrides:
    
    visitCtSuperAccess in class CtScanner
  - visitCtComment
```
public void visitCtComment(CtComment comment)
```
    Description copied from interface: CtVisitor
    
    Visits a comment
    
    Specified by:
    
    visitCtComment in interface CtVisitor
    
    Overrides:
    
    visitCtComment in class CtScanner
  - visitCtJavaDoc
```
public void visitCtJavaDoc(CtJavaDoc javaDoc)
```
    Description copied from interface: CtVisitor
    
    Visits a javadoc comment
    
    Specified by:
    
    visitCtJavaDoc in interface CtVisitor
    
    Overrides:
    
    visitCtJavaDoc in class CtScanner
  - visitCtJavaDocTag
```
public void visitCtJavaDocTag(CtJavaDocTag docTag)
```
    Description copied from interface: CtVisitor
    
    Visits a javadoc tag
    
    Specified by:
    
    visitCtJavaDocTag in interface CtVisitor
    
    Overrides:
    
    visitCtJavaDocTag in class CtScanner
  - visitCtImport
```
public void visitCtImport(CtImport ctImport)
```
    Description copied from interface: CtVisitor
    
    Visits an import declaration
    
    Specified by:
    
    visitCtImport in interface CtVisitor
    
    Overrides:
    
    visitCtImport in class CtScanner
  - visitCtModule
```
public void visitCtModule(CtModule module)
```
    Description copied from interface: CtVisitor
    
    Visits a module declaration
    
    Specified by:
    
    visitCtModule in interface CtVisitor
    
    Overrides:
    
    visitCtModule in class CtScanner
  - visitCtModuleReference
```
public void visitCtModuleReference(CtModuleReference moduleReference)
```
    Description copied from interface: CtVisitor
    
    Visits a module reference
    
    Specified by:
    
    visitCtModuleReference in interface CtVisitor
    
    Overrides:
    
    visitCtModuleReference in class CtScanner
  - 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
    
    Overrides:
    
    visitCtPackageExport in class CtScanner
  - 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
    
    Overrides:
    
    visitCtModuleRequirement in class CtScanner
  - 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
    
    Overrides:
    
    visitCtProvidedService in class CtScanner
  - 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
    
    Overrides:
    
    visitCtUsedService in class CtScanner
  - visitCtCompilationUnit
```
public void visitCtCompilationUnit(CtCompilationUnit compilationUnit)
```
    Description copied from interface: CtVisitor
    
    Visits a compilation unit
    
    Specified by:
    
    visitCtCompilationUnit in interface CtVisitor
    
    Overrides:
    
    visitCtCompilationUnit in class CtScanner
  - visitCtPackageDeclaration
```
public void visitCtPackageDeclaration(CtPackageDeclaration packageDeclaration)
```
    Description copied from interface: CtVisitor
    
    Visits a package declaration
    
    Specified by:
    
    visitCtPackageDeclaration in interface CtVisitor
    
    Overrides:
    
    visitCtPackageDeclaration in class CtScanner
  - 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
    
    Overrides:
    
    visitCtTypeMemberWildcardImportReference in class CtScanner
  - visitCtYieldStatement
```
public void visitCtYieldStatement(CtYieldStatement statement)
```
    Description copied from interface: CtVisitor
    
    Visits a yield statement.
    
    Specified by:
    
    visitCtYieldStatement in interface CtVisitor
    
    Overrides:
    
    visitCtYieldStatement in class CtScanner

Class ReplacementVisitor

Method Summary

Methods inherited from class spoon.reflect.visitor.CtScanner

Methods inherited from class java.lang.Object

Method Detail

replace

replace

visitCtAnnotation

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

visitCtVariableWrite

visitCtWhile

visitCtCodeSnippetExpression

visitCtCodeSnippetStatement

visitCtUnboundVariableReference

visitCtFieldRead

visitCtFieldWrite

visitCtSuperAccess

visitCtComment