Application: gvSIG desktop

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

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

import org.gvsig.fmap.dal.DataManager;

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

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

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

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

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

import org.gvsig.tools.script.Script;

import org.gvsig.tools.util.UnmodifiableBasicList;

/**

 *

 * @author jjdelcerro

 */

public class DefaultFeatureSymbolTable extends AbstractSymbolTable implements FeatureSymbolTable {

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

    }

    @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 void setFeature(Feature feature) {

        this.feature = feature;

        this.type = feature.getType();

    }

    public static void selfRegister() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        manager.registerSymbolTable(new DefaultFeatureSymbolTable(), false);

    }

}