Package org.codehaus.janino.util

# Class AbstractTraverser<EX extends Throwable>

java.lang.Object
org.codehaus.janino.util.AbstractTraverser<EX>

Type Parameters:
  `EX` - The exception that the "`traverse*()`" and "`visit*()`" methods may throw

All Implemented Interfaces:
  `Traverser<EX>`

Direct Known Subclasses:
  `DeclarationCounter`

public class AbstractTraverser<EX extends Throwable> extends Object implements Traverser<EX>
A basic implementation of `Traverser`; each `traverse*(s)` method invokes the `traverse*()` methods of all Java elements subordinate to `x`.

Example:

         LocalClassDeclaration lcd = ...;

         new AbstractTraverser() {

             int n = 0;

             public void
             traverseMethodDeclarator(MethodDeclarator md) {
                 ++this.n;
                 super.traverseMethodDeclarator(md);
             }
         }.visitTypeDeclaration(lcd);

See Also:
  - `visitAnnotation(Java.Annotation)`
  - `visitAtom(Java.Atom)`
  - `visitBlockStatement(Java.BlockStatement)`
  - `visitElementValue(Java.ElementValue)`
  - `visitImportDeclaration(Java.AbstractCompilationUnit.ImportDeclaration)`
  - `visitTypeBodyDeclaration(Java.TypeBodyDeclaration)`
  - `visitTypeDeclaration(Java.TypeDeclaration)`
  - `visitAbstractCompilationUnit(Java.AbstractCompilationUnit)`

## Constructor Summary

Constructors
Constructor
Description
`AbstractTraverser()`
`AbstractTraverser(Traverser<EX> delegate)`

## Method Summary

