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

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.tools.script.Script;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractSymbolTable implements SymbolTable {

    private final String name;

    private 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() + "'.");

        }

    }

    protected final List<SymbolTable> symbolTables;

    protected Map<String, Object> vars;

    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;

        this.scripts = null;

    }

    @Override

    public String getName() {

        return name;

    }

    protected 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);

            }

        }

    }

    @Override

    public void addSymbolTable(SymbolTable symbolTable) {

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

            return;

        }

        this.symbolTables.add(symbolTable);

    }

    protected Map<String, Object> getVars() {

        if (this.vars == null) {

            this.vars = new HashMap<>();

        }

        return this.vars;

    }

    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;

    }

    protected List<Script> getScripts() {

        if (this.scripts == null) {

            this.scripts = new ArrayList<>();

        }

        return this.scripts;

    }

    @Override

    public boolean exists(String name) {

        if (StringUtils.isEmpty(name)) {

            return false;

        }

        if (this.vars != null) {

            if (this.vars.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;

        }

        if (this.vars != null) {

            name = name.toUpperCase();

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

                return this.vars.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) {

                if (fn instanceof ScriptFunction) {

                    continue;

                }

                return fn;

            }

        }

        if (this.scripts == null || this.scripts.isEmpty()) {

            return null;

        }

        return new ScriptFunction(name);

    }

    @Override

    public Collection<String> variables() {

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

        for (SymbolTable symbolTable : this.symbolTables) {

            theVars.addAll(symbolTable.variables());

        }

        if (this.vars != null) {

            theVars.addAll(this.vars.keySet());

        }

        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<Script> scripts() {

        Set<Script> theScripts = new HashSet<>();

        for (SymbolTable symbolTable : this.symbolTables) {

            theScripts.addAll(symbolTable.scripts());

        }

        if (this.scripts != null) {

            theScripts.addAll(this.scripts);

        }

        return Collections.unmodifiableCollection(theScripts);

    }

    @Override

    public Iterator<Function> iterator() {

        return this.functions().iterator();

    }

    @Override

    public SymbolTable clone() throws CloneNotSupportedException {

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

        return other;

    }

}