Application: gvSIG desktop

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

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Identifier;

import org.gvsig.expressionevaluator.Expression;

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

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

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DataManager;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

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

import org.gvsig.tools.logger.FilteredLogger;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author osc

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureAttributeEmulatorExpression implements FeatureAttributeEmulatorExpression {

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

    private static final String EMULEFIELDEXP_PERSISTENCE_DEFINITION_NAME = "EmulatedFieldExpression";

    private String[] requiredFields = null;

    private Expression expression = null;

    private SymbolTable symbolTable = null;

    private FeatureSymbolTable featureSymbolTable = null;

    private boolean valid;

    private String errorMessage;

    private boolean enableExceptions;

    private FilteredLogger logger;

    public DefaultFeatureAttributeEmulatorExpression() {

    }

    public DefaultFeatureAttributeEmulatorExpression(FeatureType featureType, Expression expression) {

        this.expression = expression;

        this.checkVars(featureType);

        this.enableExceptions = false;

    }

    private FilteredLogger getLogger() {

        if( this.logger == null ) {

            this.logger = new FilteredLogger(LOGGER, "FeatureAttributeEmulatorExpression", 10);

        }

        return this.logger;

    }

    private void checkVars(final FeatureType featureType) {

        this.valid = true;

        final List<String> theUsedFields = new ArrayList<>();

        final List<String> undefinedFields = new ArrayList<>();

        try {

            Code code = this.expression.getCode();

            code.accept(new Visitor() {

                @Override

                public void visit(Object obj) throws VisitCanceledException, BaseException {

                    Code code = (Code) obj;

                    if (code instanceof Identifier) {

                        String name = ((Identifier) code).name();

                        if (featureType.get(name) == null) {

                            undefinedFields.add(name);

                            valid = false;

                        } else {

                            theUsedFields.add(name);

                        }

                    }

                }

            });

            if(!undefinedFields.isEmpty()){

                this.errorMessage = "undefined fields " + StringUtils.join(undefinedFields,", ");

            }

        } catch (Exception ex) {

            valid = false;

            this.errorMessage = ex.getMessage();

        }

        this.requiredFields = theUsedFields.toArray(new String[theUsedFields.size()]);

    }

    public boolean isEnableExceptions() {

        return enableExceptions;

    }

    public void setEnableExceptions(boolean enableExceptions) {

        this.enableExceptions = enableExceptions;

    }

    @Override

    public SymbolTable getSymbolTable() {

        if (this.symbolTable == null) {

            ExpressionEvaluatorManager expressionManager = ExpressionEvaluatorLocator.getManager();

            this.featureSymbolTable = (FeatureSymbolTable) expressionManager.getSymbolTable(

                    DataManager.FEATURE_SYMBOL_TABLE

            );

            this.symbolTable = expressionManager.createSymbolTable();

            this.symbolTable.addSymbolTable(this.featureSymbolTable);

        }

        return this.symbolTable;

    }

    private FeatureSymbolTable getFeatureSymbolTable() {

        if (this.featureSymbolTable == null) {

            this.getSymbolTable();

        }

        return this.featureSymbolTable;

    }

    @Override

    public boolean isValid() {

        return this.valid;

    }

    @Override

    public Object get(Feature feature) {

        if (!this.valid) {

            return null;

        }

        this.getFeatureSymbolTable().setFeature(feature);

        try {

            Object result = this.expression.execute(this.getSymbolTable());

            return result;

        } catch(Exception ex) {

            if( this.enableExceptions ) {

                throw ex;

            }

            this.getLogger().warn("Problems evaluating expression '"+this.expression.getPhrase()+"' with feature '"+feature.getReference().toString()+"'.", ex);

            return null;

        }

    }

    @Override

    public void set(EditableFeature feature, Object value) {

        // Do nothing

    }

    @Override

    public boolean allowSetting() {

        return false;

    }

    @Override

    public String[] getRequiredFieldNames() {

        return this.requiredFields;

    }

    @Override

    public Expression getExpression() {

        return this.expression;

    }

    @Override

    public String getErrorMessage() {

        return this.errorMessage;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("fields", this.requiredFields);

        state.set("expression", this.expression);

        state.set("valid", this.valid);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.valid = state.getBoolean("valid");

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

        this.requiredFields = state.getStringArray("fields");

    }

    @Override

    public String toString() {

        StringBuilder builder = new StringBuilder();

        builder.append("{ (").append(StringUtils.right(super.toString(),9)).append(")\n");

        builder.append("isValid: ").append(this.isValid()).append(",\n");

        builder.append("requiredFields: ").append(StringUtils.join(this.requiredFields)).append(",\n");

        builder.append("errorMessage: \"").append(this.errorMessage).append("\",\n");

        builder.append("expression: ").append(this.expression).append("\n");

        builder.append("}");

        return builder.toString();

    }

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(EMULEFIELDEXP_PERSISTENCE_DEFINITION_NAME)

                == null) {

            DynStruct definition = manager.addDefinition(DefaultFeatureAttributeEmulatorExpression.class,

                    EMULEFIELDEXP_PERSISTENCE_DEFINITION_NAME,

                    EMULEFIELDEXP_PERSISTENCE_DEFINITION_NAME

                    + " Persistent definition",

                    null,

                    null

            );

            definition.addDynFieldObject("expression")

                    .setMandatory(true)

                    .setPersistent(true)

                    .setClassOfValue(Expression.class);

            definition.addDynFieldArray("fields")

                    .setClassOfItems(String.class)

                    .setMandatory(true)

                    .setPersistent(true);

            definition.addDynFieldBoolean("valid")

                    .setMandatory(true)

                    .setPersistent(true);

        }

    }

}