Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.net.URI;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

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.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.script.Script;

import org.gvsig.tools.script.ScriptManager;

import org.gvsig.tools.util.UnmodifiableBasicList;

import org.gvsig.tools.util.UnmodifiableBasicListAdapter;

import org.json.JSONArray;

import org.json.JSONObject;

/**

 *

 * @author jjdelcerro

 */

public class DefaultExpression implements Expression {

    private String phrase = null;

    private Script userScript = null;

    private List<Script> scripts = null;

    private UnmodifiableBasicList<Script> unmodifiableScripts = null;

    private Code code = null;

    private Interpreter interpreter;

    private boolean hasNotBeenOptimized = true;

    public DefaultExpression() {

    }

    @Override

    public String getPhrase() {

        return this.phrase;

    }

    @Override

    public Script getUserScript() {

        return this.userScript;

    }

    @Override

    public UnmodifiableBasicList<Script> getScripts() {

        if (this.unmodifiableScripts == null) {

            if (this.scripts == null) {

                return null;

            }

            this.unmodifiableScripts = new UnmodifiableBasicListAdapter<>(this.scripts);

        }

        return this.unmodifiableScripts;

    }

    @Override

    public void setPhrase(String phrase) {

        this.phrase = phrase;

        this.code = null;

        this.hasNotBeenOptimized = true;

    }

    @Override

    public void setUserScript(String code, String languaje) {

        if (this.userScript == null) {

            ScriptManager scriptMananger = ToolsLocator.getScriptManager();

            this.userScript = scriptMananger.createScript("user", code, languaje);

        } else if (this.userScript.getTypeName().equalsIgnoreCase(languaje)) {

            this.userScript.setCode(code);

        } else {

            ScriptManager scriptMananger = ToolsLocator.getScriptManager();

            this.userScript = scriptMananger.createScript("user", code, languaje);

        }

    }

    @Override

    public void setUserScript(Script script) {

        this.userScript = script;

    }

    @Override

    public void setUserScript(String code) {

        this.setUserScript(code, "python");

    }

    @Override

    public void removeAllScripts() {

        this.scripts = null;

        this.unmodifiableScripts = null;

    }

    @Override

    public void addScript(Script script) {

        if (this.scripts == null) {

            this.scripts = new ArrayList<>();

        }

        this.scripts.add(script);

    }

    @Override

    public void clear() {

        this.phrase = null;

        this.userScript = null;

        this.unmodifiableScripts = null;

        this.scripts = null;

        this.code = null;

        this.interpreter = null;

        this.hasNotBeenOptimized = true;

    }

    @Override

    public Code getCode() {

        if (this.code == null) {

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

            this.code = manager.compile(this.phrase);

        }

        return code;

    }

    @Override

    public Object execute(SymbolTable symbolTable) {

        if (this.interpreter == null) {

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

            this.interpreter = manager.createInterpreter();

        }

        this.interpreter.setSymbolTable(symbolTable);

        if( this.hasNotBeenOptimized  ) {

            Optimizer optimizer = new DefaultOptimizer(symbolTable);

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

            this.hasNotBeenOptimized = false;

        }

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

        return x;

    }

    @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<URI> l = new ArrayList<>();

            for (Script script : this.scripts) {

                URI location = script.getURI();

                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").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.getURI());

            }

            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;

    }

}