Application: gvSIG desktop

package org.gvsig.app.project;

import java.io.File;

import java.io.FileInputStream;

import java.util.HashMap;

import java.util.Map;

import java.util.Properties;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.Range;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

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

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

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

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

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

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ProjectSymbolTable extends AbstractSymbolTable {

    private abstract class CachedValue<T> {

        T value = null;

        long lastAccess = 0;

        protected abstract void reload();

        public boolean isExpired() {

            long now = System.currentTimeMillis();

            return now - lastAccess > 3000;

        }

        public T get() {

            if (isExpired()) {

                reload();

            }

            lastAccess = System.currentTimeMillis();

            return value;

        }

    }

    private class ProjectValue extends CachedValue<Project> {

        @Override

        protected void reload() {

            value = ProjectManager.getInstance().getCurrentProject();

        }

    }

    private class PropertiesValue extends CachedValue<Map<File, Properties>> {

        @Override

        protected void reload() {

            value = new HashMap<>();

        }

    }

    private class CurrentProjectFunction extends AbstractFunction {

        public CurrentProjectFunction() {

            super(

                    "Project",

                    "project",

                    Range.is(0),

                    "Access to the current project loaded in gvSIG desktop.\n",

                    "project()",

                    null,

                    "Project"

            );

        }

        @Override

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

            return currentProject.get();

        }

    }

    private class FirstSelectedFeatureFunction extends AbstractFunction {

        public FirstSelectedFeatureFunction() {

            super(

                    "Project",

                    "firstSelectedFeature",

                    Range.between(3, 4),

                    "Access to the first selected feature of the layer, and "

                    + "return the value of the attribute.",

                    "firstSelectedFeature({{view}}, layer, attribute, defaulValue)",

                    new String[]{

                        "view - String value with the name of a view",

                        "layer - String value with the name of a layer in the indicated view",

                        "attribute - String value with the name of the attribute in the indicated layer",

                        "defaultValue - Optional. Value to use if the indicated "

                        + "attribute can not be accessed. For example, if the "

                        + "view or layer does not exist, or it does not have "

                        + "selected elements."

                    },

                    "Object"

            );

        }

        @Override

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

            Object defaultValue = null;

            String viewName = getStr(args, 0);

            String layerName = getStr(args, 1);

            String attrName = getStr(args, 2);

            if (args.length == 4) {

                defaultValue = getObject(args, 3);

            }

            try {

                Project project = currentProject.get();

                ViewDocument view = (ViewDocument) project.getDocument(viewName, ViewManager.TYPENAME);

                if (view == null) {

                    return defaultValue;

                }

                FLayer layer = view.getLayer(layerName);

                if (!(layer instanceof FLyrVect)) {

                    return defaultValue;

                }

                FeatureSelection selection = ((FLyrVect) layer).getFeatureStore().getFeatureSelection();

                if (selection == null || selection.isEmpty()) {

                    return defaultValue;

                }

                Feature feature = selection.first();

                if (feature == null) {

                    return defaultValue;

                }

                return feature.get(attrName);

            } catch (Exception ex) {

                return defaultValue;

            }

        }

    }

    private class FirstFeatureFunction extends AbstractFunction {

        public FirstFeatureFunction() {

            super(

                    "Project",

                    "firstFeature",

                    Range.between(3, 6),

                    "Access to the first feature of the layer, and "

                    + "return the value of the attribute.",

                    "firstFeature({{view}}, layer, attribute, filter, order, defaulValue)",

                    new String[]{

                        "view - String value with the name of a view",

                        "layer - String value with the name of a layer in the indicated view",

                        "attribute - String value with the name of the attribute in the indicated layer",

                        "filter - 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",

                        "defaultValue - Optional. Value to use if the indicated "

                        + "attribute can not be accessed. For example, if the "

                        + "view or layer does not exist."

                    },

                    "Object"

            );

        }

        @Override

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

            Object defaultValue = null;

            String filter = null;

            String order = null;

            String viewName = getStr(args, 0);

            String layerName = getStr(args, 1);

            String attrName = getStr(args, 2);

            switch(args.length ) {

                case 4:

                    filter = getStr(args, 3);

                    break;

                case 5:

                    filter = getStr(args, 3);

                    order = getStr(args, 4);

                    break;

                case 6:

                    filter = getStr(args, 3);

                    order = getStr(args, 4);

                    defaultValue = getObject(args, 6);

                    break;

            }

            try {

                Project project = currentProject.get();

                ViewDocument view = (ViewDocument) project.getDocument(viewName, ViewManager.TYPENAME);

                if (view == null) {

                    return defaultValue;

                }

                FLayer layer = view.getLayer(layerName);

                if (!(layer instanceof FLyrVect)) {

                    return defaultValue;

                }

                FeatureStore store = ((FLyrVect) layer).getFeatureStore();

                FeatureSet set;

                if( filter==null && order==null ) {

                    set = store.getFeatureSet();

                } else {

                    FeatureQuery query = store.createFeatureQuery();

                    if( filter != null ) {

                        query.addFilter(filter);

                    }

                    if( order!=null ) {

                        query.getOrder().add(order);

                    }

                    set = store.getFeatureSet(query);

                }

                Feature feature = set.first();

                if (feature == null) {

                    return defaultValue;

                }

                return feature.get(attrName);

            } catch (Exception ex) {

                return defaultValue;

            }

        }

    }

    private class ViewFunction extends AbstractFunction {

        public ViewFunction() {

            super(

                    "Project",

                    "view",

                    Range.is(1),

                    "Access to the indicated view",

                    "view({{viewName}})",

                    new String[]{

                        "view - String value with the name of a view"

                    },

                    "DocumentView"

            );

        }

        @Override

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

            String viewName = getStr(args, 0);

            Project project = currentProject.get();

            ViewDocument view = (ViewDocument) project.getDocument(viewName, ViewManager.TYPENAME);

            return view;

        }

    }

    private class PropertyFunction extends AbstractFunction {

        public PropertyFunction() {

            super(

                    "Project",

                    "property",

                    Range.between(2, 3),

                    "Access to a property value in a properties file. If the"

                    + "indicated filename is not absolute, access it relative"

                    + "to the project.",

                    "property({{filename}}, name, defaultValue)",

                    new String[]{

                        "filename - String value with the name of the properties file",

                        "name - String value with the name of the property to retrieve from the file",

                        "defaultValue - Optional. Default value if can't access the file or the property",},

                    "String"

            );

        }

        @Override

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

            String filename = getStr(args, 0);

            String name = getStr(args, 1);

            String defaultValue = null;

            if (args.length == 3) {

                defaultValue = getStr(args, 2);

            }

            File file = new File(filename);

            if (!file.isAbsolute()) {

                Project project = currentProject.get();

                if (project.getFile() == null) {

                    return defaultValue;

                }

                file = new File(project.getFile().getParent(), filename);

            }

            Map<File, Properties> x = propertiesFiles.get();

            Properties properties = x.get(file);

            if (properties == null) {

                properties = new Properties();

                FileInputStream in = null;

                try {

                    in = new FileInputStream(file);

                    properties.load(in);

                } catch (Exception ex) {

                    return defaultValue;

                } finally {

                    IOUtils.closeQuietly(in);

                }

                x.put(file, properties);

            }

            String value = properties.getProperty(name, defaultValue);

            return value;

        }

    }

    ProjectValue currentProject = new ProjectValue();

    PropertiesValue propertiesFiles = new PropertiesValue();

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public ProjectSymbolTable() {

        super("Project");

        this.addFunction(new CurrentProjectFunction());

        this.addFunction(new FirstSelectedFeatureFunction());

        this.addFunction(new FirstFeatureFunction());

        this.addFunction(new ViewFunction());

        this.addFunction(new PropertyFunction());

    }

    public static void selfRegister() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        manager.registerSymbolTable(new ProjectSymbolTable(), true);

    }

}