Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.io.InputStream;

import java.io.StringWriter;

import java.net.URI;

import java.net.URL;

import org.gvsig.expressionevaluator.Grammar;

import org.gvsig.expressionevaluator.GrammarFactory;

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import java.util.Objects;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.SymbolTableFactory;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.GrammarSet;

import org.gvsig.expressionevaluator.impl.javascripting.CosaScriptEngineFactory;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.bookmarksandhistory.impl.BaseBookmarks;

import org.gvsig.tools.bookmarksandhistory.impl.BaseHistory;

import org.gvsig.tools.script.Script;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultExpressionEvaluatorManager implements ExpressionEvaluatorManager {

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

    private Double accuracy;

    private final Map<String,SymbolTableFactory>symbolTableFactories;

    private final Map<String,GrammarFactory> grammarFactories;

    private Bookmarks<Expression> bookmarks;

    private History<Expression> history;

    public DefaultExpressionEvaluatorManager() {

        this.symbolTableFactories = new HashMap<>();

        this.grammarFactories = new HashMap<>();

    }

    @Override

    public SymbolTable getSymbolTable(String name) {

        if( name == null ) {

            return null;

        }

        SymbolTableFactory factory = this.symbolTableFactories.get(name.toUpperCase());

        if( factory == null ) {

            return null;

        }

        return factory.create();

    }

    @Override

    public Collection<SymbolTableFactory> getSymbolTableFactories() {

        return this.symbolTableFactories.values();

    }

    @Override

    public final void registerSymbolTable(SymbolTableFactory factory) {

        if( factory == null ) {

            throw new IllegalArgumentException("factory can't be null");

        }

        this.symbolTableFactories.put(factory.getName().toUpperCase(),factory);

    }

    @Override

    public Object evaluate(String source) {

        DefaultInterpreter interpreter = new DefaultInterpreter();

        DefaultCompiler compiler = new DefaultCompiler();

        Code code = compiler.compileExpression(source);

        return interpreter.run(code);

    }

    @Override

    public Object evaluate(SymbolTable symbolTable, String source) {

        DefaultInterpreter interpreter = new DefaultInterpreter();

        DefaultCompiler compiler = new DefaultCompiler();

        Code code = compiler.compileExpression(source);

        interpreter.setSymbolTable(symbolTable);

        return interpreter.run(code);

    }

    @Override

    public Object evaluate(SymbolTable symbolTable, Code code) {

        DefaultInterpreter interpreter = new DefaultInterpreter();

        interpreter.setSymbolTable(symbolTable);

        return interpreter.run(code);

    }

    @Override

    public String evaluatePage(String source) {

        return evaluatePage(null, source);

    }

    @Override

    public String evaluatePage(SymbolTable symbolTable, String source) {

        String[] sources = StringUtils.substringsBetween(source, "<%", "%>");

        if( ArrayUtils.isEmpty(sources) ) {

            return source;

        }

        String[] values = new String[sources.length];

        DefaultInterpreter interpreter = new DefaultInterpreter();

        if( symbolTable!=null ) {

            interpreter.setSymbolTable(symbolTable);

        }

        StringWriter writer = new StringWriter();

        interpreter.setWriter(writer);

        DefaultCompiler compiler = new DefaultCompiler();

        for (int i = 0; i < sources.length; i++) {

            String theSource = sources[i];

            if( StringUtils.startsWith(theSource, "=") ) {

                Code code = compiler.compileExpression(theSource.substring(1));

                Object value = interpreter.run(code);

                values[i] = Objects.toString(value, "");

            } else {

                Code code = compiler.compileExpression(theSource.substring(1));

                writer.getBuffer().setLength(0);

                interpreter.run(code);

                values[i] = writer.toString();

            }

            sources[i] = "<%"+sources[i]+"%>";

        }

        String output = StringUtils.replaceEach(source, sources, values);

        return output;

    }

    @Override

    public Code compile(String source) {

        Compiler compiler = this.createCompiler();

        return compiler.compileExpression(source);

    }

    @Override

    public Code compile(LexicalAnalyzer lex, String source) {

        Compiler compiler = this.createCompiler();

        compiler.setLexicalAnalyzer(lex);

        return compiler.compileExpression(source);

    }

    @Override

    public Code optimize(SymbolTable symbolTable, Code code) {

        Optimizer optimizer = this.createOptimizer();

        return optimizer.optimize(symbolTable, code);

    }

    @Override

    public MutableSymbolTable createSymbolTable() {

        DefaultSymbolTable theSymbolTable = new DefaultSymbolTable();

        return theSymbolTable;

    }

    public void populateSymbolTable(SymbolTable aSymbolTable) {

        for (SymbolTableFactory factory : this.getSymbolTableFactories() ) {

            if( factory.isAutoload() ) {

                SymbolTable symbolTable = factory.create();

                aSymbolTable.addSymbolTable(symbolTable);

            }

        }

    }

    @Override

    public LexicalAnalyzer createLexicalAnalyzer() {

        return new SQLLexicalAnalyzer();

    }

    @Override

    public CodeBuilder createCodeBuilder() {

        return new DefaultCodeBuilder();

    }

    @Override

    public Compiler createCompiler() {

        DefaultCompiler compiler = new DefaultCompiler();

        this.populateGrammars(compiler);

        return  compiler;

    }

    @Override

    public Interpreter createInterpreter() {

        return new DefaultInterpreter();

    }

    @Override

    public Double getAccuracy() {

        return this.accuracy;

    }

    @Override

    public void setAccuracy(Double accuracy) {

        this.accuracy = accuracy;

    }

    @Override

    public Expression createExpression() {

        DefaultExpression e = new DefaultExpression();

        return e;

    }

    @Override

    public ExpressionBuilder createExpressionBuilder() {

        ExpressionBuilder x = new DefaultExpressionBuilder();

        return x;

    }

    @Override

    public Optimizer createOptimizer() {

        Optimizer x = new DefaultOptimizer();

        return x;

    }

    @Override

    public void registerGrammar(GrammarFactory factory) {

        if( factory==null ) {

            throw new IllegalArgumentException("factory can't be null");

        }

        this.grammarFactories.put(factory.getName(), factory);

    }

    @Override

    public Collection<GrammarFactory> getGrammarFactories() {

        return this.grammarFactories.values();

    }

    public void populateGrammars(Compiler compiler) {

        GrammarSet grammarSet = compiler.getGrammars();

        for (GrammarFactory factory : this.getGrammarFactories() ) {

            if( factory.isAutoload() ) {

                Grammar grammar = factory.create();

                grammarSet.add(grammar);

            }

        }

    }

    @Override

    public Grammar createGrammar(String name) {

        DefaultGrammar grammar = new DefaultGrammar(name);

        return grammar;

    }

    @Override

    public Bookmarks<Expression> getBookmarks() {

        if( this.bookmarks==null ) {

            this.bookmarks = new BaseBookmarks<Expression>();

        }

        return this.bookmarks;

    }

    @Override

    public History<Expression> getHistory() {

        if( this.history==null ) {

            this.history = new BaseHistory<Expression>(20);

        }

        return this.history;

    }

    @Override

    public Script createScript(String name, String code, String languaje) {

        SimpleScript sc = new SimpleScript(this.createInterpreter(), name, code);

        return sc;

    }

    @Override

    public Script locateScript(String name) {

        return null;

    }

    @Override

    public Script loadScript(URI location) {

        InputStream is = null;

        String code = null;

        String name = null;

        try {

            URL url = location.toURL();

            is = url.openStream();

            code = IOUtils.toString(is);

            name = FilenameUtils.getBaseName(location.getPath());

        } catch(Exception ex) {

            return null;

        } finally {

            IOUtils.closeQuietly(is);

        }

        return this.createScript(name, code, CosaScriptEngineFactory.LANGUAGE_NAME);

    }

}