Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Compiler;

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.impl.symboltable.OGCSymbolTable;

import org.gvsig.expressionevaluator.impl.symboltable.SQLSymbolTable;

import org.gvsig.expressionevaluator.impl.symboltable.UtilsSymbolTable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultExpressionEvaluatorManager implements ExpressionEvaluatorManager {

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

    private Double accuracy;

    private final Map<String,SymbolTable>symbolTables;

    private final Set<String>autoloadSymbolTables;

    public DefaultExpressionEvaluatorManager() {

        this.symbolTables = new HashMap<>();

        this.autoloadSymbolTables = new HashSet<>();

        this.registerSymbolTable(new SQLSymbolTable(), true);

        this.registerSymbolTable(new OGCSymbolTable(), true);

        this.registerSymbolTable(new UtilsSymbolTable(), true);

    }

    @Override

    public SymbolTable getSymbolTable(String name) {

        return this.symbolTables.get(name.toUpperCase());

    }

    @Override

    public Collection<SymbolTable> getSymbolTables() {

        return this.symbolTables.values();

    }

    @Override

    public final void registerSymbolTable(SymbolTable symbolTable, boolean autoload) {

        if( symbolTable instanceof MutableSymbolTable ) {

            LOGGER.warn("Registered a MutableSymbolTable '"+symbolTable.getName()+"'.");

        }

        this.symbolTables.put(symbolTable.getName().toUpperCase(),symbolTable);

        if( autoload ) {

            this.autoloadSymbolTables.add(symbolTable.getName().toUpperCase());

        }

    }

    @Override

    public boolean isAutoload(SymbolTable symbolTable) {

        return this.autoloadSymbolTables.contains(symbolTable.getName().toUpperCase());

    }

    @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 Code compile(String source) {

        DefaultCompiler compiler = new DefaultCompiler();

        return compiler.compileExpression(source);

    }

    @Override

    public Code compile(LexicalAnalyzer lex, String source) {

        DefaultCompiler compiler = new DefaultCompiler();

        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 (String name : this.autoloadSymbolTables ) {

            SymbolTable symbolTable = this.symbolTables.get(name);

            if( symbolTable!=null ) {

                aSymbolTable.addSymbolTable(symbolTable);

            }

        }

    }

    @Override

    public LexicalAnalyzer createLexicalAnalyzer() {

        return new SQLLexicalAnalyzer();

    }

    @Override

    public CodeBuilder createCodeBuilder() {

        return new DefaultCodeBuilder();

    }

    @Override

    public Compiler createCompiler() {

        return new DefaultCompiler();

    }

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

    }

}