// Generated from java-escape by ANTLR 4.11.1
package main.expressions;
import main.parsers.XGrammarBaseVisitor;
import main.parsers.XGrammarParser;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

/**

 */
@SuppressWarnings("CheckReturnValue")
public class RewriteBuilder extends XGrammarBaseVisitor<JoinContainer> {


    //TODO: Change back to private after debugging
    public JoinContainer joinObj;

    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitProg(XGrammarParser.ProgContext ctx) {
        joinObj = new JoinContainer("$tuple");
        visit(ctx.xq(0));
        return joinObj;
    }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitAp_Slash(XGrammarParser.Ap_SlashContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitAp_Dslash(XGrammarParser.Ap_DslashContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_DSlash(XGrammarParser.Rp_DSlashContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_Wild(XGrammarParser.Rp_WildContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_Per(XGrammarParser.Rp_PerContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_Filter(XGrammarParser.Rp_FilterContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_Concat(XGrammarParser.Rp_ConcatContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_Tag(XGrammarParser.Rp_TagContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_Text(XGrammarParser.Rp_TextContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_Dper(XGrammarParser.Rp_DperContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_Slash(XGrammarParser.Rp_SlashContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_Attr(XGrammarParser.Rp_AttrContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitRp_Par(XGrammarParser.Rp_ParContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitF_Par(XGrammarParser.F_ParContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitF_Not(XGrammarParser.F_NotContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitF_Or(XGrammarParser.F_OrContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitF_Const(XGrammarParser.F_ConstContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitF_And(XGrammarParser.F_AndContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitF_Rp(XGrammarParser.F_RpContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitF_Eq(XGrammarParser.F_EqContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitF_Is(XGrammarParser.F_IsContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitDoc(XGrammarParser.DocContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_Const(XGrammarParser.Xq_ConstContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXp_Par(XGrammarParser.Xp_ParContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_Dslash(XGrammarParser.Xq_DslashContext ctx) {
        if (joinObj.firstReturn){
            //System.out.println(ctx.getText());
            //locate all vars on the path -> replace any with $tuple/$a/*
            String fullPath = ctx.getText();
            String[] paths = fullPath.split("/");
            for (String var: paths){
                if (joinObj.varGroupIds.containsKey(var)){
                    //joinObj.tupleName + "/" + var + "/*"
                    // String toReplace = "\\" + var;
                    // System.out.println(toReplace);
                    fullPath = fullPath.replace(var, joinObj.tupleName + "/" + var.substring(1, var.length()) + "/*");
                }
            }
            JoinContainer toReturn = new JoinContainer(joinObj.tupleName);
            toReturn.nodesToReturn.add(fullPath);
            return toReturn;
        }
        return visitChildren(ctx);
    }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_Concat(XGrammarParser.Xq_ConcatContext ctx) {
        if (joinObj.firstReturn){

            JoinContainer concatPaths = new JoinContainer(joinObj.tupleName);
            JoinContainer firstPath = visit(ctx.xq(0));
            JoinContainer secondPath = visit(ctx.xq(1));

            if (firstPath != null) {
                concatPaths.nodesToReturn.addAll(firstPath.nodesToReturn);
            }
            if (secondPath != null) {
                concatPaths.nodesToReturn.addAll(secondPath.nodesToReturn);
            }

            return concatPaths;
        }
        return visitChildren(ctx);
    }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_Ap(XGrammarParser.Xq_ApContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_Slash(XGrammarParser.Xq_SlashContext ctx) {

        if (joinObj.firstReturn){
            //System.out.println(ctx.getText());
            //locate all vars on the path -> replace any with $tuple/$a/*
            String fullPath = ctx.getText();
            String[] paths = fullPath.split("/");
            for (String var: paths){
                if (joinObj.varGroupIds.containsKey(var)){
                    //joinObj.tupleName + "/" + var + "/*"
                    // String toReplace = "\\" + var;
                    // System.out.println(toReplace);
                    fullPath = fullPath.replace(var, joinObj.tupleName + "/" + var.substring(1, var.length()) + "/*");
                }
            }
            JoinContainer toReturn = new JoinContainer(joinObj.tupleName);
            toReturn.nodesToReturn.add(fullPath);
            return toReturn;
        }
        return visitChildren(ctx);
    }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_Var(XGrammarParser.Xq_VarContext ctx) {
       if (joinObj.firstReturn) {
           String varName = ctx.VAR().getText();
           StringBuilder newReturn = new StringBuilder();
           newReturn.append(joinObj.tupleName + "/" + varName.substring(1, varName.length()) + "/*");
           JoinContainer nodesToReturnOnly = new JoinContainer(joinObj.tupleName); //empty container holding only the nodeToReturn
           nodesToReturnOnly.nodesToReturn.add(newReturn.toString());
           return nodesToReturnOnly;
       }
        return visitChildren(ctx);
    }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_FLWR(XGrammarParser.Xq_FLWRContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_Join(XGrammarParser.Xq_JoinContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_Tag(XGrammarParser.Xq_TagContext ctx) {
        if (joinObj.firstReturn){
            JoinContainer paths = visit(ctx.xq());

            JoinContainer newReturn = new JoinContainer(joinObj.tupleName);

            StringBuilder newPath = new StringBuilder();
            newPath.append("<" + ctx.TAGNAME(0) + ">{");

            if (paths != null) {
                for (int i = 0; i < paths.nodesToReturn.size(); i++) {
                    newPath.append(paths.nodesToReturn.get(i));
                    if (i != paths.nodesToReturn.size() - 1) {
                        newPath.append(", ");
                    }
                }
            }
            newPath.append("}</" + ctx.TAGNAME(1) + ">");
            newReturn.nodesToReturn.add(newPath.toString());
            return newReturn;
        }

        return visitChildren(ctx);
    }


    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_Tag2(XGrammarParser.Xq_Tag2Context ctx) {
        if (joinObj.firstReturn){
            JoinContainer paths = visit(ctx.xq());

            JoinContainer newReturn = new JoinContainer(joinObj.tupleName);

            StringBuilder newPath = new StringBuilder();
            newPath.append("<" + ctx.TAGNAME(0) + ">");

            if (paths != null) {
                for (int i = 0; i < paths.nodesToReturn.size(); i++) {
                    newPath.append(paths.nodesToReturn.get(i));
                    if (i != paths.nodesToReturn.size() - 1) {
                        newPath.append(", ");
                    }
                }
            }
            newPath.append("</" + ctx.TAGNAME(1) + ">");
            newReturn.nodesToReturn.add(newPath.toString());
            return newReturn;
        }

        return visitChildren(ctx);
    }



    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXq_Let(XGrammarParser.Xq_LetContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitForClause(XGrammarParser.ForClauseContext ctx) {

        int numVars = ctx.VAR().size(); //number iterator variables
        for (int i = 0; i < numVars; i++){ //to check each path

            //check if any vars in the in xq() is already in the varGroupIds map (they should all be in the same group)
                //if it is then add this new variable to that group id
                //if it isn't then create a new grouping

            String xqString = ctx.xq(i).getText();
            String[] splitXQ = xqString.split("/"); //  "//" will also be ignored
            Integer grouping = -1;

            for (String token: splitXQ){
                if (joinObj.varGroupIds.containsKey(token)){ //found a grouping with the varId
                    grouping = joinObj.varGroupIds.get(token);
                    break;
                }
            }
            StringBuilder str = new StringBuilder();
            str.append(ctx.VAR(i).getText() + " in " + ctx.xq(i).getText());
            if (grouping > -1){ //if any var exists in the i(th) xq absolute/relative path that already exist from before, add to respective grouping
                joinObj.varGroupIds.put(ctx.VAR(i).getText(), grouping);
                ArrayList<String> aList = joinObj.varForGroupings.get(grouping);
                aList.add(str.toString());
                joinObj.varForGroupings.put(grouping, aList);

                aList = joinObj.varVarGroupings.get(grouping);
                aList.add(ctx.VAR(i).getText());
                joinObj.varVarGroupings.put(grouping, aList);
            } else{ //none of the xq vars exist in the map already
                joinObj.lastGroupId++;
                joinObj.varGroupIds.put(ctx.VAR(i).getText(), joinObj.lastGroupId); //groupIds start from 0
                joinObj.varForGroupings.put(joinObj.lastGroupId, new ArrayList<>(Arrays.asList(str.toString())));
                joinObj.varVarGroupings.put(joinObj.lastGroupId, new ArrayList<>(Arrays.asList(ctx.VAR(i).getText())));
            }
        }
        return joinObj;
    }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitLetClause(XGrammarParser.LetClauseContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */

    //here
    @Override public JoinContainer visitWhereClause(XGrammarParser.WhereClauseContext ctx) {

        visit(ctx.cond()); //goes through all eq conditions
        return joinObj;
    }




    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitReturnClause(XGrammarParser.ReturnClauseContext ctx) {



        if ((ctx.xq().getChild(1) != null) && (ctx.getChild(8) != null) && ((ctx.xq().getChild(1).getText().equals(ctx.xq().getChild(8).getText())) == false)) {
            System.err.println("Opening tag text != closing tag text");
        }
        if ((ctx.xq().getChild(1) != null)) {
            joinObj.finalTagName = ctx.xq().getChild(1).getText(); //get the tagname
        }

        //collect a list of all nodes (concatenated) : either a VAR, new newly constructed node, a path, or a concatenation
        //rules: ctx.VAR(), ctx.Concat(), ctx.xq_tag(), ctx.x_slash(), ctx.xq_d_slash()
        joinObj.firstReturn = true;
        JoinContainer returnPaths = visit(ctx.xq());
        joinObj.firstReturn = false;
        joinObj.nodesToReturn.addAll(returnPaths.nodesToReturn);
        return joinObj;
    }
//    /**
//     * {@inheritDoc}
//     *
//     * <p>The default implementation returns the result of calling
//     * {@link #visitChildren} on {@code ctx}.</p>
//     */
//    @Override public JoinContainer visitReturnClauseJoin(XGrammarParser.ReturnClauseJoinContext ctx) { return visitChildren(ctx); }
//    /**
//     * {@inheritDoc}
//     *
//     * <p>The default implementation returns the result of calling
//     * {@link #visitChildren} on {@code ctx}.</p>
//     */
//    @Override public JoinContainer visitCondClauseJoin(XGrammarParser.CondClauseJoinContext ctx) { return visitChildren(ctx); }


    @Override
    public JoinContainer visitJoin_concat(XGrammarParser.Join_concatContext ctx) {
        return visitChildren(ctx);
    }

    @Override
    public JoinContainer visitJoin_tag_no_constr(XGrammarParser.Join_tag_no_constrContext ctx) {
        return visitChildren(ctx);
    }

    @Override
    public JoinContainer visitJoin_tag_constr(XGrammarParser.Join_tag_constrContext ctx) {
        return visitChildren(ctx);
    }

    @Override
    public JoinContainer visitJoin_ap(XGrammarParser.Join_apContext ctx) {
        return visitChildren(ctx);
    }

    @Override
    public JoinContainer visitJoin_return(XGrammarParser.Join_returnContext ctx) {
        return visitChildren(ctx);
    }

    @Override
    public JoinContainer visitJoin_cond_var_eq(XGrammarParser.Join_cond_var_eqContext ctx) {
        return visitChildren(ctx);
    }

    @Override
    public JoinContainer visitJoin_cond_var_const_eq(XGrammarParser.Join_cond_var_const_eqContext ctx) {
        return visitChildren(ctx);
    }

    @Override
    public JoinContainer visitJoin_cond_const_eq(XGrammarParser.Join_cond_const_eqContext ctx) {
        return visitChildren(ctx);
    }

    @Override
    public JoinContainer visitJoin_cond_and(XGrammarParser.Join_cond_andContext ctx) {
        return visitChildren(ctx);
    }

    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitAttrList(XGrammarParser.AttrListContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitXqJoin(XGrammarParser.XqJoinContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitJoin(XGrammarParser.JoinContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitCond_And(XGrammarParser.Cond_AndContext ctx) {
        visit(ctx.cond(0));
        visit(ctx.cond(1));
        return joinObj;
    }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitCond_Eq(XGrammarParser.Cond_EqContext ctx) {
        String var1 = ctx.xq(0).getText();
        String var2 = ctx.xq(1).getText();
        Integer groupingId1 = -1;
        Integer groupingId2 = -2;

        if (joinObj.varGroupIds.containsKey(var1)){ //maps variables to group id
            groupingId1 = joinObj.varGroupIds.get(var1);
        }
        if (joinObj.varGroupIds.containsKey(var2)){
            groupingId2 = joinObj.varGroupIds.get(var2);
        }

        String condText = var1 + " eq " + var2;

        //String condText = ctx.getText(); //full eq condition (as a string)
        //double
        if (groupingId1 >=0 && groupingId2 >=0 && groupingId1 != groupingId2){
            ArrayList<Integer> key = new ArrayList<>(Arrays.asList(groupingId1, groupingId2));
            Collections.sort(key);
            if (joinObj.doubleVarConditions.containsKey(key)){
                ArrayList<String> toAdd = joinObj.doubleVarConditions.get(key);
                toAdd.add(condText);
                joinObj.doubleVarConditions.put(key, toAdd); //replace key val with new val

                ArrayList<String> toAdd2 = joinObj.doubleVarsOnly.get(key);
                toAdd2.add(var1);
                toAdd2.add(var2);
                joinObj.doubleVarsOnly.put(key, toAdd2);
            } else{
                joinObj.doubleVarConditions.put(key, new ArrayList<>(Arrays.asList(condText))); //create a brand new val from scratch
                joinObj.doubleVarsOnly.put(key, new ArrayList<>(Arrays.asList(var1, var2)));
            }
        }
        //single condition (groupId1 is valid, or both groupId1 and Id2 are valid and equivalent)
        if ((groupingId1 >=0 && groupingId2 < 0) || (groupingId1 >=0 && groupingId2 >=0 && groupingId1 == groupingId2)){
            if (joinObj.singleConditions.containsKey(groupingId1)){
                ArrayList<String> toAdd = joinObj.singleConditions.get(groupingId1);
                toAdd.add(condText);
                joinObj.singleConditions.put(groupingId1, toAdd);
            } else{
                joinObj.singleConditions.put(groupingId1, new ArrayList<>(Arrays.asList(condText)));
            }
        }
        //single
        if (groupingId1 < 0 && groupingId2 >= 0){
            if (joinObj.singleConditions.containsKey(groupingId2)){
                ArrayList<String> toAdd = joinObj.singleConditions.get(groupingId2);
                toAdd.add(condText);
                joinObj.singleConditions.put(groupingId2, toAdd);
            } else{
                joinObj.singleConditions.put(groupingId2, new ArrayList<>(Arrays.asList(condText)));
            }
        }
        return joinObj;
    }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitCond_Is(XGrammarParser.Cond_IsContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitCond_Some(XGrammarParser.Cond_SomeContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitCond_Not(XGrammarParser.Cond_NotContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitCond_Par(XGrammarParser.Cond_ParContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitCond_Empty(XGrammarParser.Cond_EmptyContext ctx) { return visitChildren(ctx); }
    /**
     * {@inheritDoc}
     *
     * <p>The default implementation returns the result of calling
     * {@link #visitChildren} on {@code ctx}.</p>
     */
    @Override public JoinContainer visitCond_Or(XGrammarParser.Cond_OrContext ctx) { return visitChildren(ctx); }
}