Modifier and Type
Method
Description
`void`
`traverseAbstractCompilationUnit(Java.AbstractCompilationUnit acu)`
`void`
`traverseAbstractTypeBodyDeclaration(Java.AbstractTypeBodyDeclaration atbd)`
`void`
`traverseAbstractTypeDeclaration(Java.AbstractTypeDeclaration atd)`
`void`
`traverseAlternateConstructorInvocation(Java.AlternateConstructorInvocation aci)`
`void`
`traverseAmbiguousName(Java.AmbiguousName an)`
`void`
`traverseAnnotation(Java.Annotation a)`
`void`
`traverseAnonymousClassDeclaration(Java.AnonymousClassDeclaration acd)`
`void`
`traverseArrayAccessExpression(Java.ArrayAccessExpression aae)`
`void`
`traverseArrayCreationReference(Java.ArrayCreationReference acr)`
`void`
`traverseArrayInitializerOrRvalue(Java.ArrayInitializerOrRvalue aiorv)`
`void`
`traverseArrayLength(Java.ArrayLength al)`
`void`
`traverseArrayType(Java.ArrayType at)`
`void`
`traverseAssertStatement(Java.AssertStatement as)`
`void`
`traverseAssignment(Java.Assignment a)`
`void`
`traverseAtom(Java.Atom a)`
`void`
`traverseBinaryOperation(Java.BinaryOperation bo)`
`void`
`traverseBlock(Java.Block b)`
`void`
`traverseBooleanLiteral(Java.BooleanLiteral bl)`
`void`
`traverseBooleanRvalue(Java.BooleanRvalue brv)`
`void`
`traverseBreakableStatement(Java.BreakableStatement bs)`
`void`
`traverseBreakStatement(Java.BreakStatement bs)`
`void`
`traverseCast(Java.Cast c)`
`void`
`traverseCharacterLiteral(Java.CharacterLiteral cl)`
`void`
`traverseClassDeclaration(Java.AbstractClassDeclaration cd)`
`void`
`traverseClassInstanceCreationReference(Java.ClassInstanceCreationReference cicr)`
`void`
`traverseClassLiteral(Java.ClassLiteral cl)`
`void`
`traverseCompilationUnit(Java.CompilationUnit cu)`
`void`
`traverseConditionalExpression(Java.ConditionalExpression ce)`
`void`
`traverseConstructorDeclarator(Java.ConstructorDeclarator cd)`
`void`
`traverseConstructorInvocation(Java.ConstructorInvocation ci)`
`void`
`traverseContinuableStatement(Java.ContinuableStatement cs)`
`void`
`traverseContinueStatement(Java.ContinueStatement cs)`
`void`
`traverseCrement(Java.Crement c)`
`void`
`traverseDoStatement(Java.DoStatement ds)`
`void`
`traverseElementValue(Java.ElementValue ev)`
`void`
`traverseElementValueArrayInitializer(Java.ElementValueArrayInitializer evai)`
`void`
`traverseEmptyStatement(Java.EmptyStatement es)`
`void`
`traverseEnumConstant(Java.EnumConstant ec)`
`void`
`traverseExpressionStatement(Java.ExpressionStatement es)`
`void`
`traverseFieldAccess(Java.FieldAccess fa)`
`void`
`traverseFieldAccessExpression(Java.FieldAccessExpression fae)`
`void`
`traverseFieldDeclaration(Java.FieldDeclaration fd)`
`void`
`traverseFloatingPointLiteral(Java.FloatingPointLiteral fpl)`
`void`
`traverseForEachStatement(Java.ForEachStatement fes)`
`void`
`traverseFormalParameter(Java.FunctionDeclarator.FormalParameter formalParameter)`
`void`
`traverseFormalParameters(Java.FunctionDeclarator.FormalParameters formalParameters)`
`void`
`traverseForStatement(Java.ForStatement fs)`
`void`
`traverseFunctionDeclarator(Java.FunctionDeclarator fd)`
`void`
`traverseIfStatement(Java.IfStatement is)`
`void`
`traverseImportDeclaration(Java.AbstractCompilationUnit.ImportDeclaration id)`
`void`
`traverseInitializer(Java.Initializer i)`
`void`
`traverseInstanceof(Java.Instanceof io)`
`void`
`traverseIntegerLiteral(Java.IntegerLiteral il)`
`void`
`traverseInterfaceDeclaration(Java.InterfaceDeclaration id)`
`void`
`traverseInvocation(Java.Invocation i)`
`void`
`traverseLabeledStatement(Java.LabeledStatement ls)`
`void`
`traverseLambdaExpression(Java.LambdaExpression le)`
`void`
`traverseLiteral(Java.Literal l)`
`void`
`traverseLocalClassDeclaration(Java.LocalClassDeclaration lcd)`
`void`
`traverseLocalClassDeclarationStatement(Java.LocalClassDeclarationStatement lcds)`
`void`
`traverseLocalVariableAccess(Java.LocalVariableAccess lva)`
`void`
`traverseLocalVariableDeclarationStatement(Java.LocalVariableDeclarationStatement lvds)`
`void`
`traverseLocalVariableDeclaratorResource(Java.TryStatement.LocalVariableDeclaratorResource lvdr)`
`void`
`traverseLocated(Java.Located l)`
`void`
`traverseLvalue(Java.Lvalue lv)`
`void`
`traverseMarkerAnnotation(Java.MarkerAnnotation ma)`
`void`
`traverseMemberAnnotationTypeDeclaration(Java.MemberAnnotationTypeDeclaration matd)`
`void`
`traverseMemberClassDeclaration(Java.MemberClassDeclaration mcd)`
`void`
`traverseMemberEnumDeclaration(Java.MemberEnumDeclaration med)`
`void`
`traverseMemberInterfaceDeclaration(Java.MemberInterfaceDeclaration mid)`
`void`
`traverseMethodDeclarator(Java.MethodDeclarator md)`
`void`
`traverseMethodInvocation(Java.MethodInvocation mi)`
`void`
`traverseMethodReference(Java.MethodReference mr)`
`void`
`traverseModularCompilationUnit(Java.ModularCompilationUnit mcu)`
`void`
`traverseNamedClassDeclaration(Java.NamedClassDeclaration ncd)`
`void`
`traverseNewAnonymousClassInstance(Java.NewAnonymousClassInstance naci)`
`void`
`traverseNewArray(Java.NewArray na)`
`void`
`traverseNewClassInstance(Java.NewClassInstance nci)`
`void`
`traverseNewInitializedArray(Java.NewInitializedArray nia)`
`void`
`traverseNormalAnnotation(Java.NormalAnnotation na)`
`void`
`traverseNullLiteral(Java.NullLiteral nl)`
`void`
`traversePackage(Java.Package p)`
`void`
`traversePackageMemberAnnotationTypeDeclaration(Java.PackageMemberAnnotationTypeDeclaration pmatd)`
`void`
`traversePackageMemberClassDeclaration(Java.PackageMemberClassDeclaration pmcd)`
`void`
`traversePackageMemberEnumDeclaration(Java.PackageMemberEnumDeclaration pmed)`
`void`
`traversePackageMemberInterfaceDeclaration(Java.PackageMemberInterfaceDeclaration pmid)`
`void`
`traverseParameterAccess(Java.ParameterAccess pa)`
`void`
`traverseParenthesizedExpression(Java.ParenthesizedExpression pe)`
`void`
`traversePrimitiveType(Java.PrimitiveType bt)`
`void`
`traverseQualifiedThisReference(Java.QualifiedThisReference qtr)`
`void`
`traverseReferenceType(Java.ReferenceType rt)`
`void`
`traverseReturnStatement(Java.ReturnStatement rs)`
`void`
`traverseRvalue(Java.Rvalue rv)`
`void`
`traverseRvalueMemberType(Java.RvalueMemberType rmt)`
`void`
`traverseSimpleLiteral(Java.SimpleConstant sl)`
`void`
`traverseSimpleType(Java.SimpleType st)`
`void`
`traverseSingleElementAnnotation(Java.SingleElementAnnotation sea)`
`void`
`traverseSingleStaticImportDeclaration(Java.AbstractCompilationUnit.SingleStaticImportDeclaration stid)`
`void`
`traverseSingleTypeImportDeclaration(Java.AbstractCompilationUnit.SingleTypeImportDeclaration stid)`
`void`
`traverseStatement(Java.Statement s)`
`void`
`traverseStaticImportOnDemandDeclaration(Java.AbstractCompilationUnit.StaticImportOnDemandDeclaration siodd)`
`void`
`traverseStringLiteral(Java.StringLiteral sl)`
`void`
`traverseSuperclassFieldAccessExpression(Java.SuperclassFieldAccessExpression scfae)`
`void`
`traverseSuperclassMethodInvocation(Java.SuperclassMethodInvocation smi)`
`void`
`traverseSuperConstructorInvocation(Java.SuperConstructorInvocation sci)`
`void`
`traverseSwitchStatement(Java.SwitchStatement ss)`
`void`
`traverseSynchronizedStatement(Java.SynchronizedStatement ss)`
`void`
`traverseTextBlock(Java.TextBlock tb)`
`void`
`traverseThisReference(Java.ThisReference tr)`
`void`
`traverseThrowStatement(Java.ThrowStatement ts)`
`void`
`traverseTryStatement(Java.TryStatement ts)`
`void`
`traverseType(Java.Type t)`
`void`
`traverseTypeImportOnDemandDeclaration(Java.AbstractCompilationUnit.TypeImportOnDemandDeclaration tiodd)`
`void`
`traverseUnaryOperation(Java.UnaryOperation uo)`
`void`
`traverseVariableAccessResource(Java.TryStatement.VariableAccessResource var)`
`void`
`traverseWhileStatement(Java.WhileStatement ws)`
`void`
`visitAbstractCompilationUnit(Java.AbstractCompilationUnit acu)`
`void`
`visitAnnotation(Java.Annotation a)`
`void`
`visitAtom(Java.Atom a)`
`void`
`visitBlockStatement(Java.BlockStatement bs)`
`void`
`visitElementValue(Java.ElementValue ev)`
`void`
`visitImportDeclaration(Java.AbstractCompilationUnit.ImportDeclaration id)`
`void`
`visitTypeBodyDeclaration(Java.TypeBodyDeclaration tbd)`
`void`
`visitTypeDeclaration(Java.TypeDeclaration td)`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### AbstractTraverser

