Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.lang.ref.WeakReference;

import java.util.Objects;

import org.apache.commons.lang3.StringUtils;

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.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.evaluator.Evaluator;

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.json.JSONObject;

/**

 *

 * @author jjdelcerro

 */

public class DefaultExpression implements Expression, LabeledValue<Expression> {

    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;

            }

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

            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("phrase", this.phrase);

//        if (this.userScript == null) {

//            state.setNull("userScript_code");

//            state.setNull("userScript_language");

//        } else {

//            state.set("userScript_code", this.userScript.getCode());

//            state.set("userScript_language", this.userScript.getTypeName());

//        }

//        if (this.scripts != null && !this.scripts.isEmpty()) {

//            List<URL> l = new ArrayList<>();

//            for (Script script : this.scripts) {

//                URL location = script.getURL();

//                if (location != null) {

//                    l.add(location);

//                }

//            }

//            if (l.isEmpty()) {

//                state.setNull("scripts");

//            } else {

//                state.set("scripts", l);

//            }

//        } else {

//            state.setNull("scripts");

//        }

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        ScriptManager scriptManager = ToolsLocator.getScriptManager();

        this.clear();

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

//        String userScript_code = state.getString("userScript_code");

//        String userScript_language = state.getString("userScript_language");

//        if (StringUtils.isEmpty(userScript_code)) {

//            this.userScript = null;

//        } else {

//            if (StringUtils.isEmpty(userScript_language)) {

//                userScript_language = "python";

//            }

//            this.userScript = scriptManager.createScript("user", userScript_code, userScript_language);

//        }

//        Iterator scriptsLocations = state.getIterator("scripts");

//        if (scriptsLocations != null) {

//            while (scriptsLocations.hasNext()) {

//                URI location = (URI) scriptsLocations.next();

//                Script script = scriptManager.loadScript(location);

//                if (script != null) {

//                    if (this.scripts == null) {

//                        this.scripts = new ArrayList<>();

//                    }

//                    this.scripts.add(script);

//                }

//            }

//        }

    }

    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.addDynFieldString("userScript_code").setMandatory(false);

//            definition.addDynFieldString("userScript_language").setMandatory(false);

//            definition.addDynFieldList("scripts")

//                    .setClassOfItems(URL.class)

//                    .setMandatory(false);

        }

    }

    @Override

    public String toJSON() {

        JSONObject expressionJson = new JSONObject();

        expressionJson.put("phrase", this.phrase);

//        if (this.userScript != null) {

//            JSONObject userScriptJson = new JSONObject();

//            userScriptJson.put("code", this.userScript.getCode());

//            userScriptJson.put("language", this.userScript.getTypeName());

//            expressionJson.put("userScript", userScriptJson);

//        }

//

//        if (this.scripts != null && !this.scripts.isEmpty()) {

//            JSONArray scriptsJson = new JSONArray();

//            for (Script script : this.scripts) {

//                scriptsJson.put(script.getURL());

//            }

//            expressionJson.put("scripts", scriptsJson);

//        }

        return expressionJson.toString();

    }

    @Override

    public void fromJSON(String json) {

        this.clear();

        ScriptManager scriptMananger = ToolsLocator.getScriptManager();

        JSONObject expressionJson = new JSONObject(json);

        if (expressionJson.has("phrase")) {

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

        }

//        if (expressionJson.has("userScript")) {

//            String theCode = "";

//            String theLanguage = "python";

//            JSONObject userScriptJson = expressionJson.getJSONObject("userScript");

//            if (userScriptJson.has("code")) {

//                theCode = userScriptJson.getString("code");

//            }

//            if (userScriptJson.has("language")) {

//                theCode = userScriptJson.getString("language");

//            }

//            this.userScript = scriptMananger.createScript("user", theCode, theLanguage);

//        }

//        if (expressionJson.has("scripts")) {

//            this.scripts = new ArrayList<>();

//            JSONArray scriptsJson = expressionJson.getJSONArray("scripts");

//            for (Object object : scriptsJson) {

//                URI location = (URI) object;

//                Script script = scriptMananger.loadScript(location);

//                this.scripts.add(script);

//            }

//        }

    }

    @Override

    public String toString() {

        return this.toJSON();

    }

    @Override

    public Expression clone() throws CloneNotSupportedException {

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

        other.fromJSON(this.toJSON());

        return other;

    }

    @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;

    }

}