Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.lang.ref.WeakReference;

import java.util.Objects;

import javax.json.JsonObject;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.builder.ToStringBuilder;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.json.Json;

import org.gvsig.json.JsonManager;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.json.SupportToJson;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.packageutils.Version;

import org.gvsig.tools.packageutils.impl.DefaultVersion;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.script.ScriptManager;

import org.gvsig.tools.util.LabeledValue;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class DefaultExpression implements Expression, LabeledValue<Expression> {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultExpression.class);

    private static final Version VERSION_2_6_0_1 = ToolsLocator.getPackageManager().createVersion("2.6.0-1");

    //?Ojo!, esto est? copiado de DataAccessGrammarFactory por cuestiones de dependencias. Si lo tocamos hay que tocarlo en los dos lados

    public static final String COMPATIBILITY_SELECT_ID = "SELECT";

    public static final String COMPATIBILITY_SELECT_OPTIONAL_SEMICOLON_AT_END = "OPTIONAL_SEMICOLON_AT_END";

    private String phrase = null;

    private Code code = null;

    private Interpreter interpreter;

    private boolean hasNotBeenOptimized = true;

    private SymbolTable mySymbolTable = null;

    private WeakReference<SymbolTable> lastSymbolTable = null;

    private boolean useBracketsForIdentifiers = false;

    protected ExpressionEvaluatorManager manager;

    public DefaultExpression() {

        this(ExpressionEvaluatorLocator.getExpressionEvaluatorManager());

    }

    public DefaultExpression(ExpressionEvaluatorManager manager) {

        this.manager = manager;

    }

    @Override

    public String getLabel() {

        return StringUtils.abbreviate(

                StringUtils.normalizeSpace(this.getPhrase()),

                35

        );

    }

    @Override

    public Expression getValue() {

        return this;

    }

    @Override

    public boolean equals(Object obj) {

        if( obj == null || !(obj instanceof Expression) ) {

            return false;

        }

        String this_s = this.toJSON();

        String other_s = ((Expression)obj).toJSON();

        return this_s.equals(other_s);

    }

    @Override

    public int hashCode() {

        String this_s = this.toJSON();

        return Objects.hashCode(this_s);

    }

    @Override

    public SymbolTable getSymbolTable() {

        if( this.mySymbolTable==null ) {

            this.mySymbolTable = ExpressionUtils.createSymbolTable();

        }

        return this.mySymbolTable;

    }

    @Override

    public String getPhrase() {

        return this.phrase;

    }

    @Override

    public boolean isPhraseEmpty() {

        return StringUtils.isBlank(this.phrase);

    }

    @Override

    public boolean isEmpty() {

        if( !StringUtils.isBlank(this.phrase) ) {

            return false;

        }

        return true;

    }

    @Override

    public Expression setPhrase(String phrase) {

        this.phrase = phrase;

        this.code = null;

        this.hasNotBeenOptimized = true;

        return this;

    }

    @Override

    public void clear() {

        this.phrase = null;

        this.code = null;

        this.interpreter = null;

        this.hasNotBeenOptimized = true;

    }

    @Override

    public Code getCode() {

        if (this.code == null) {

            Compiler compiler = this.manager.createCompiler();

            compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(

                    this.useBracketsForIdentifiers

            );

            this.code = compiler.compileExpression(this.phrase);

        }

        return code;

    }

    @Override

    public void setSQLCompatible(boolean sqlCompatible) {

        this.getInterpreter().setSQLCompatible(sqlCompatible);

    }

    @Override

    public boolean isSQLCompatible() {

        return this.getInterpreter().isSQLCompatible();

    }

    private Interpreter getInterpreter() {

        if (this.interpreter == null) {

            this.interpreter = this.manager.createInterpreter();

        }

        return this.interpreter;

    }

    @Override

    public Object execute(SymbolTable symbolTable) {

        if (this.interpreter == null) {

            this.interpreter = this.manager.createInterpreter();

        }

        boolean added = false;

        if( symbolTable!=null ) {

            added = this.getSymbolTable().addSymbolTable(symbolTable);

            if( this.lastSymbolTable==null ) {

                this.lastSymbolTable = new WeakReference<>(symbolTable);

            } else if( this.lastSymbolTable.get()!=symbolTable ) {

                this.link(this.getSymbolTable());

                this.hasNotBeenOptimized = true;

            }

        }

        try {

            this.interpreter.setSymbolTable(this.getSymbolTable());

            if( this.hasNotBeenOptimized  ) {

                try {

                    Optimizer optimizer = this.manager.createOptimizer();

                    optimizer.setSymbolTable(this.getSymbolTable());

                    this.code = optimizer.optimize(this.getCode());

                } catch(Throwable th) {

                    // Si no es capaz de optimizar la expresion no, peta y la

                    // ejecuta tal cual.

                }

                this.hasNotBeenOptimized = false;

            }

            Code code_exp = this.getCode();

            if( this.manager.hasHostExpressions(code_exp) ) {

                code_exp = this.manager.resolveHostExpressions(code_exp, interpreter);

            }

            Object x = this.interpreter.run(code_exp);

            return x;

        } finally {

            if( added ) {

                this.getSymbolTable().removeSymbolTable(symbolTable);

            }

        }

    }

    @Override

    public void link(SymbolTable symbolTable) {

        if (this.interpreter == null) {

            this.interpreter = this.manager.createInterpreter();

        }

        this.lastSymbolTable = new WeakReference<>(symbolTable);

        this.interpreter.setSymbolTable(symbolTable);

        if( this.hasNotBeenOptimized  ) {

            Optimizer optimizer = new DefaultOptimizer(this.manager, symbolTable);

            this.code = optimizer.optimize(this.getCode());

            this.hasNotBeenOptimized = false;

        }

        this.interpreter.link(this.getCode());

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("version", VERSION_2_6_0_1);

        state.set("phrase", this.phrase);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        ScriptManager scriptManager = ToolsLocator.getScriptManager();

        this.clear();

        Version version = (Version) state.get("version");

        this.phrase = state.getString("phrase");

        this.fixCompatibility(version);

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("Expression") == null) {

            DynStruct definition = manager.addDefinition(DefaultExpression.class,

                    "Expression", "Expression persistence definition", null, null);

            definition.addDynFieldString("phrase").setMandatory(false);

            definition.addDynFieldObject("version")

                    .setClassOfValue(DefaultVersion.class)

                    .setMandatory(false);

        }

    }

    @Override

    public JsonObject toJson() {

        return this.toJsonBuilder().build();

    }

    @Override

    public JsonObjectBuilder toJsonBuilder() {

        JsonObjectBuilder builder = Json.createObjectBuilder();

        builder.add_class(this);

        builder.add("phrase", this.phrase);

        builder.add("version", VERSION_2_6_0_1.toString());

        return builder;

    }

    @Override

    public void fromJson(JsonObject values) {

        this.clear();

        if( values.containsKey("phrase") ) {

            this.phrase = values.getString("phrase");

        }

        String version_s = values.getString("version", null);

        Version version = ToolsLocator.getPackageManager().createVersion(version_s);

        this.fixCompatibility(version);

    }

    @Deprecated

    @Override

    public String toJSON() {

        return toJson().toString();

    }

    @Deprecated

    @Override

    public void fromJSON(String json) {

        this.fromJson(Json.createObject(json));

    }

    @Override

    public Expression clone() throws CloneNotSupportedException {

        Expression other = (Expression) super.clone();

        other.fromJSON(this.toJSON());

        return other;

    }

    @Override

    public String toString() {

        try {

            ToStringBuilder builder = new ToStringBuilder(this);

            builder.append("phrase", this.phrase);

            return builder.toString();

        } catch (Exception e) {

            return super.toString();

        }

    }

    @Override

    public void setUseBracketsForIdentifiers(boolean useBracketsForIdentifiers) {

        this.useBracketsForIdentifiers = useBracketsForIdentifiers;

    }

    @Override

    public boolean getUseBracketsForIdentifiers() {

        return this.useBracketsForIdentifiers;

    }

    @Override

    public Evaluator toEvaluator() {

        ExpressionEvaluator evaluator = this.manager.createExpressionEvaluator(this);

        return evaluator;

    }

    public static void selfRegister() {

        Json.registerSerializer(new TheJsonSerializer());

    }

    private void fixCompatibility(Version version) {

        if (version == null || version.compareTo(VERSION_2_6_0_1) < 0) {

            try {

                if (StringUtils.isNotBlank(this.phrase)) {

                    ExpressionEvaluatorManager expressionManager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

                    org.gvsig.expressionevaluator.Compiler compiler = expressionManager.createCompiler();

                    compiler.addCompatibility(

                            COMPATIBILITY_SELECT_ID,

                            COMPATIBILITY_SELECT_OPTIONAL_SEMICOLON_AT_END

                    );

                    Code code = compiler.compileExpressionQuietly(this.phrase);

                    if (code != null) {

                        code.link();

                        this.phrase = code.toString();

                    }

                }

            } catch (Throwable t) {

                LOGGER.warn("Can't check select compatibility in select ("+this.phrase+")", t);

            }

        }

    }

    private static class TheJsonSerializer implements JsonManager.JsonSerializer {

        public TheJsonSerializer() {

        }

        @Override

        public Class getObjectClass() {

            return DefaultExpression.class;

        }

        @Override

        public Object toObject(JsonObject json) {

            DefaultExpression o = new DefaultExpression();

            o.fromJson(json);

            return o;

        }

        @Override

        public JsonObjectBuilder toJsonBuilder(Object value) {

            return ((SupportToJson)value).toJsonBuilder();

        }

    }

}