EjbqlAbstractVisitor.java

package org.objectweb.jonas_ejb.lib;

import org.objectweb.jonas_ejb.deployment.ejbql.ASTAbstractSchemaName;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTAggregateSelectExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTArithmeticExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTArithmeticFactor;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTArithmeticLiteral;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTArithmeticTerm;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTBetweenExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTBooleanExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTBooleanLiteral;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTCmpPathExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTCollectionMemberDeclaration;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTCollectionMemberExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTCollectionValuedPathExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTComparisonExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTConditionalExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTConditionalFactor;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTConditionalTerm;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTDatetimeExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTEJBQL;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTEmptyCollectionComparisonExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTEntityBeanExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTFloatingPointLiteral;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTFromClause;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTFunctionsReturningNumerics;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTFunctionsReturningStrings;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTIdentificationVariable;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTIdentifier;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTInExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTInputParameter;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTIntegerLiteral;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTLikeExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTLimitClause;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTLimitExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTLiteral;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTNullComparisonExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTOrderByClause;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTOrderByItem;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTPath;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTRangeVariableDeclaration;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTSelectClause;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTSelectExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTSingleValuedCmrPathExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTSingleValuedPathExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTStringExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTStringLiteral;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTWhereClause;
import org.objectweb.jonas_ejb.deployment.ejbql.EJBQLVisitor;
import org.objectweb.jonas_ejb.deployment.ejbql.SimpleNode;
import org.objectweb.medor.query.api.QueryTree;
import org.objectweb.medor.query.jorm.lib.NavigatorNodeFactory;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Stack;
import java.util.StringTokenizer;

public class EjbqlAbstractVisitor implements EJBQLVisitor {

    protected class IdValue {
        private ArrayList paths = null;

        private String[] name = null;

        private QueryTree qt = null;

        public IdValue(String pathName) {
            this();
            name = splitPath(pathName);
        }

        public IdValue() {
            paths = new ArrayList();
        }

        public String [] getName() {
            return name;
        }

        public void setName(String [] name) {
            this.name = name;
        }

        public void addPath(String path) {
            if (!paths.contains(path)) {
                paths.add(path);
            }
        }

        public String[] getSplitedPath(int idx) {
            return splitPath((String) paths.get(idx));
        }

        public String getMergedPath(int idx) {
            return (String) paths.get(idx);
        }

        public int getDeclaredPathLength() {
            return paths.size();
        }

        public QueryTree getQueryTree() {
            return qt;
        }

        public void setQueryTree(QueryTree qt) {
            this.qt = qt;
        }

        public String toString() {
            StringBuffer sb = new StringBuffer();
            sb = sb.append("(paths=[");
            Iterator ip = paths.iterator();
            while (ip.hasNext()) {
                sb = sb.append((String) ip.next() + ",");
            }
            if (name == null) {
                sb = sb.append("],name=null");
            } else {
                sb = sb.append("],name=");
                for (int i = 0; i < name.length; i++) {
                    sb = sb.append(name[i] + ".");
                }
            }
            if (qt == null) {
                sb = sb.append(",qt=null)");
            } else {
                sb = sb.append(",qt!=null)");
            }
            return sb.toString();
        }
    }

    protected class VisitorException extends RuntimeException {

        Exception nestedException;

        VisitorException(Exception nestedException) {
            this.nestedException = nestedException;
        }

        Exception getNestedException() {
            return nestedException;
        }
    }

    protected String[] splitPath(String path) {
        StringTokenizer st = new StringTokenizer(path, ".");
        String[] ret = new String[st.countTokens()];
        for (int i = 0; i < ret.length; i++) {
            ret[i] = st.nextToken();
        }
        return ret;
    }

    protected String mergePath(String[] path, int begin, int length) {
        if (length == 0) {
            return "";
        }
        StringBuffer ret = new StringBuffer();
        for (int i = begin; i < (begin + length); i++) {
            ret.append(path[i]);
            ret.append('.');
        }
        ret.deleteCharAt(ret.length() - 1);
        return ret.toString();
    }

    protected String mergePath(String[] path) {
        return (mergePath(path, 0, path.length));
    }

    protected boolean endsWith(String[] path, String suffix) {
        return (suffix.equals(path[path.length - 1]));
    }

