Application: gvSIG desktop

package org.gvsig.expressionevaluator.spi;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.SymbolTable;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractSymbolTable implements SymbolTable {

    private final String name;

//    public class ScriptFunction extends AbstractFunction {

//

//        public ScriptFunction(String funcName) {

//            super("Script", funcName, Range.between(1, Integer.MAX_VALUE));

//        }

//

//        @Override

//        public Object call(Interpreter interpreter, Object[] args) throws Exception {

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

//                try {

//                    return script.invokeFunction(this.name(), args);

//                } catch (NoSuchMethodException ex) {

//                    // Si la funcion no existe en el script pasamos al siguiente

//                    // script.

//                }

//            }

//            throw new NoSuchMethodException("Can't locate funcion '" + this.name() + "'.");

//        }

//

//    }

    private Map<String, Object> vars;

    protected final List<SymbolTable> symbolTables;

    protected Map<String, Function> functions;

    protected Map<String, Function> functionAlias;

//    protected List<Script> scripts;

    public AbstractSymbolTable() {

        this(null);

    }

    public AbstractSymbolTable(String name) {

        this.name = name;

        this.symbolTables = new ArrayList<>();

        this.vars = null;

        this.functions = null;

        this.functionAlias = null;

    }

    @Override

    public String getName() {

        return name;

    }

    public void addFunction(Function function) {

        if (function == null) {

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

        }

        this.getFunctions().put(function.name().toUpperCase(), function);

        List<String> aliases = function.aliases();

        if( aliases == null || aliases.isEmpty() ) {

            return;

        }

        Map<String, Function> theFunctionAlias = this.getFunctionAlias();

        for (String alias : aliases) {

            if( alias!=null ) {

                theFunctionAlias.put(alias, function);

            }

        }

    }

    public void addFunctions(Collection<Function> functions) {

        for (Function function : functions) {

            this.addFunction(function);

        }

    }

    public void removeFunction(String name) {

        if( StringUtils.isEmpty(name) ) {

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

        }

        this.functions.remove(name.toUpperCase());

    }

    @Override

    public boolean addSymbolTable(SymbolTable symbolTable) {

        if( symbolTable==null ) {

          throw new IllegalArgumentException("Invalid symbol table (null)");

        }

        if (this.symbolTables.contains(symbolTable)) {

            return false;

        }

        this.symbolTables.add(0,symbolTable);

        return true;

    }

    @Override

    public boolean containsSymbolTable(SymbolTable symbolTable) {

        return this.symbolTables.contains(symbolTable);

    }

    @Override

    public boolean removeSymbolTable(SymbolTable symbolTable) {

        boolean n = this.symbolTables.remove(symbolTable);

        return n;

    }

    protected Map<String, Object> getVars() {

        if (this.vars == null) {

            this.vars = new HashMap<>();

        }

        return this.vars;

    }

    public void setVar(String name, Object value) {

        if( StringUtils.isEmpty(name) ) {

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

        }

        this.getVars().put(name.toUpperCase(), value);

    }

    public void removeVar(String name) {

        if( StringUtils.isEmpty(name) ) {

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

        }

        this.getVars().remove(name.toUpperCase());

    }

    protected Map<String, Function> getFunctions() {

        if (this.functions == null) {

            this.functions = new HashMap<>();

        }

        return this.functions;

    }

    protected Map<String, Function> getFunctionAlias() {

        if (this.functionAlias == null) {

            this.functionAlias = new HashMap<>();

        }

        return this.functionAlias;

    }

    @Override

    public boolean exists(String name) {

        if (StringUtils.isEmpty(name)) {

            return false;

        }

        if (this.getVars().containsKey(name.toUpperCase())) {

            return true;

        }

        for (SymbolTable other : this.symbolTables) {

            if (other.exists(name)) {

                return true;

            }

        }

        return false;

    }

    @Override

    public Object value(String name) {

        if (StringUtils.isEmpty(name)) {

            return null;

        }

        name = name.toUpperCase();

        if (this.getVars().containsKey(name)) {

            return this.getVars().get(name);

        }

        for (SymbolTable other : this.symbolTables) {

            if (other.exists(name)) {

                return other.value(name);

            }

        }

        return null;

    }

    @Override

    public Function function(String name) {

        if (StringUtils.isEmpty(name)) {

            return null;

        }

        if (this.functions != null) {

            name = name.toUpperCase();

            if (this.functions.containsKey(name)) {

                return this.functions.get(name);

            }

        }

        if (this.functionAlias != null) {

            name = name.toUpperCase();

            if (this.functionAlias.containsKey(name)) {

                return this.functionAlias.get(name);

            }

        }

        for (SymbolTable other : this.symbolTables) {

            Function fn = other.function(name);

            if (fn != null) {

                return fn;

            }

        }

        return null;

    }

    @Override

    public Collection<String> variables() {

        Set<String> theVars = new HashSet<>();

        for (SymbolTable symbolTable : this.symbolTables) {

            theVars.addAll(symbolTable.variables());

        }

        theVars.addAll(this.localvariables());

        return Collections.unmodifiableCollection(theVars);

    }

    @Override

    public Collection<Function> functions() {

        Set<Function> theFunctions = new HashSet<>();

        for (SymbolTable symbolTable : this.symbolTables) {

            theFunctions.addAll(symbolTable.functions());

        }

        if (this.functions != null) {

            theFunctions.addAll(this.functions.values());

        }

        return Collections.unmodifiableCollection(theFunctions);

    }

    @Override

    public Collection<Function> localfunctions() {

        if( this.functions == null ) {

            return Collections.EMPTY_LIST;

        }

        return Collections.unmodifiableCollection(this.functions.values());

    }

    @Override

    public Collection<String> localvariables() {

        if( this.getVars().size() == 0) {

            return Collections.EMPTY_LIST;

        }

        return Collections.unmodifiableCollection(this.vars.keySet());

    }

    @Override

    public Iterator<Function> iterator() {

        return this.functions().iterator();

    }

    @Override

    public SymbolTable clone() throws CloneNotSupportedException {

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

        return other;

    }

    @Override

    public boolean isSQLCompatible(String name) {

        Function f = function(name);

        if( f!=null ) {

            return f.isSQLCompatible();

        }

        return true;

    }

}