//
   // Generated by JTB 1.3.2
   //
   
   package com.randomnoun.common.jexl.visitor;
   import com.randomnoun.common.jexl.ast.*;
   import java.util.*;
   
   /**
   * Provides default methods which visit each node in the tree in depth-first
   * order.  Your visitors may extend this class.
   */
  public class GJDepthFirst<R,A> implements GJVisitor<R,A> {
     //
     // Auto class visitors--probably don't need to be overridden.
     //
     public R visit(NodeList n, A argu) {
        R _ret=null;
        int _count=0;
        for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
           e.nextElement().accept(this,argu);
           _count++;
        }
        return _ret;
     }
  
     public R visit(NodeListOptional n, A argu) {
        if ( n.present() ) {
           R _ret=null;
           int _count=0;
           for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
              e.nextElement().accept(this,argu);
              _count++;
           }
           return _ret;
        }
        else
           return null;
     }
  
     public R visit(NodeOptional n, A argu) {
        if ( n.present() )
           return n.node.accept(this,argu);
        else
           return null;
     }
  
     public R visit(NodeSequence n, A argu) {
        R _ret=null;
        int _count=0;
        for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
           e.nextElement().accept(this,argu);
           _count++;
        }
        return _ret;
     }
  
     public R visit(NodeToken n, A argu) { return null; }
  
     //
     // User-generated visitor methods below
     //
  
     /**
      * <PRE>
      * expression -> Expression()
      * nodeToken -> &lt;EOF&gt;
      * </PRE>
      */
     public R visit(TopLevelExpression n, A argu) {
        R _ret=null;
        n.expression.accept(this, argu);
        n.nodeToken.accept(this, argu);
        return _ret;
     }
  
     /**
      * <PRE>
      * conditionalAndExpression -> ConditionalAndExpression()
      * nodeListOptional -> ( "||" ConditionalAndExpression() )*
      * </PRE>
      */
     public R visit(Expression n, A argu) {
        R _ret=null;
        n.conditionalAndExpression.accept(this, argu);
        n.nodeListOptional.accept(this, argu);
        return _ret;
     }
  
     /**
      * <PRE>
      * equalityExpression -> EqualityExpression()
      * nodeListOptional -> ( "&&" EqualityExpression() )*
      * </PRE>
      */
     public R visit(ConditionalAndExpression n, A argu) {
        R _ret=null;
        n.equalityExpression.accept(this, argu);
        n.nodeListOptional.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * relationalExpression -> RelationalExpression()
     * nodeListOptional -> ( ( "==" | "!=" ) RelationalExpression() )*
     * </PRE>
     */
    public R visit(EqualityExpression n, A argu) {
       R _ret=null;
       n.relationalExpression.accept(this, argu);
       n.nodeListOptional.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * additiveExpression -> AdditiveExpression()
     * nodeListOptional -> ( ( "&lt;" | "&gt;" | "&lt;=" | "&gt;=" ) AdditiveExpression() )*
     * </PRE>
     */
    public R visit(RelationalExpression n, A argu) {
       R _ret=null;
       n.additiveExpression.accept(this, argu);
       n.nodeListOptional.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * multiplicativeExpression -> MultiplicativeExpression()
     * nodeListOptional -> ( ( "+" | "-" ) MultiplicativeExpression() )*
     * </PRE>
     */
    public R visit(AdditiveExpression n, A argu) {
       R _ret=null;
       n.multiplicativeExpression.accept(this, argu);
       n.nodeListOptional.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * unaryExpression -> UnaryExpression()
     * nodeListOptional -> ( ( "*" | "/" | "%" ) UnaryExpression() )*
     * </PRE>
     */
    public R visit(MultiplicativeExpression n, A argu) {
       R _ret=null;
       n.unaryExpression.accept(this, argu);
       n.nodeListOptional.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * nodeChoice -> ( "~" | "!" | "-" ) UnaryExpression()
     *       | PrimaryExpression()
     * </PRE>
     */
    public R visit(UnaryExpression n, A argu) {
       R _ret=null;
       n.nodeChoice.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * nodeChoice -> FunctionCall()
     *       | Name()
     *       | Literal()
     *       | "(" Expression() ")"
     * </PRE>
     */
    public R visit(PrimaryExpression n, A argu) {
       R _ret=null;
       n.nodeChoice.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * nodeToken -> &lt;IDENTIFIER&gt;
     * nodeListOptional -> ( "." &lt;IDENTIFIER&gt; )*
     * </PRE>
     */
    public R visit(Name n, A argu) {
       R _ret=null;
       n.nodeToken.accept(this, argu);
       n.nodeListOptional.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * nodeToken -> &lt;IDENTIFIER&gt;
     * arguments -> Arguments()
     * </PRE>
     */
    public R visit(FunctionCall n, A argu) {
       R _ret=null;
       n.nodeToken.accept(this, argu);
       n.arguments.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * nodeToken -> "("
     * nodeOptional -> [ ArgumentList() ]
     * nodeToken1 -> ")"
     * </PRE>
     */
    public R visit(Arguments n, A argu) {
       R _ret=null;
       n.nodeToken.accept(this, argu);
       n.nodeOptional.accept(this, argu);
       n.nodeToken1.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * expression -> Expression()
     * nodeListOptional -> ( "," Expression() )*
     * </PRE>
     */
    public R visit(ArgumentList n, A argu) {
       R _ret=null;
       n.expression.accept(this, argu);
       n.nodeListOptional.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * nodeChoice -> &lt;INTEGER_LITERAL&gt;
     *       | &lt;FLOATING_POINT_LITERAL&gt;
     *       | &lt;CHARACTER_LITERAL&gt;
     *       | &lt;STRING_LITERAL&gt;
     *       | BooleanLiteral()
     *       | NullLiteral()
     * </PRE>
     */
    public R visit(Literal n, A argu) {
       R _ret=null;
       n.nodeChoice.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * nodeChoice -> "true"
     *       | "false"
     * </PRE>
     */
    public R visit(BooleanLiteral n, A argu) {
       R _ret=null;
       n.nodeChoice.accept(this, argu);
       return _ret;
    }
 
    /**
     * <PRE>
     * nodeToken -> "null"
     * </PRE>
     */
    public R visit(NullLiteral n, A argu) {
       R _ret=null;
       n.nodeToken.accept(this, argu);
       return _ret;
    }
 
 }