    protected String[] basePath(String[] path) {
        String[] base = new String[path.length - 1];
        for (int i = 0; i < path.length - 1; i++) {
            base[i] = new String(path[i]);
        }
        return base;
    }

    public Object visit(SimpleNode node) throws Exception {
        try {
            return visit((SimpleNode) node, new Stack());
        } catch (VisitorException e) {
            throw e.getNestedException();
        }
    }

    public Object visit(SimpleNode node, Object data) {
        return node.childrenAccept(this, data);
    }

    public Object visit(ASTEJBQL node, Object data) {
        return null;
    }

    public Object visit(ASTFromClause node, Object data) {
        return null;
    }

    public Object visit(ASTCollectionMemberDeclaration node, Object data) {
        return null;
    }

    public Object visit(ASTRangeVariableDeclaration node, Object data) {
        return null;
    }

    public Object visit(ASTSingleValuedPathExpression node, Object data) {
        return null;
    }

    public Object visit(ASTCmpPathExpression node, Object data) {
        return null;
    }

    public Object visit(ASTSingleValuedCmrPathExpression node, Object data) {
        return null;
    }

    public Object visit(ASTCollectionValuedPathExpression node, Object data) {
        return null;
    }

    public Object visit(ASTSelectClause node, Object data) {
        return null;
    }

    public Object visit(ASTSelectExpression node, Object data) {
        return null;
    }

    public Object visit(ASTAggregateSelectExpression node, Object data) {
        return null;
    }

    public Object visit(ASTOrderByClause node, Object data) {
        return null;
    }

    public Object visit(ASTOrderByItem node, Object data) {
        return null;
    }

    public Object visit(ASTLimitClause node, Object data) {
        return null;
    }

    public Object visit(ASTLimitExpression node, Object data) {
        return null;
    }

    public Object visit(ASTWhereClause node, Object data) {
        return null;
    }

    public Object visit(ASTConditionalExpression node, Object data) {
        return null;
    }

    public Object visit(ASTConditionalTerm node, Object data) {
        return null;
    }

    public Object visit(ASTConditionalFactor node, Object data) {
        return null;
    }

    public Object visit(ASTBetweenExpression node, Object data) {
        return null;
    }

    public Object visit(ASTInExpression node, Object data) {
        return null;
    }

    public Object visit(ASTLikeExpression node, Object data) {
        return null;
    }

    public Object visit(ASTNullComparisonExpression node, Object data) {
        return null;
    }

    public Object visit(ASTEmptyCollectionComparisonExpression node, Object data) {
        return null;
    }

    public Object visit(ASTCollectionMemberExpression node, Object data) {
        return null;
    }

    public Object visit(ASTComparisonExpression node, Object data) {
        return null;
    }

    public Object visit(ASTArithmeticExpression node, Object data) {
        return null;
    }

    public Object visit(ASTIntegerLiteral node, Object data) {
        return null;
    }

    public Object visit(ASTFloatingPointLiteral node, Object data) {
        return null;
    }

    public Object visit(ASTArithmeticTerm node, Object data) {
        return null;
    }

    public Object visit(ASTArithmeticFactor node, Object data) {
        return null;
    }

    public Object visit(ASTStringExpression node, Object data) {
        return null;
    }

    public Object visit(ASTDatetimeExpression node, Object data) {
        return null;
    }

    public Object visit(ASTBooleanExpression node, Object data) {
        return null;
    }

    public Object visit(ASTEntityBeanExpression node, Object data) {
        return null;
    }

    public Object visit(ASTFunctionsReturningStrings node, Object data) {
        return null;
    }

    public Object visit(ASTFunctionsReturningNumerics node, Object data) {
        return null;
    }

    public Object visit(ASTAbstractSchemaName node, Object data) {
        return null;
    }

    public Object visit(ASTIdentificationVariable node, Object data) {
        return null;
    }

    public Object visit(ASTIdentifier node, Object data) {
        return null;
    }

    public Object visit(ASTPath node, Object data) {
        return null;
    }

    public Object visit(ASTLiteral node, Object data) {
        return null;
    }

    public Object visit(ASTStringLiteral node, Object data) {
        return null;
    }

    public Object visit(ASTArithmeticLiteral node, Object data) {
        return null;
    }

    public Object visit(ASTBooleanLiteral node, Object data) {
        return null;
    }

    public Object visit(ASTInputParameter node, Object data) {
        return null;
    }
}

---