Application: gvSIG desktop

package org.gvsig.fmap.dal.impl.expressionevaluator;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Objects;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Callable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Function;

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

import org.gvsig.expressionevaluator.ExpressionEvaluator;

import org.gvsig.expressionevaluator.impl.DefaultExpression;

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.evaluator.AbstractEvaluator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.lang.Cloneable;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureExpressionEvaluator

        extends AbstractEvaluator

        implements ExpressionEvaluator, Cloneable {

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

    private String storeName;

    private static class DescriptionAdapter implements Description {

        Function function;

        public DescriptionAdapter(Function function) {

            this.function = function;

        }

        @Override

        public String getName() {

            return this.function.name();

        }

        @Override

        public String getDescription() {

            return this.function.description();

        }

        @Override

        public String getTemplate() {

            return this.function.template();

        }

        @Override

        public int getDataTypeCategories() {

            switch (this.function.group()) {

                case Function.GROUP_STRING:

                    return Description.DATATYPE_CATEGORY_STRING;

                case Function.GROUP_BOOLEAN:

                    return Description.DATATYPE_CATEGORY_BOOLEAN;

                case Function.GROUP_DATETIME:

                    return Description.DATATYPE_CATEGORY_DATETIME;

                case Function.GROUP_NUMERIC:

                    return Description.DATATYPE_CATEGORY_NUMBER;

                case Function.GROUP_OGC:

                    return Description.DATATYPE_CATEGORY_ALL;

                default:

                    return Description.DATATYPE_CATEGORY_ALL;

            }

        }

    }

    private FeatureSymbolTable featureSymbolTable;

    private SymbolTable symbolTable;

    private Expression expression;

    private Description[] availableOperators;

    private Description[] availableFunctions;

    public DefaultFeatureExpressionEvaluator() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        this.symbolTable = manager.createSymbolTable();

        this.featureSymbolTable = new FeatureSymbolTableImpl();

        this.symbolTable.addSymbolTable(this.featureSymbolTable);

        this.availableOperators = null;

        this.availableFunctions = null;

    }

    public DefaultFeatureExpressionEvaluator(String source) {

        this(null, source);

    }

    public DefaultFeatureExpressionEvaluator(String storeName, String source) {

        this();

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        this.expression = manager.createExpression();

        this.expression.setPhrase(source);

        this.storeName = storeName;

    }

    public DefaultFeatureExpressionEvaluator(Expression expression) {

        this(null, expression);

    }

    public DefaultFeatureExpressionEvaluator(String storeName, Expression expression) {

        this();

        this.expression = expression;

        this.storeName = storeName;

    }

    @Override

    public String getName() {

        return "Genereric expression";

    }

    @Override

    public String getDescription() {

        return this.expression.getPhrase();

    }

    @Override

    public String getSQL() {

        return this.expression.getPhrase();

    }

    @Override

    public Expression toExpression() {

        return expression;

    }

    @Override

    public SymbolTable toSymbolTable() {

        return this.symbolTable;

    }

    @Override

    public Object evaluate(EvaluatorData data) throws EvaluatorException {

        this.featureSymbolTable.setFeature((Feature) data);

        Object v = this.expression.execute(this.symbolTable);

        return v;

    }

    @Override

    public EvaluatorFieldsInfo getFieldsInfo() {

        final Set<String> names = new HashSet<>();

        try {

            this.expression.getCode().accept((Object code) -> {

                if (code instanceof Code.Identifier) {

                    Code.Identifier identifier = (Code.Identifier) code;

                    if (!StringUtils.equalsIgnoreCase(storeName, identifier.name())) {

                        names.add(identifier.name());

                    }

                } else if (code instanceof Code.Callable) {

                    Callable callable = (Callable) code;

                    if (callable.name().equals(ExpressionBuilder.FUNCTION_GETATTR)) {

                        Code p0 = callable.parameters().get(0);

                        if (!(p0 instanceof Code.Identifier)) {

                            return;

                        }

                        if (!StringUtils.equalsIgnoreCase(storeName, ((Code.Identifier) p0).name())) {

                            return;

                        }

                        Code p1 = callable.parameters().get(1);

                        if (!(p1 instanceof Code.Constant)) {

                            return;

                        }

                        String s = Objects.toString(((Code.Constant) p1).value(), null);

                        if (s != null) {

                            names.add(s);

                        }

                    }

                }

            });

            EvaluatorFieldsInfo info = new EvaluatorFieldsInfo();

            for (String name : names) {

                info.addFieldValue(name);

            }

            return info;

        } catch (BaseException ex) {

            throw new RuntimeException("Can't calculate fields information.", ex);

        }

    }

    @Override

    public Description[] getAvailableOperators() {

        if (availableOperators == null) {

            List<Description> l = new ArrayList<>();

            for (Function function : toSymbolTable()) {

                if (function.isOperator()) {

                    l.add(new DescriptionAdapter(function));

                }

            }

            this.availableOperators = l.toArray(new Description[l.size()]);

        }

        return availableOperators;

    }

    @Override

    public Description[] getAvailableFunctions() {

        if (availableFunctions == null) {

            List<Description> l = new ArrayList<>();

            for (Function function : toSymbolTable()) {

                if (!function.isOperator()) {

                    l.add(new DescriptionAdapter(function));

                }

            }

            this.availableFunctions = l.toArray(new Description[l.size()]);

        }

        return availableFunctions;

    }

    @Override

    public Evaluator clone() throws CloneNotSupportedException {

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

        other.expression = this.expression.clone();

        other.availableFunctions = null;

        other.availableOperators = null;

        if (this.featureSymbolTable != null) {

            other.featureSymbolTable = this.featureSymbolTable.clone();

        }

        if (this.symbolTable != null) {

            other.symbolTable = this.symbolTable.clone();

        }

        return other;

    }

    @Override

    public void saveToState(PersistentState ps) throws PersistenceException {

        ps.set("expression", expression);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.expression = (Expression) state.get("expression");

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("DefaultFeatureExpressionEvaluator") == null) {

            DynStruct definition = manager.addDefinition(DefaultFeatureExpressionEvaluator.class,

                    "DefaultFeatureExpressionEvaluator", "DefaultFeatureExpressionEvaluator persistence definition", null, null);

            definition.addDynFieldObject("expression").setClassOfValue(DefaultExpression.class).setMandatory(false);

        }

    }

    @Override

    public void addSymbolTable(SymbolTable symbolTable) {

        if (symbolTable != null) {

            this.symbolTable.addSymbolTable(symbolTable);

        }

    }

}