Application: gvSIG desktop

package org.gvsig.expressionevaluator;

import java.io.File;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import static org.gvsig.expressionevaluator.ExpressionEvaluatorManager.DYNAMICTEXT_ENDTAG;

import static org.gvsig.expressionevaluator.ExpressionEvaluatorManager.DYNAMICTEXT_STARTTAG;

/**

 *

 * @author jjdelcerro

 */

public class ExpressionUtils {

    public static boolean isEmpty(Expression expression) {

        return expression == null || expression.isEmpty();

    }

    public static boolean isPhraseEmpty(Expression expression) {

        return expression == null || expression.isPhraseEmpty();

    }

    public static Expression defaultIfEmpty(Expression expression, Expression defaultValue) {

        if( expression==null || expression.isEmpty() ) {

            return defaultValue;

        }

        return expression;

    }

    public static Expression defaultNullIfEmpty(Expression expression) {

        if( expression==null || expression.isEmpty() ) {

            return null;

        }

        return expression;

    }

    public static Expression defaultIfPhraseEmpty(Expression expression, Expression defaultValue) {

        if( expression==null || expression.isPhraseEmpty() ) {

            return defaultValue;

        }

        return expression;

    }

    public static Expression defaultNullIfPhraseEmpty(Expression expression) {

        if( expression==null || expression.isPhraseEmpty() ) {

            return null;

        }

        return expression;

    }

    public static Expression createExpression() {

        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();

        return expression;

    }

    public static Expression createExpression(String phrase) {

        if( StringUtils.isBlank(phrase) ) {

            return null;

        }

        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();

        expression.setPhrase(phrase);

        return expression;

    }

//    public static Expression createExpression(String phrase, String code, Script... scripts) {

//        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();

//        expression.setPhrase(phrase);

//        expression.setUserScript(code);

//        for (Script script : scripts) {

//            expression.addScript(script);

//        }

//        return expression;

//    }

//

//    public static Expression createExpression(String phrase, String code, String languaje, Script... scripts) {

//        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();

//        expression.setPhrase(phrase);

//        expression.setUserScript(code, languaje);

//        for (Script script : scripts) {

//            expression.addScript(script);

//        }

//        return expression;

//    }

    public static ExpressionBuilder createExpressionBuilder() {

        ExpressionBuilder builder = ExpressionEvaluatorLocator.getManager().createExpressionBuilder();

        return builder;

    }

    public static Code compile(String expression) {

        if( StringUtils.isBlank(expression) ) {

            return null;

        }

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Code code = manager.compile(expression);

        return code;

    }

    public static Object evaluate(String expression) {

        return evaluate(null, expression);

    }

    public static Object evaluate(SymbolTable symbolTable, String expression) {

        if( StringUtils.isBlank(expression) ) {

            return null;

        }

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Object x = manager.evaluate(symbolTable, expression);

        return x;

    }

    public static Object evaluate(SymbolTable symbolTable, Code code) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Object x = manager.evaluate(symbolTable, code);

