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.apache.commons.lang3.StringUtils;

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 org.gvsig.fmap.dal.impl.expressionevaluator.DALSymbolTable.FeaturesFunction;

import org.gvsig.tools.dynobject.DynObjectAdapter;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

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 static final String FUNCTION_FEATURES = "FEATURES";

//

//    public class FeaturesFunction extends AbstractFunction {

//

//        public FeaturesFunction() {

//            super(

//                    "Data access",

//                    FUNCTION_FEATURES,

//                    Range.between(1, 3),

//                    "Return a list of the features selecteds with filter in the store.",

//                    FUNCTION_FEATURES + "({{store_name}}, filter, order)",

//                    new String[]{

//                        "store - data store name to be used",

//                        "where - Optional. String value with a filter expression",

//                        "order - Optional. String value with the order. must be a string with the names of separate fields with commas"

//                    },

//                    "LIST"

//            );

//        }

//

//        @Override

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

//            String storeName = getStr(args, 0);

//            String where = null;

//            String order = null;

//            switch (args.length) {

//                case 2:

//                    where = getStr(args, 1);

//                    break;

//                case 3:

//                    where = getStr(args, 1);

//                    order = getStr(args, 2);

//                    break;

//            }

//            try {

//                DataStore store = getStore(storeName);

//                if (store == null || !(store instanceof FeatureStore)) {

//                    throw new ExpressionRuntimeException("Cant locate the store '" + storeName + "' in function '" + FUNCTION_FEATURES + "'.");

//                }

//                if (!(store instanceof FeatureStore)) {

//                    throw new ExpressionRuntimeException("The store'" + storeName + "' is not valid for function '" + FUNCTION_FEATURES + "', a FeatureStore is required.");

//                }

//                FeatureStore featureStore = (FeatureStore) store;

//                List<Feature> features;

//                if (where == null && order == null) {

//                    features = featureStore.getFeatures();

//                } else {

//                    FeatureQuery query = featureStore.createFeatureQuery();

//                    if (where != null) {

//                        query.addFilter(where);

//                    }

//                    if (order != null) {

//                        query.getOrder().add(order);

//                    }

//                    query.retrievesAllAttributes();

//                    features = featureStore.getFeatures(query);

//                }

//                return features;

//            } catch (ExpressionRuntimeException ex) {

//                throw ex;

//            } catch (Exception ex) {

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

//            }

//        }

//

//        protected DataStore getStore(String storeName) {

//            DataStore store = feature.getStore();

////            DataManager dataManager = DALLocator.getDataManager();

////            DataStore store = dataManager.getStoresRepository().getStore(storeName);

//            return store;

//        }

//    }

    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_FOREING_VALUE + 

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

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

            }

            Feature currentFeature = feature;

            try {

                String fieldName;

                Object value;

                value = feature.getExtraValue(StringUtils.join(fieldNames, "."));

                if( value != null ) {

                    return 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_FOREING_VALUE + "' 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.getStoresRepository().getStore(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;

    private String storeName;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public DefaultFeatureSymbolTable() {

        super(DataManager.DAL_SYMBOL_TABLE_FEATURE);

//        this.addFunction(new FeaturesFunction());

        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;

        }

        if( StringUtils.equalsIgnoreCase(name, this.storeName) ) {

            return new DynObjectAdapter() {

                @Override

                public Object getDynValue(String string) throws DynFieldNotFoundException {

                    return feature.get(string);

                }

            };

        }

        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;

        if( this.type == null ) {

            this.type = feature.getType();

            FeatureStore store = feature.getStore();

            if( store!=null ) {

                this.storeName = store.getName();

            }

        }

    }

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

    }

}