Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.apache.commons.lang3.StringUtils;

import org.apache.http.client.utils.URIBuilder;

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

/**

 *

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

    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;

    }

    @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 Object execute(SymbolTable symbolTable) {

        if (this.code == null) {

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

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

        }

        if (this.interpreter == null) {

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

            this.interpreter = manager.createInterpreter();

        }

        this.interpreter.setSymbolTable(symbolTable);

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

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

        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 URI toURI() {

        URIBuilder builder = new URIBuilder();

        builder.setScheme("expression");

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

        if( this.userScript==null ) {

            builder.addParameter("userScriptCode", null);

            builder.addParameter("userScriptLanguage", null);

        } else {

            builder.addParameter("userScriptCode", this.userScript.getCode());

            builder.addParameter("userScriptLanguage", 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()) {

                builder.addParameter("scriptsCount", "0");

                builder.addParameter("scripts", null);

            } else {

                builder.addParameter("scriptsCount", String.valueOf(l.size()));

                int n = 1;

                for (URI uri : l) {

                    builder.addParameter("scripts"+n, uri.toString());

                }

            }

        } else {

            builder.addParameter("scriptsCount", "0");

            builder.addParameter("scripts", null);

        }

        try {

            return builder.build();

        } catch (URISyntaxException ex) {

            throw new RuntimeException("Can't serialize expression", ex);

        }

    }

}