public AbstractTraverser()

### AbstractTraverser

public AbstractTraverser(Traverser<EX> delegate)

## Method Details

### visitAbstractCompilationUnit

public void visitAbstractCompilationUnit(Java.AbstractCompilationUnit acu) throws EX

Specified by:
  `visitAbstractCompilationUnit` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### visitImportDeclaration

public void visitImportDeclaration(Java.AbstractCompilationUnit.ImportDeclaration id) throws EX

Specified by:
  `visitImportDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### visitTypeDeclaration

public void visitTypeDeclaration(Java.TypeDeclaration td) throws EX

Specified by:
  `visitTypeDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### visitTypeBodyDeclaration

public void visitTypeBodyDeclaration(Java.TypeBodyDeclaration tbd) throws EX

Specified by:
  `visitTypeBodyDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### visitBlockStatement

public void visitBlockStatement(Java.BlockStatement bs) throws EX

Specified by:
  `visitBlockStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### visitAtom

public void visitAtom(Java.Atom a) throws EX

Specified by:
  `visitAtom` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### visitElementValue

public void visitElementValue(Java.ElementValue ev) throws EX

Specified by:
  `visitElementValue` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### visitAnnotation

public void visitAnnotation(Java.Annotation a) throws EX

Specified by:
  `visitAnnotation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseAbstractCompilationUnit

public void traverseAbstractCompilationUnit(Java.AbstractCompilationUnit acu) throws EX

Specified by:
  `traverseAbstractCompilationUnit` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseCompilationUnit

public void traverseCompilationUnit(Java.CompilationUnit cu) throws EX

Specified by:
  `traverseCompilationUnit` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseModularCompilationUnit

public void traverseModularCompilationUnit(Java.ModularCompilationUnit mcu) throws EX

Specified by:
  `traverseModularCompilationUnit` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseSingleTypeImportDeclaration

public void traverseSingleTypeImportDeclaration(Java.AbstractCompilationUnit.SingleTypeImportDeclaration stid) throws EX

Specified by:
  `traverseSingleTypeImportDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseTypeImportOnDemandDeclaration

