Groovy example source code file (CompositeVisitor.java)

This example Groovy source code file (CompositeVisitor.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Groovy tags/keywords

arraylist, closing_visit, compositevisitor, compositevisitor, groovysourceast, groovysourceast, iterator, iterator, list, stack, stack, util, visitor

The Groovy CompositeVisitor.java source code

/*
 * Copyright 2003-2007 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.codehaus.groovy.antlr.treewalker;

import java.util.*;

import org.codehaus.groovy.antlr.GroovySourceAST;

/**
 * A composite of many visitors. Any call to a method from Visitor
 * will invoke each visitor in turn, and reverse the invocation
 * order on a closing visit.
 * i.e.
 * with the list of visitors = [a,b,c]
 * composite.visitDefault() would...
 * call on the opening visit - a.visitDefault() then b.visitDefault() then c.visitDefault()
 * call on the closing visit - c.visitDefault() then b.visitDefault() then a.visitDefault()
 *
 * @author <a href="mailto:groovy@ross-rayner.com">Jeremy Rayner
 * @version $Revision: 20590 $
 */

public class CompositeVisitor implements Visitor{
    final List visitors;
    final List backToFrontVisitors;
    private final Stack stack;

    /**
     * A composite of the supplied list of antlr AST visitors.
     * @param visitors a List of implementations of the Visitor interface
     */
    public CompositeVisitor(List visitors) {
        this.visitors = visitors;
        this.stack = new Stack();
        backToFrontVisitors = new ArrayList();
        backToFrontVisitors.addAll(visitors);
        Collections.reverse(backToFrontVisitors);
    }

    private Iterator itr(int visit) {
        Iterator itr=visitors.iterator();
        if (visit == CLOSING_VISIT) {
            itr = backToFrontVisitors.iterator();
        }
        return itr;
    }

    public void setUp() {
        Iterator itr = visitors.iterator();
        while (itr.hasNext()) {((Visitor)itr.next()).setUp();}
    }

    public void visitAbstract(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitAbstract(t,visit);}
    }

    public void visitAnnotation(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotation(t,visit);}
    }

    public void visitAnnotations(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotations(t,visit);}
    }

    public void visitAnnotationArrayInit(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotationArrayInit(t,visit);}
    }

    public void visitAnnotationDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotationDef(t,visit);}
    }

    public void visitAnnotationFieldDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotationFieldDef(t,visit);}
    }

    public void visitAnnotationMemberValuePair(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitAnnotationMemberValuePair(t,visit);}
    }

    public void visitArrayDeclarator(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitArrayDeclarator(t,visit);}
    }

    public void visitAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitAssign(t,visit);}
    }

    public void visitAt(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitAt(t,visit);}
    }

    public void visitBand(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBand(t,visit);}
    }

    public void visitBandAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBandAssign(t,visit);}
    }

    public void visitBigSuffix(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBigSuffix(t,visit);}
    }

    public void visitBlock(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBlock(t,visit);}
    }

    public void visitBnot(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBnot(t,visit);}
    }

    public void visitBor(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBor(t,visit);}
    }

    public void visitBorAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBorAssign(t,visit);}
    }

    public void visitBsr(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBsr(t,visit);}
    }

    public void visitBsrAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBsrAssign(t,visit);}
    }

    public void visitBxor(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBxor(t,visit);}
    }

    public void visitBxorAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitBxorAssign(t,visit);}
    }

    public void visitCaseGroup(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitCaseGroup(t,visit);}
    }

    public void visitClassDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitClassDef(t,visit);}
    }

    public void visitClosedBlock(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitClosedBlock(t,visit);}
    }

    public void visitClosureList(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitClosureList(t,visit);}
    }

    public void visitClosureOp(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitClosureOp(t,visit);}
    }

    public void visitColon(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitColon(t,visit);}
    }

    public void visitComma(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitComma(t,visit);}
    }

    public void visitCompareTo(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitCompareTo(t,visit);}
    }

    public void visitCtorCall(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitCtorCall(t,visit);}
    }

    public void visitCtorIdent(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitCtorIdent(t,visit);}
    }

    public void visitDec(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitDec(t,visit);}
    }

    public void visitDigit(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitDigit(t,visit);}
    }

    public void visitDiv(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitDiv(t,visit);}
    }

    public void visitDivAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitDivAssign(t,visit);}
    }

    public void visitDollar(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitDollar(t,visit);}
    }

    public void visitDot(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitDot(t,visit);}
    }

    public void visitDynamicMember(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitDynamicMember(t,visit);}
    }

    public void visitElist(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitElist(t,visit);}
    }

    public void visitEmptyStat(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitEmptyStat(t,visit);}
    }

    public void visitEnumConstantDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitEnumConstantDef(t,visit);}
    }

    public void visitEnumDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitEnumDef(t,visit);}
    }

    public void visitEof(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitEof(t,visit);}
    }

    public void visitEqual(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitEqual(t,visit);}
    }

    public void visitEsc(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitEsc(t,visit);}
    }

    public void visitExponent(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitExponent(t,visit);}
    }

    public void visitExpr(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitExpr(t,visit);}
    }

    public void visitExtendsClause(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitExtendsClause(t,visit);}
    }

    public void visitFinal(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitFinal(t,visit);}
    }

    public void visitFloatSuffix(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitFloatSuffix(t,visit);}
    }

    public void visitForCondition(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitForCondition(t,visit);}
    }

    public void visitForEachClause(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitForEachClause(t,visit);}
    }

    public void visitForInit(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitForInit(t,visit);}
    }

    public void visitForInIterable(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitForInIterable(t,visit);}
    }

    public void visitForIterator(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitForIterator(t,visit);}
    }

    public void visitGe(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitGe(t,visit);}
    }

    public void visitGt(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitGt(t,visit);}
    }

    public void visitHexDigit(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitHexDigit(t,visit);}
    }

    public void visitIdent(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitIdent(t,visit);}
    }

    public void visitImplementsClause(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitImplementsClause(t,visit);}
    }

    public void visitImplicitParameters(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitImplicitParameters(t,visit);}
    }

    public void visitImport(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitImport(t,visit);}
    }

    public void visitInc(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitInc(t,visit);}
    }

    public void visitIndexOp(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitIndexOp(t,visit);}
    }

    public void visitInstanceInit(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitInstanceInit(t,visit);}
    }

    public void visitInterfaceDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitInterfaceDef(t,visit);}
    }

    public void visitLabeledArg(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLabeledArg(t,visit);}
    }

    public void visitLabeledStat(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLabeledStat(t,visit);}
    }

    public void visitLand(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLand(t,visit);}
    }

    public void visitLbrack(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLbrack(t,visit);}
    }

    public void visitLcurly(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLcurly(t,visit);}
    }

    public void visitLe(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLe(t,visit);}
    }

    public void visitLetter(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLetter(t,visit);}
    }

    public void visitListConstructor(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitListConstructor(t,visit);}
    }

    public void visitLiteralAs(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralAs(t,visit);}
    }

    public void visitLiteralAssert(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralAssert(t,visit);}
    }

    public void visitLiteralBoolean(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralBoolean(t,visit);}
    }

    public void visitLiteralBreak(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralBreak(t,visit);}
    }

    public void visitLiteralByte(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralByte(t,visit);}
    }

    public void visitLiteralCase(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralCase(t,visit);}
    }

    public void visitLiteralCatch(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralCatch(t,visit);}
    }

    public void visitLiteralChar(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralChar(t,visit);}
    }

    public void visitLiteralClass(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralClass(t,visit);}
    }

    public void visitLiteralContinue(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralContinue(t,visit);}
    }

    public void visitLiteralDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralDef(t,visit);}
    }

    public void visitLiteralDefault(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralDefault(t,visit);}
    }

    public void visitLiteralDouble(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralDouble(t,visit);}
    }

    public void visitLiteralElse(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralElse(t,visit);}
    }

    public void visitLiteralEnum(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralEnum(t,visit);}
    }

    public void visitLiteralExtends(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralExtends(t,visit);}
    }

    public void visitLiteralFalse(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralFalse(t,visit);}
    }

    public void visitLiteralFinally(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralFinally(t,visit);}
    }

    public void visitLiteralFloat(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralFloat(t,visit);}
    }

    public void visitLiteralFor(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralFor(t,visit);}
    }

    public void visitLiteralIf(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralIf(t,visit);}
    }

    public void visitLiteralImplements(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralImplements(t,visit);}
    }

    public void visitLiteralImport(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralImport(t,visit);}
    }

    public void visitLiteralIn(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralIn(t,visit);}
    }

    public void visitLiteralInstanceof(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralInstanceof(t,visit);}
    }

    public void visitLiteralInt(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralInt(t,visit);}
    }

    public void visitLiteralInterface(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralInterface(t,visit);}
    }

    public void visitLiteralLong(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralLong(t,visit);}
    }

    public void visitLiteralNative(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralNative(t,visit);}
    }

    public void visitLiteralNew(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralNew(t,visit);}
    }

    public void visitLiteralNull(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralNull(t,visit);}
    }

    public void visitLiteralPackage(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralPackage(t,visit);}
    }

    public void visitLiteralPrivate(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralPrivate(t,visit);}
    }

    public void visitLiteralProtected(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralProtected(t,visit);}
    }

    public void visitLiteralPublic(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralPublic(t,visit);}
    }

    public void visitLiteralReturn(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralReturn(t,visit);}
    }

    public void visitLiteralShort(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralShort(t,visit);}
    }

    public void visitLiteralStatic(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralStatic(t,visit);}
    }

    public void visitLiteralSuper(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralSuper(t,visit);}
    }

    public void visitLiteralSwitch(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralSwitch(t,visit);}
    }

    public void visitLiteralSynchronized(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralSynchronized(t,visit);}
    }

    public void visitLiteralThis(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralThis(t,visit);}
    }

    public void visitLiteralThreadsafe(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralThreadsafe(t,visit);}
    }

    public void visitLiteralThrow(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralThrow(t,visit);}
    }

    public void visitLiteralThrows(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralThrows(t,visit);}
    }

    public void visitLiteralTransient(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralTransient(t,visit);}
    }

    public void visitLiteralTrue(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralTrue(t,visit);}
    }

    public void visitLiteralTry(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralTry(t,visit);}
    }

    public void visitLiteralVoid(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralVoid(t,visit);}
    }

    public void visitLiteralVolatile(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralVolatile(t,visit);}
    }

    public void visitLiteralWhile(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLiteralWhile(t,visit);}
    }

    public void visitLnot(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLnot(t,visit);}
    }

    public void visitLor(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLor(t,visit);}
    }

    public void visitLparen(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLparen(t,visit);}
    }

    public void visitLt(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitLt(t,visit);}
    }

    public void visitMapConstructor(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitMapConstructor(t,visit);}
    }

    public void visitMemberPointer(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitMemberPointer(t,visit);}
    }

    public void visitMethodCall(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitMethodCall(t,visit);}
    }

    public void visitMethodDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitMethodDef(t,visit);}
    }

    public void visitMinus(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitMinus(t,visit);}
    }

    public void visitMinusAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitMinusAssign(t,visit);}
    }

    public void visitMlComment(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitMlComment(t,visit);}
    }

    public void visitMod(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitMod(t,visit);}
    }

    public void visitModifiers(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitModifiers(t,visit);}
    }

    public void visitModAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitModAssign(t,visit);}
    }

    public void visitNls(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitNls(t,visit);}
    }

    public void visitNotEqual(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitNotEqual(t,visit);}
    }

    public void visitNullTreeLookahead(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitNullTreeLookahead(t,visit);}
    }

    public void visitNumBigDecimal(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitNumBigDecimal(t,visit);}
    }

    public void visitNumBigInt(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitNumBigInt(t,visit);}
    }

    public void visitNumDouble(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitNumDouble(t,visit);}
    }

    public void visitNumFloat(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitNumFloat(t,visit);}
    }

    public void visitNumInt(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitNumInt(t,visit);}
    }

    public void visitNumLong(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitNumLong(t,visit);}
    }

    public void visitObjblock(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitObjblock(t,visit);}
    }

    public void visitOneNl(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitOneNl(t,visit);}
    }

    public void visitOptionalDot(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitOptionalDot(t,visit);}
    }

    public void visitPackageDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitPackageDef(t,visit);}
    }

    public void visitParameters(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitParameters(t,visit);}
    }

    public void visitParameterDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitParameterDef(t,visit);}
    }

    public void visitPlus(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitPlus(t,visit);}
    }

    public void visitPlusAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitPlusAssign(t,visit);}
    }

    public void visitPostDec(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitPostDec(t,visit);}
    }

    public void visitPostInc(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitPostInc(t,visit);}
    }

    public void visitQuestion(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitQuestion(t,visit);}
    }

    public void visitRangeExclusive(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitRangeExclusive(t,visit);}
    }

    public void visitRangeInclusive(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitRangeInclusive(t,visit);}
    }

    public void visitRbrack(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitRbrack(t,visit);}
    }

    public void visitRcurly(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitRcurly(t,visit);}
    }

    public void visitRegexpCtorEnd(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitRegexpCtorEnd(t,visit);}
    }

    public void visitRegexpLiteral(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitRegexpLiteral(t,visit);}
    }

    public void visitRegexpSymbol(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitRegexpSymbol(t,visit);}
    }

    public void visitRegexFind(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitRegexFind(t,visit);}
    }

    public void visitRegexMatch(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitRegexMatch(t,visit);}
    }

    public void visitRparen(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitRparen(t,visit);}
    }

    public void visitSelectSlot(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSelectSlot(t,visit);}
    }

    public void visitSemi(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSemi(t,visit);}
    }

    public void visitShComment(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitShComment(t,visit);}
    }

    public void visitSl(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSl(t,visit);}
    }

    public void visitSlist(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSlist(t,visit);}
    }

    public void visitSlAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSlAssign(t,visit);}
    }

    public void visitSlComment(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSlComment(t,visit);}
    }

    public void visitSpreadArg(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSpreadArg(t,visit);}
    }

    public void visitSpreadDot(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSpreadDot(t,visit);}
    }

    public void visitSpreadMapArg(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSpreadMapArg(t,visit);}
    }

    public void visitSr(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSr(t,visit);}
    }

    public void visitSrAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSrAssign(t,visit);}
    }

    public void visitStar(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStar(t,visit);}
    }

    public void visitStarAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStarAssign(t,visit);}
    }

    public void visitStarStar(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStarStar(t,visit);}
    }

    public void visitStarStarAssign(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStarStarAssign(t,visit);}
    }

    public void visitStaticImport(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStaticImport(t,visit);}
    }

    public void visitStaticInit(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStaticInit(t,visit);}
    }

    public void visitStrictfp(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStrictfp(t,visit);}
    }

    public void visitStringCh(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStringCh(t,visit);}
    }

    public void visitStringConstructor(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStringConstructor(t,visit);}
    }

    public void visitStringCtorEnd(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStringCtorEnd(t,visit);}
    }

    public void visitStringCtorMiddle(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStringCtorMiddle(t,visit);}
    }

    public void visitStringCtorStart(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStringCtorStart(t,visit);}
    }

    public void visitStringLiteral(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStringLiteral(t,visit);}
    }

    public void visitStringNl(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitStringNl(t,visit);}
    }

    public void visitSuperCtorCall(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitSuperCtorCall(t,visit);}
    }

    public void visitTripleDot(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitTripleDot(t,visit);}
    }

    public void visitType(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitType(t,visit);}
    }

    public void visitTypecast(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitTypecast(t,visit);}
    }

    public void visitTypeArgument(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitTypeArgument(t,visit);}
    }

    public void visitTypeArguments(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitTypeArguments(t,visit);}
    }

    public void visitTypeLowerBounds(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitTypeLowerBounds(t,visit);}
    }

    public void visitTypeParameter(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitTypeParameter(t,visit);}
    }

    public void visitTypeParameters(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitTypeParameters(t,visit);}
    }

    public void visitTypeUpperBounds(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitTypeUpperBounds(t,visit);}
    }

    public void visitUnaryMinus(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitUnaryMinus(t,visit);}
    }

    public void visitUnaryPlus(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitUnaryPlus(t,visit);}
    }

    public void visitUnusedConst(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitUnusedConst(t,visit);}
    }

    public void visitUnusedDo(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitUnusedDo(t,visit);}
    }

    public void visitUnusedGoto(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitUnusedGoto(t,visit);}
    }

    public void visitVariableDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitVariableDef(t,visit);}
    }

    public void visitVariableParameterDef(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitVariableParameterDef(t,visit);}
    }

    public void visitVocab(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitVocab(t,visit);}
    }

    public void visitWildcardType(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitWildcardType(t,visit);}
    }

    public void visitWs(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitWs(t,visit);}
    }

    public void visitDefault(GroovySourceAST t, int visit) {
        Iterator itr = itr(visit);
        while (itr.hasNext()) {((Visitor)itr.next()).visitDefault(t,visit);}
    }

    public void tearDown() {
        Iterator itr = backToFrontVisitors.iterator();
        while (itr.hasNext()) {((Visitor)itr.next()).tearDown();}
    }

    public void push(GroovySourceAST t) {
        Iterator itr = visitors.iterator();
        while (itr.hasNext()) {((Visitor)itr.next()).push(t);}
    }
    public GroovySourceAST pop() {
        GroovySourceAST lastNodePopped = null;
        Iterator itr = backToFrontVisitors.iterator();
        while (itr.hasNext()) {lastNodePopped = (GroovySourceAST) ((Visitor)itr.next()).pop();}
        return lastNodePopped;
    }
}