Application: gvSIG desktop

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

import java.util.Arrays;

import java.util.List;

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 static org.gvsig.fmap.dal.DataManager.FUNCTION_FOREING_VALUE;

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 org.gvsig.fmap.dal.feature.ForeingKey;

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

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

import org.gvsig.tools.script.Script;

import org.gvsig.tools.util.UnmodifiableBasicList;

import org.gvsig.tools.util.UnmodifiableBasicListAdapter;

/**

 *

 * @author jjdelcerro

 */

    @SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureSymbolTable extends AbstractSymbolTable implements FeatureSymbolTable {

    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 or list of strings with field names."

                    },

                    "OBJECT"

            );

        }

        @Override

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

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            UnmodifiableBasicList<String> fieldNames;

            Object fields_o = getObject(args, 0);

            if( fields_o instanceof List ) {

                fieldNames = new UnmodifiableBasicListAdapter<>((List<String>) fields_o);

            } else if( fields_o instanceof String ) {

                fieldNames =  new UnmodifiableBasicListAdapter<>(Arrays.asList(((String)fields_o).split("[.]")));

            } else if( fields_o instanceof UnmodifiableBasicList ) {

                fieldNames = (UnmodifiableBasicList<String>) fields_o;

            } else {

                throw new ExpressionRuntimeException(

                    "Problems calling '" + FUNCTION_FEATURES + 

                    "' function, type of parameter '"+fields_o.getClass().getSimpleName()+

                    "' not supported, use string or list.");

            }

            Feature currentFeature = feature;

            try {

                String fieldName;

                Object value;

                for (int i = 0; i < fieldNames.size()-1; i++) {

                    fieldName = fieldNames.get(i);

                    value = currentFeature.get(fieldName);

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

                    ForeingKey foreingKey = attrdesc.getForeingKey();

//                    ContextForeingKey context = foreingKey.createContext();

                    currentFeature = foreingKey.getFeature(null, value);

//                    DisposeUtils.disposeQuietly(context);

                    if( currentFeature==null ) {

                        return null;

                    }

                }

                fieldName = fieldNames.get(fieldNames.size()-1);

                value = currentFeature.get(fieldName);

                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.getStore(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.DAL_SYMBOL_TABLE_FEATURE);

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

    }

}