public void traverseTypeImportOnDemandDeclaration(Java.AbstractCompilationUnit.TypeImportOnDemandDeclaration tiodd) throws EX

Specified by:
  `traverseTypeImportOnDemandDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseSingleStaticImportDeclaration

public void traverseSingleStaticImportDeclaration(Java.AbstractCompilationUnit.SingleStaticImportDeclaration stid) throws EX

Specified by:
  `traverseSingleStaticImportDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseStaticImportOnDemandDeclaration

public void traverseStaticImportOnDemandDeclaration(Java.AbstractCompilationUnit.StaticImportOnDemandDeclaration siodd) throws EX

Specified by:
  `traverseStaticImportOnDemandDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseImportDeclaration

public void traverseImportDeclaration(Java.AbstractCompilationUnit.ImportDeclaration id) throws EX

Specified by:
  `traverseImportDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseAnonymousClassDeclaration

public void traverseAnonymousClassDeclaration(Java.AnonymousClassDeclaration acd) throws EX

Specified by:
  `traverseAnonymousClassDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseLocalClassDeclaration

public void traverseLocalClassDeclaration(Java.LocalClassDeclaration lcd) throws EX

Specified by:
  `traverseLocalClassDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traversePackageMemberClassDeclaration

public void traversePackageMemberClassDeclaration(Java.PackageMemberClassDeclaration pmcd) throws EX

Specified by:
  `traversePackageMemberClassDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseMemberInterfaceDeclaration

public void traverseMemberInterfaceDeclaration(Java.MemberInterfaceDeclaration mid) throws EX

Specified by:
  `traverseMemberInterfaceDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traversePackageMemberInterfaceDeclaration

public void traversePackageMemberInterfaceDeclaration(Java.PackageMemberInterfaceDeclaration pmid) throws EX