        return x;

    }

    public static Code optimize(SymbolTable symbolTable, Code code) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        code = manager.optimize(symbolTable, code);

        return code;

    }

    public static String toString(Value value, Formatter formatter) {

        if( value == null ) {

            return null;

        }

        if( formatter==null ) {

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

            formatter = manager.getExpressionBuilderFormatter();

        }

        return value.toString(formatter);

    }

    public static String toString(Value value) {

      return toString(value, null);

    }

    public static String toString(Code code, Formatter formatter) {

        if( code == null ) {

            return null;

        }

        if( formatter==null ) {

            formatter = Code.EMPTY_FORMATTER;

        }

        return code.toString(formatter);

    }

    public static String toString(Code code) {

      return toString(code, null);

    }

    public static Expression createExpressionFromJSON(String json) {

        Expression expression = ExpressionUtils.createExpression();

        expression.fromJSON(json);

        return expression;

    }

    public static MutableSymbolTable createSymbolTable() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        MutableSymbolTable symbolTable = manager.createSymbolTable();

        return symbolTable;

    }

    public static String surroundByDynamicTextTag(String source) {

        return surroundByDynamicTextTag(source, true);

    }

    public static String surroundByDynamicTextTag(String source, boolean insert) {

        if( source==null ) {

            return null;

        }

        if( insert ) {

            return DYNAMICTEXT_STARTTAG+ "=" + source + DYNAMICTEXT_ENDTAG;

        }

        return DYNAMICTEXT_STARTTAG + source + DYNAMICTEXT_ENDTAG;

    }

    public static boolean isDynamicText(String source) {

        if( !source.contains(DYNAMICTEXT_STARTTAG) ) {

          return false;

        }

        String[] sources = StringUtils.substringsBetween(source, DYNAMICTEXT_STARTTAG, DYNAMICTEXT_ENDTAG);

        if( ArrayUtils.isEmpty(sources) ) {

            return false;

        }

        return true;

    }

    public static String evaluateDynamicText(String source) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        return manager.evaluateDynamicText(source);

    }

    public static String evaluateDynamicText(SymbolTable symbolTable, String source) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        return manager.evaluateDynamicText(symbolTable, source);

    }

    public static File evaluateFilename(File source) {

        return evaluateFilename(null, source);

    }

    public static boolean isDynamicFilename(File source) {

        if( source == null ) {

            return false;

        }

        return isDynamicText(source.getPath());

    }

    public static File createDynamicFile(Value builder) {

        File f = new File(surroundByDynamicTextTag(builder.toString()));

        return f;

    }

    public static File createDynamicFile(String expression) {

        File f = new File(surroundByDynamicTextTag(expression));

        return f;

    }

    @SuppressWarnings("StringEquality")

    public static File evaluateFilename(SymbolTable symbolTable, File source) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        String src =  source.getPath();

        String r = manager.evaluateDynamicText(symbolTable, src);

        if( r == src ) { // !!! I compare that it is the same pointer, it is what I want.

            return source;

        }

        File f = new File(r);

        return f;

    }

    public static int parseInt(String s) throws NumberFormatException {

        if( StringUtils.isBlank(s) ) {

            throw new NumberFormatException("Can't get integer from a blank string.");

        }

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        SymbolTable symbolTable = null; //manager.getInmutableSymbolTable();

        Object x;

        try {

            x = manager.evaluate(symbolTable, s);

            if( x instanceof Number ) {

                return ((Number) x).intValue();

            }

        } catch(Exception ex) {

            NumberFormatException ex1 = new NumberFormatException("Can't get integer from '"+s+"'.");

            ex1.initCause(ex);

            throw ex;

        }

        if( x == null ) {

            throw new NumberFormatException("Can't get integer from '"+s+"' value is null.");

        }

        throw new NumberFormatException("Can't get integer from '"+s+"' value is a "+x.getClass().getSimpleName()+".");

    }

    public static long parseLong(String s) throws NumberFormatException {

        if( StringUtils.isBlank(s) ) {

            throw new NumberFormatException("Can't get long from a blank string.");

        }

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        SymbolTable symbolTable = null; //manager.getInmutableSymbolTable();

        Object x;

        try {

            x = manager.evaluate(symbolTable, s);

            if( x instanceof Number ) {

                return ((Number) x).longValue();

            }

        } catch(Exception ex) {

            NumberFormatException ex1 = new NumberFormatException("Can't get long from '"+s+"'.");

            ex1.initCause(ex);

            throw ex;

        }

        if( x == null ) {

            throw new NumberFormatException("Can't get long from '"+s+"' value is null.");

        }

        throw new NumberFormatException("Can't get long from '"+s+"' value is a "+x.getClass().getSimpleName()+".");

    }

    public static double parseDouble(String s) throws NumberFormatException {

        if( StringUtils.isBlank(s) ) {

            throw new NumberFormatException("Can't get double from a blank string.");

        }

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        SymbolTable symbolTable = null; //manager.getInmutableSymbolTable();

        Object x;

        try {

            x = manager.evaluate(symbolTable, s);

            if( x instanceof Number ) {

                return ((Number) x).doubleValue();

            }

        } catch(Exception ex) {

            NumberFormatException ex1 = new NumberFormatException("Can't get double from '"+s+"'.");

            ex1.initCause(ex);

            throw ex;

        }

        if( x == null ) {

            throw new NumberFormatException("Can't get double from '"+s+"' value is null.");

        }

        throw new NumberFormatException("Can't get double from '"+s+"' value is a "+x.getClass().getSimpleName()+".");

    }

    public static Compiler createCompiler() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Compiler compiler = manager.createCompiler();

        return compiler;

    }

    public static Interpreter createInterpreter() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Interpreter interpreter = manager.createInterpreter();

        return interpreter;

    }

    public static Optimizer createOptimizer() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Optimizer optimizer = manager.createOptimizer();

        return optimizer;

    }

    public static String repr(Object value) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        ReprMethod method = manager.getReprMethod(value);

        return method.repr(value);

    }

    public static CodeBuilder createCodeBuilder() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        return manager.createCodeBuilder();

    }

}