Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.app.project.documents.table.gui;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.apache.commons.collections.ListUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Identifier;

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

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

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

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.MutableSymbolTable;

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

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

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;

/**

 *

 * @author osc

 */

public class EmulatedFieldExpression implements FeatureAttributeEmulator, Persistent {

    String[] requiredFields = null;

    String code = "";

    Code codeCompiled = null;

    MutableSymbolTable symbolTable = null;

    ExpressionEvaluatorManager expressionManager = null;

    private static final String EMULEFIELDEXP_PERSISTENCE_DEFINITION_NAME

            = "EmulatedFieldExpression";

    private boolean valid;

    private String errorMessage;

    public EmulatedFieldExpression() {

    }

    EmulatedFieldExpression(FeatureType featureType, String code) {

        this.setCode(code);

        this.checkVars(featureType);

    }

    public boolean isValid() {

        return this.valid;

    }

    private void checkVars(final FeatureType featureType) {

        this.valid = true;

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

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

        try {

            Code theCodeCompiled = this.getCodeCompiled();

            theCodeCompiled.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 (BaseException ex) {

            valid = false;

            this.errorMessage = ex.getMessage();

        }

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

    }

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(EMULEFIELDEXP_PERSISTENCE_DEFINITION_NAME)

                == null) {

            DynStruct definition = manager.addDefinition(

                    EmulatedFieldExpression.class,

                    EMULEFIELDEXP_PERSISTENCE_DEFINITION_NAME,

                    EMULEFIELDEXP_PERSISTENCE_DEFINITION_NAME

                    + " Persistent definition",

                    null,

                    null

            );

            definition.addDynFieldString("code")

                    .setMandatory(true)

                    .setPersistent(true);

            definition.addDynFieldArray("fields")

                    .setClassOfItems(String.class)

                    .setMandatory(true)

                    .setPersistent(true);

            definition.addDynFieldBoolean("valid")

                    .setMandatory(true)

                    .setPersistent(true);

        }

    }

    private Code getCodeCompiled() {

        if (this.codeCompiled == null) {

            this.codeCompiled = this.getExpressionManager().compile(code);

        }

        return this.codeCompiled;

    }

    private MutableSymbolTable getSymbolTable() {

        if (this.symbolTable == null) {

            this.symbolTable = this.getExpressionManager().createSymbolTable();

        }

        return this.symbolTable;

    }

    private ExpressionEvaluatorManager getExpressionManager() {

        if (this.expressionManager == null) {

            this.expressionManager

                    = ExpressionEvaluatorLocator.getManager();

        }

        return this.expressionManager;

    }

    @Override

    public Object get(Feature feature) {

        if (!this.valid) {

            return null;

        }

        MutableSymbolTable symbol = this.getSymbolTable();

        for (FeatureAttributeDescriptor descriptor : feature.getType()) {

            if (!descriptor.isComputed()) { // si eres tu mismo 

                String fieldName = descriptor.getName();

                Object value = feature.get(fieldName);

                symbol.setVar(fieldName, value);

            }

        }

        Code codeCompilation = this.getCodeCompiled();

        Object result = this.getExpressionManager().evaluate(symbol, codeCompilation);

        return result;

    }

    @Override

    public void set(EditableFeature feature, Object value) {

        //throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean allowSetting() {

        return false;

    }

    @Override

    public String[] getRequiredFieldNames() {

        return this.requiredFields;

    }

    public String getCode() {

        return this.code;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

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

        state.set("code", this.getCode());

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

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        String stateCode = state.getString("code");

        String[] stateFields = state.getStringArray("fields");

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

        this.setCode(stateCode);

        this.setFields(stateFields);

    }

    private void setCode(String code) {

        this.code = code;

    }

    private void setFields(String[] fields) {

        this.requiredFields = fields;

    }

    public String getErrorMessage() {

        return this.errorMessage;

    }

}