Application: gvSIG desktop

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

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.StoresRepository;

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

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

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

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

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

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

import static org.gvsig.fmap.dal.impl.expressionevaluator.DALSymbolTable.FUNCTION_FEATURES;

import org.gvsig.fmap.dal.impl.expressionevaluator.DALSymbolTable.FeaturesFunction;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.script.Script;

import org.gvsig.tools.util.UnmodifiableBasicList;

/**

 *

 * @author jjdelcerro

 */

    @SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureSymbolTable extends AbstractSymbolTable implements FeatureSymbolTable {

    public static final String FUNCTION_FOREING_VALUE = "FOREING_VALUE";

    public class ForeingValueFunction extends AbstractFunction {

        public ForeingValueFunction() {

            super(

                    "Data access",

                    FUNCTION_FOREING_VALUE,

                    Range.is(1),

                    "Return the value of a field throw a relation from other tables.",

                    FUNCTION_FOREING_VALUE + "({{field_name}})",

                    new String[]{

                        "fieldName - dot separated field path"

                    },

                    "OBJECT"

            );

        }

        @Override

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

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String fullFieldName = getStr(args, 0);

            String[] nameParts = fullFieldName.split("[.]");

            Feature currentFeature = feature;

            try {

                String namePart;

                Object value;

                for (int i = 0; i < nameParts.length-1; i++) {

                    namePart = nameParts[i];

                    value = currentFeature.get(namePart);

                    FeatureAttributeDescriptor attrdesc = currentFeature.getType().getAttributeDescriptor(namePart);

                    Tags tags = attrdesc.getTags();

                    String storeName = tags.getString(DataManager.DAL_FOREING_TABLE, null);

                    String attrName = tags.getString(DataManager.DAL_FOREING_CODE, null);

                    StoresRepository repository = currentFeature.getStore().getStoresRepository();

                    FeatureStore store = (FeatureStore) repository.get(storeName);

                    currentFeature = store.findFirst(

                            builder.eq(

                                    builder.constant(value), 

                                    builder.variable(attrName)

                            ).toString()

                    );

                    if( currentFeature==null ) {

                        return null;

                    }

                }

                namePart = nameParts[nameParts.length-1];

                value = currentFeature.get(namePart);

                return value;

            } catch (ExpressionRuntimeException ex) {

                throw ex;

            } catch (Exception ex) {

                throw new ExpressionRuntimeException("Problems calling '" + FUNCTION_FEATURES + "' function", ex);

            }

        }

    }

    private class LocalFeaturesFunction extends FeaturesFunction {

        public LocalFeaturesFunction() {

            super();

        }

        @Override

        protected DataStore getStore(String storeName) {

            DataManager dataManager = DALLocator.getDataManager();

            DataStore store = null;

            if (feature != null) {

                store = feature.getStore();

                store = store.getChildren().get(storeName);

            }

            if (store == null) {

                StoresRepository repository = dataManager.getStoresRepository();

                if (repository.containsKey(storeName)) {

                    store = repository.get(storeName);

                }

            }

            return store;

        }

    }

    private class FeatureFunction extends AbstractFunction {

        public FeatureFunction() {

            super(

                    "Data access",

                    "feature",

                    Range.is(0),

                    "Access to the current feature object when used in a filter.\n"

                    + "Return null if used outer a filter.",

                    "feature()",

                    null,

                    "Feature"

            );

        }

        @Override

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

            return feature;

        }

    }

    public class FeatureStoreFunction extends AbstractFunction {

        public FeatureStoreFunction() {

            super(

                    "Data access",

                    "store",

                    Range.is(0),

                    "Access to the current store object when used in a filter.\n"

                    + "Return null if used outer a filter.",

                    "store()",

                    null,

                    "FeatureStore"

            );

        }

        @Override

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

            if (feature == null) {

                return null;

            }

            return feature.getStore();

        }

    }

    public class IsSelectedFunction extends AbstractFunction {

        public IsSelectedFunction() {

            super(

                    "Data access",

                    "isSelected",

                    Range.is(0),

                    "Return if the current feature is selected in the store when used in a filter.\n"

                    + "Return false if used outer a filter.",

                    "isSelected()",

                    null,

                    "Boolean"

            );

        }

        @Override

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

            if (feature == null) {

                return false;

            }

            FeatureStore store = feature.getStore();

            FeatureSelection selection = store.getFeatureSelection();

            return selection.isSelected(feature);

        }

    }

    private Feature feature;

    private FeatureType type;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public DefaultFeatureSymbolTable() {

        super(DataManager.FEATURE_SYMBOL_TABLE);

        this.addFunction(new FeatureFunction());

        this.addFunction(new FeatureStoreFunction());

        this.addFunction(new IsSelectedFunction());

        this.addFunction(new LocalFeaturesFunction());

        this.addFunction(new ForeingValueFunction());

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public DefaultFeatureSymbolTable(Script userScript, UnmodifiableBasicList<Script> scripts) {

        this();

        if (userScript != null) {

            this.getScripts().add(userScript);

        }

        if (scripts != null && !scripts.isEmpty()) {

            for (Script script : scripts) {

                this.getScripts().add(script);

            }

        }

    }

    @Override

    public FeatureSymbolTable clone() throws CloneNotSupportedException {

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

        return other;

    }

    @Override

    public boolean exists(String name) {

        if (type != null && type.get(name) != null) {

            return true;

        }

        return false;

    }

    @Override

    public Object value(String name) {

        if (feature == null) {

            return null;

        }

        return this.feature.get(name);

    }

    @Override

    public boolean isSQLCompatible(String name) {

        if (this.type == null) {

            return super.isSQLCompatible(name);

        }

        FeatureAttributeDescriptor attrdesc = this.type.getAttributeDescriptor(name);

        if (attrdesc == null) {

            return true;

        }

        if (attrdesc.isComputed()) {

            return false;

        }

        return true;

    }

    @Override

    public void setFeature(Feature feature) {

        this.feature = feature;

        this.type = feature.getType();

    }

    @Override

    public MutableSymbolTable createParent() {

        ExpressionEvaluatorManager expManager = ExpressionEvaluatorLocator.getManager();

        MutableSymbolTable symbolTable = expManager.createSymbolTable();

        symbolTable.addSymbolTable(this);

        return symbolTable;

    }

    public static void selfRegister() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        manager.registerSymbolTable(new DefaultfeatureSymbolTableFactory());

    }

}