Application: gvSIG desktop

package org.gvsig.expressionevaluator.spi;

import org.gvsig.expressionevaluator.CodeToStringConverter;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.Code.Constant;

import org.gvsig.expressionevaluator.Code.Identifier;

import org.gvsig.expressionevaluator.Code.Method;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

/**

 *

 * @author jjdelcerro

 */

public class AbstractCodeToStringConverter implements CodeToStringConverter {

    private final Code code;

    protected Set<String> supportedFunctionsNames;

    protected Map<String, String> translatedFunctionsNames;

    public AbstractCodeToStringConverter() {

        this(null);

    }

    public AbstractCodeToStringConverter(Code code) {

        this.supportedFunctionsNames = new HashSet<>();

        this.translatedFunctionsNames = new HashMap<>();

        this.code = code;

    }

    protected final void addSupportedFunction(String name) {

        this.supportedFunctionsNames.add(name.toLowerCase());

    }

    protected final void addSupportedFunction(String name, String outputName) {

        this.supportedFunctionsNames.add(name.toLowerCase());

        this.translatedFunctionsNames.put(name.toLowerCase(), outputName);

    }

    protected final boolean isFunctionSupported(String functionName) {

        functionName = functionName.toLowerCase();

        for (String name : supportedFunctionsNames) {

            if (functionName.equals(name)) {

                return true;

            }

        }

        return false;

    }

    protected final String translateFunctionName(String functionName) {

        return this.translatedFunctionsNames.getOrDefault(functionName, functionName);

    }

    @Override

    public boolean isValid() {

        if( code == null ) {

            return false;

        }

        return this.isValid(code);

    }

    @SuppressWarnings("UseSpecificCatch")

    @Override

    public boolean isValid(Code code) {

        try {

            code.accept(new Visitor() {

                @Override

                public void visit(Object o) throws VisitCanceledException, BaseException {

                    Code code = (Code) o;

                    switch (code.code()) {

                        case Code.CALLER:

                            Caller caller = (Caller) code;

                            if (!isFunctionSupported(caller.name())) {

                                throw new UnsupportedOperationException("Function '" + caller.name() + "' not supported.");

                            }

                        case Code.CONSTANT:

                        case Code.IDENTIFIER:

                            break;

                        case Code.METHOD:

                            throw new UnsupportedOperationException("Method call not supported.");

                        default:

                            throw new UnsupportedOperationException("Code type not supported.");

                    }

                }

            });

            return true;

        } catch (Exception ex) {

            return false;

        }

    }

    @Override

    public String toString() {

        if( code == null ) {

            return null;

        }

        return this.toString(code);

    }

    @Override

    public String toString(Code code) {

        switch (code.code()) {

            case Code.CONSTANT:

                return constantToString((Constant) code);

            case Code.IDENTIFIER:

                return identifierToString((Identifier) code);

            case Code.CALLER:

                return callerToString((Caller) code);

            case Code.METHOD:

                return methodToString((Method) code);

            default:

                return "";

        }

    }

    protected String callerToString(Caller code) {

        switch (code.type()) {

            case Caller.BINARY_OPERATOR:

                if (!this.isFunctionSupported(code.name())) {

                    throw new UnsupportedOperationException("Operator '" + code.name() + "' not supported.");

                }

                return binaryOperatorToString(code.name(), code.args().get(0), code.args().get(1));

            case Caller.UNARY_OPERATOR:

                if (!this.isFunctionSupported(code.name())) {

                    throw new UnsupportedOperationException("Operator '" + code.name() + "' not supported.");

                }

                return unaryOperatorToString(code.name(), code.args().get(0));

            case Caller.FUNCTION:

            default:

                if (!this.isFunctionSupported(code.name())) {

                    throw new UnsupportedOperationException("Function '" + code.name() + "' not supported.");

                }

                String fname = this.translateFunctionName(code.name());

                return functionToString(fname, code.args());

        }

    }

    protected String constantToString(Constant code) {

        return code.toString();

    }

    protected String identifierToString(Identifier code) {

        return "\"" + code.name() + "\"";

    }

    protected String methodToString(Method code) {

        throw new UnsupportedOperationException("Method call not supported (method name '" + code.name() + "').");

    }

    protected String binaryOperatorToString(String name, Code oper1, Code oper2) {

        if (oper1.code() == Code.CONSTANT || oper1.code() == Code.IDENTIFIER) {

            if (oper2.code() == Code.CONSTANT || oper2.code() == Code.IDENTIFIER) {

                return this.toString(oper1) + " " + name + " " + this.toString(oper2);

            } else {

                return this.toString(oper1) + " " + name + " (" + this.toString(oper2) + ")";

            }

        } else if (oper2.code() == Code.CONSTANT || oper2.code() == Code.IDENTIFIER) {

            return "(" + this.toString(oper1) + ") " + name + " " + this.toString(oper2);

        }

        return "(" + this.toString(oper1) + ") " + name + " (" + this.toString(oper2) + ")";

    }

    protected String unaryOperatorToString(String name, Code oper) {

        if (oper.code() == Code.CONSTANT || oper.code() == Code.IDENTIFIER) {

            return name + " " + this.toString(oper);

        }

        return name + " (" + this.toString(oper) + ")";

    }

    protected String functionToString(String functionName, Codes args) {

        StringBuilder builder = new StringBuilder();

        builder.append(functionName);

        builder.append("(");

        boolean firstArg = true;

        for (Code arg : args) {

            if (firstArg) {

                firstArg = false;

                builder.append(this.toString(arg));

            } else {

                builder.append(", ");

                builder.append(this.toString(arg));

            }

        }

        builder.append(")");

        return builder.toString();

    }

}