Specified by:
  `traversePackageMemberInterfaceDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseMemberClassDeclaration

public void traverseMemberClassDeclaration(Java.MemberClassDeclaration mcd) throws EX

Specified by:
  `traverseMemberClassDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseConstructorDeclarator

public void traverseConstructorDeclarator(Java.ConstructorDeclarator cd) throws EX

Specified by:
  `traverseConstructorDeclarator` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseInitializer

public void traverseInitializer(Java.Initializer i) throws EX

Specified by:
  `traverseInitializer` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseMethodDeclarator

public void traverseMethodDeclarator(Java.MethodDeclarator md) throws EX

Specified by:
  `traverseMethodDeclarator` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseFieldDeclaration

public void traverseFieldDeclaration(Java.FieldDeclaration fd) throws EX

Specified by:
  `traverseFieldDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseLabeledStatement

public void traverseLabeledStatement(Java.LabeledStatement ls) throws EX

Specified by:
  `traverseLabeledStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseBlock

public void traverseBlock(Java.Block b) throws EX

Specified by:
  `traverseBlock` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseExpressionStatement

public void traverseExpressionStatement(Java.ExpressionStatement es) throws EX

Specified by:
  `traverseExpressionStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseIfStatement

public void traverseIfStatement(Java.IfStatement is) throws EX

Specified by:
  `traverseIfStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseForStatement

public void traverseForStatement(Java.ForStatement fs) throws EX

Specified by:
  `traverseForStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseForEachStatement

public void traverseForEachStatement(Java.ForEachStatement fes) throws EX

Specified by:
  `traverseForEachStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseWhileStatement

public void traverseWhileStatement(Java.WhileStatement ws) throws EX

Specified by:
  `traverseWhileStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseTryStatement

public void traverseTryStatement(Java.TryStatement ts) throws EX

Specified by:
  `traverseTryStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseSwitchStatement

public void traverseSwitchStatement(Java.SwitchStatement ss) throws EX

Specified by:
  `traverseSwitchStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseSynchronizedStatement

public void traverseSynchronizedStatement(Java.SynchronizedStatement ss) throws EX

Specified by:
  `traverseSynchronizedStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseDoStatement

public void traverseDoStatement(Java.DoStatement ds) throws EX

Specified by:
  `traverseDoStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseLocalVariableDeclarationStatement

public void traverseLocalVariableDeclarationStatement(Java.LocalVariableDeclarationStatement lvds) throws EX

Specified by:
  `traverseLocalVariableDeclarationStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseReturnStatement

public void traverseReturnStatement(Java.ReturnStatement rs) throws EX

Specified by:
  `traverseReturnStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseThrowStatement

public void traverseThrowStatement(Java.ThrowStatement ts) throws EX

Specified by:
  `traverseThrowStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseBreakStatement

public void traverseBreakStatement(Java.BreakStatement bs) throws EX

Specified by:
  `traverseBreakStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseContinueStatement

public void traverseContinueStatement(Java.ContinueStatement cs) throws EX

Specified by:
  `traverseContinueStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseAssertStatement

public void traverseAssertStatement(Java.AssertStatement as) throws EX

Specified by:
  `traverseAssertStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseEmptyStatement

public void traverseEmptyStatement(Java.EmptyStatement es) throws EX

Specified by:
  `traverseEmptyStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseLocalClassDeclarationStatement

public void traverseLocalClassDeclarationStatement(Java.LocalClassDeclarationStatement lcds) throws EX

Specified by:
  `traverseLocalClassDeclarationStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traversePackage

public void traversePackage(Java.Package p) throws EX

Specified by:
  `traversePackage` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseArrayLength

public void traverseArrayLength(Java.ArrayLength al) throws EX

Specified by:
  `traverseArrayLength` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseAssignment

public void traverseAssignment(Java.Assignment a) throws EX

Specified by:
  `traverseAssignment` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseUnaryOperation

public void traverseUnaryOperation(Java.UnaryOperation uo) throws EX

Specified by:
  `traverseUnaryOperation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseBinaryOperation

public void traverseBinaryOperation(Java.BinaryOperation bo) throws EX

Specified by:
  `traverseBinaryOperation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseCast

public void traverseCast(Java.Cast c) throws EX

Specified by:
  `traverseCast` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseClassLiteral

public void traverseClassLiteral(Java.ClassLiteral cl) throws EX

Specified by:
  `traverseClassLiteral` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseConditionalExpression

public void traverseConditionalExpression(Java.ConditionalExpression ce) throws EX

Specified by:
  `traverseConditionalExpression` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseCrement

public void traverseCrement(Java.Crement c) throws EX

Specified by:
  `traverseCrement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseInstanceof

public void traverseInstanceof(Java.Instanceof io) throws EX

Specified by:
  `traverseInstanceof` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseMethodInvocation

public void traverseMethodInvocation(Java.MethodInvocation mi) throws EX

Specified by:
  `traverseMethodInvocation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseSuperclassMethodInvocation

public void traverseSuperclassMethodInvocation(Java.SuperclassMethodInvocation smi) throws EX

Specified by:
  `traverseSuperclassMethodInvocation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseLiteral

public void traverseLiteral(Java.Literal l) throws EX

Specified by:
  `traverseLiteral` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseIntegerLiteral

public void traverseIntegerLiteral(Java.IntegerLiteral il) throws EX

Specified by:
  `traverseIntegerLiteral` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseFloatingPointLiteral

public void traverseFloatingPointLiteral(Java.FloatingPointLiteral fpl) throws EX

Specified by:
  `traverseFloatingPointLiteral` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseBooleanLiteral

public void traverseBooleanLiteral(Java.BooleanLiteral bl) throws EX

Specified by:
  `traverseBooleanLiteral` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseCharacterLiteral

public void traverseCharacterLiteral(Java.CharacterLiteral cl) throws EX

Specified by:
  `traverseCharacterLiteral` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseStringLiteral

public void traverseStringLiteral(Java.StringLiteral sl) throws EX

Specified by:
  `traverseStringLiteral` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseTextBlock

public void traverseTextBlock(Java.TextBlock tb) throws EX

Specified by:
  `traverseTextBlock` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseNullLiteral

public void traverseNullLiteral(Java.NullLiteral nl) throws EX

Specified by:
  `traverseNullLiteral` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseSimpleLiteral

public void traverseSimpleLiteral(Java.SimpleConstant sl) throws EX

Specified by:
  `traverseSimpleLiteral` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseNewAnonymousClassInstance

public void traverseNewAnonymousClassInstance(Java.NewAnonymousClassInstance naci) throws EX

Specified by:
  `traverseNewAnonymousClassInstance` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseNewArray

public void traverseNewArray(Java.NewArray na) throws EX

Specified by:
  `traverseNewArray` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseNewInitializedArray

public void traverseNewInitializedArray(Java.NewInitializedArray nia) throws EX

Specified by:
  `traverseNewInitializedArray` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseArrayInitializerOrRvalue

public void traverseArrayInitializerOrRvalue(Java.ArrayInitializerOrRvalue aiorv) throws EX

Specified by:
  `traverseArrayInitializerOrRvalue` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseNewClassInstance

public void traverseNewClassInstance(Java.NewClassInstance nci) throws EX

Specified by:
  `traverseNewClassInstance` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseParameterAccess

public void traverseParameterAccess(Java.ParameterAccess pa) throws EX

Specified by:
  `traverseParameterAccess` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseQualifiedThisReference

public void traverseQualifiedThisReference(Java.QualifiedThisReference qtr) throws EX

Specified by:
  `traverseQualifiedThisReference` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseThisReference

public void traverseThisReference(Java.ThisReference tr) throws EX

Specified by:
  `traverseThisReference` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseLambdaExpression

public void traverseLambdaExpression(Java.LambdaExpression le) throws EX

Specified by:
  `traverseLambdaExpression` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseMethodReference

public void traverseMethodReference(Java.MethodReference mr) throws EX

Specified by:
  `traverseMethodReference` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseClassInstanceCreationReference

public void traverseClassInstanceCreationReference(Java.ClassInstanceCreationReference cicr) throws EX

Specified by:
  `traverseClassInstanceCreationReference` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseArrayCreationReference

public void traverseArrayCreationReference(Java.ArrayCreationReference acr) throws EX

Specified by:
  `traverseArrayCreationReference` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseArrayType

public void traverseArrayType(Java.ArrayType at) throws EX

Specified by:
  `traverseArrayType` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traversePrimitiveType

public void traversePrimitiveType(Java.PrimitiveType bt) throws EX

Specified by:
  `traversePrimitiveType` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseReferenceType

public void traverseReferenceType(Java.ReferenceType rt) throws EX

Specified by:
  `traverseReferenceType` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseRvalueMemberType

public void traverseRvalueMemberType(Java.RvalueMemberType rmt) throws EX

Specified by:
  `traverseRvalueMemberType` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseSimpleType

public void traverseSimpleType(Java.SimpleType st) throws EX

Specified by:
  `traverseSimpleType` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseAlternateConstructorInvocation

public void traverseAlternateConstructorInvocation(Java.AlternateConstructorInvocation aci) throws EX

Specified by:
  `traverseAlternateConstructorInvocation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseSuperConstructorInvocation

public void traverseSuperConstructorInvocation(Java.SuperConstructorInvocation sci) throws EX

Specified by:
  `traverseSuperConstructorInvocation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseAmbiguousName

public void traverseAmbiguousName(Java.AmbiguousName an) throws EX

Specified by:
  `traverseAmbiguousName` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseArrayAccessExpression

public void traverseArrayAccessExpression(Java.ArrayAccessExpression aae) throws EX

Specified by:
  `traverseArrayAccessExpression` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseFieldAccess

public void traverseFieldAccess(Java.FieldAccess fa) throws EX

Specified by:
  `traverseFieldAccess` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseFieldAccessExpression

public void traverseFieldAccessExpression(Java.FieldAccessExpression fae) throws EX

Specified by:
  `traverseFieldAccessExpression` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseSuperclassFieldAccessExpression

public void traverseSuperclassFieldAccessExpression(Java.SuperclassFieldAccessExpression scfae) throws EX

Specified by:
  `traverseSuperclassFieldAccessExpression` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseLocalVariableAccess

public void traverseLocalVariableAccess(Java.LocalVariableAccess lva) throws EX

Specified by:
  `traverseLocalVariableAccess` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseParenthesizedExpression

public void traverseParenthesizedExpression(Java.ParenthesizedExpression pe) throws EX

Specified by:
  `traverseParenthesizedExpression` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseElementValueArrayInitializer

public void traverseElementValueArrayInitializer(Java.ElementValueArrayInitializer evai) throws EX

Specified by:
  `traverseElementValueArrayInitializer` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseElementValue

public void traverseElementValue(Java.ElementValue ev) throws EX

Specified by:
  `traverseElementValue` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`
See Also:
  - `AbstractTraverser`

### traverseSingleElementAnnotation

public void traverseSingleElementAnnotation(Java.SingleElementAnnotation sea) throws EX

Specified by:
  `traverseSingleElementAnnotation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseAnnotation

public void traverseAnnotation(Java.Annotation a) throws EX

Specified by:
  `traverseAnnotation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`
See Also:
  - `AbstractTraverser`

### traverseNormalAnnotation

public void traverseNormalAnnotation(Java.NormalAnnotation na) throws EX

Specified by:
  `traverseNormalAnnotation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseMarkerAnnotation

public void traverseMarkerAnnotation(Java.MarkerAnnotation ma) throws EX

Specified by:
  `traverseMarkerAnnotation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseClassDeclaration

public void traverseClassDeclaration(Java.AbstractClassDeclaration cd) throws EX

Specified by:
  `traverseClassDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseAbstractTypeDeclaration

public void traverseAbstractTypeDeclaration(Java.AbstractTypeDeclaration atd) throws EX

Specified by:
  `traverseAbstractTypeDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseNamedClassDeclaration

public void traverseNamedClassDeclaration(Java.NamedClassDeclaration ncd) throws EX

Specified by:
  `traverseNamedClassDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseInterfaceDeclaration

public void traverseInterfaceDeclaration(Java.InterfaceDeclaration id) throws EX

Specified by:
  `traverseInterfaceDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseFunctionDeclarator

public void traverseFunctionDeclarator(Java.FunctionDeclarator fd) throws EX

Specified by:
  `traverseFunctionDeclarator` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseFormalParameters

public void traverseFormalParameters(Java.FunctionDeclarator.FormalParameters formalParameters) throws EX

Specified by:
  `traverseFormalParameters` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseFormalParameter

public void traverseFormalParameter(Java.FunctionDeclarator.FormalParameter formalParameter) throws EX

Specified by:
  `traverseFormalParameter` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseAbstractTypeBodyDeclaration

public void traverseAbstractTypeBodyDeclaration(Java.AbstractTypeBodyDeclaration atbd) throws EX

Specified by:
  `traverseAbstractTypeBodyDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseStatement

public void traverseStatement(Java.Statement s) throws EX

Specified by:
  `traverseStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseBreakableStatement

public void traverseBreakableStatement(Java.BreakableStatement bs) throws EX

Specified by:
  `traverseBreakableStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseContinuableStatement

public void traverseContinuableStatement(Java.ContinuableStatement cs) throws EX

Specified by:
  `traverseContinuableStatement` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseRvalue

public void traverseRvalue(Java.Rvalue rv) throws EX

Specified by:
  `traverseRvalue` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseBooleanRvalue

public void traverseBooleanRvalue(Java.BooleanRvalue brv) throws EX

Specified by:
  `traverseBooleanRvalue` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseInvocation

public void traverseInvocation(Java.Invocation i) throws EX

Specified by:
  `traverseInvocation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseConstructorInvocation

public void traverseConstructorInvocation(Java.ConstructorInvocation ci) throws EX

Specified by:
  `traverseConstructorInvocation` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseEnumConstant

public void traverseEnumConstant(Java.EnumConstant ec) throws EX

Specified by:
  `traverseEnumConstant` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traversePackageMemberEnumDeclaration

public void traversePackageMemberEnumDeclaration(Java.PackageMemberEnumDeclaration pmed) throws EX

Specified by:
  `traversePackageMemberEnumDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseMemberEnumDeclaration

public void traverseMemberEnumDeclaration(Java.MemberEnumDeclaration med) throws EX

Specified by:
  `traverseMemberEnumDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traversePackageMemberAnnotationTypeDeclaration

public void traversePackageMemberAnnotationTypeDeclaration(Java.PackageMemberAnnotationTypeDeclaration pmatd) throws EX

Specified by:
  `traversePackageMemberAnnotationTypeDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseMemberAnnotationTypeDeclaration

public void traverseMemberAnnotationTypeDeclaration(Java.MemberAnnotationTypeDeclaration matd) throws EX

Specified by:
  `traverseMemberAnnotationTypeDeclaration` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseLvalue

public void traverseLvalue(Java.Lvalue lv) throws EX

Specified by:
  `traverseLvalue` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseType

public void traverseType(Java.Type t) throws EX

Specified by:
  `traverseType` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseAtom

public void traverseAtom(Java.Atom a) throws EX

Specified by:
  `traverseAtom` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseLocated

public void traverseLocated(Java.Located l) throws EX

Specified by:
  `traverseLocated` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseLocalVariableDeclaratorResource

public void traverseLocalVariableDeclaratorResource(Java.TryStatement.LocalVariableDeclaratorResource lvdr) throws EX

Specified by:
  `traverseLocalVariableDeclaratorResource` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`

### traverseVariableAccessResource

public void traverseVariableAccessResource(Java.TryStatement.VariableAccessResource var) throws EX

Specified by:
  `traverseVariableAccessResource` in interface `Traverser<EX extends Throwable>`
Throws:
  `EX`