Application: gvSIG desktop

import org.gvsig.tools.util.GetItemByKey;

public interface Feature extends GetItemByKey<String, Object>{

        @Override

//        if (this.isReadOnly(i)) {

//            return;

//        }

                    || attribute.isComputed() ) {

            int index = featureAttributeDescriptor.getIndex();

            value = this.data.get(index);

            if( value==null ) {

                value = emulator.get(this);

                this.data.set(index,value);

            }

import java.util.List;

import org.gvsig.tools.util.UnmodifiableBasicList;

    public static final String FETCH_NAME = "FETCH";

    private class FetchFunction extends AbstractFunction {

        public FetchFunction() {

            super(

                    "Project",

                    FETCH_NAME,

                    Range.between(2, 4),

                    "Access to the features of a table and retuen a list with the values.",

                    FETCH_NAME+"({{value}}, store, where, order)",

                    new String[]{

                        "value - value to retrieve from the store, usually an expression in the columns of this are involved.",

                        "store - data store from which values will be collected",

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

                    },

                    "Object"

            );

        }

        @Override

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

            Object value;

            String where = null;

            String order = null;

            String expression_s = getStr(args, 0);

            FeatureStore store = (FeatureStore) getObject(args, 1);

            switch (args.length) {

                case 3:

                    where = getStr(args, 2);

                    break;

                case 4:

                    where = getStr(args, 2);

                    order = getStr(args, 3);

                    break;

            }

            try {

                List<Feature> features;

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

                    features = store.getFeatures();

                } else {

                    FeatureQuery query = store.createFeatureQuery();

                    if (where != null) {

                        query.addFilter(where);

                    }

                    if (order != null) {

                        query.getOrder().add(order);

                    }

                    query.retrievesAllAttributes();

                    features = store.getFeatures(query);

                }

                UnmodifiableBasicList<Object> list = new ListOfFeaturesWrapper(

                        features,

                        interpreter.getSymbolTable(), 

                        expression_s

                );

                return list;

            } catch (Exception ex) {

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

            }

        }

    }

        this.addFunction(new FetchFunction());

package org.gvsig.app.project.symboltables;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

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

import org.gvsig.tools.util.UnmodifiableBasicList;

import org.gvsig.tools.util.UnmodifiableBasicListToListAdapter;

/**

 *

 * @author jjdelcerro

 */

public class ListOfFeaturesWrapper implements UnmodifiableBasicList<Object> {

    private final List<Feature> features;

    private final FeatureSymbolTable featureSymbolTable;

    private final MutableSymbolTable symbolTable;

    private final Expression expression;

    public ListOfFeaturesWrapper(

            List<Feature> features, 

            SymbolTable symbolTable, 

            String expression

        ) {

        DataManager dataManager = DALLocator.getDataManager();

        ExpressionEvaluatorManager expManager = ExpressionEvaluatorLocator.getManager();

        this.features = features;

        this.featureSymbolTable = dataManager.createFeatureSymbolTable();

        this.symbolTable = this.featureSymbolTable.createParent();

        this.symbolTable.addSymbolTable(symbolTable);

        this.expression = expManager.createExpression();

        this.expression.setPhrase(expression);

    }

    private Object getValue(Feature feature) {

        this.featureSymbolTable.setFeature(feature);

        Object value = this.expression.execute(this.symbolTable);

        return value;

    }

    @Override

    public boolean isEmpty() {

        return this.features.isEmpty();

    }

    @Override

    public List<Object> toList() {

        List<Object> x = new UnmodifiableBasicListToListAdapter<>(this);

        return x;

    }

    @Override

    public Object get(int position) {

        return this.getValue(this.features.get(position));

    }

    @Override

    public int size() {

        return this.features.size();

    }

    @Override

    public Iterator<Object> iterator() {

        return new Itr();

    }

    private class Itr implements Iterator<Object> {

        int cursor;       // index of next element to return

        Itr() {}

        @Override

        public boolean hasNext() {

            return cursor != size();

        }

        @Override

        public Object next() {

            int i = cursor;

            if (i >= size())

                throw new NoSuchElementException();

            cursor = i + 1;

            return get(i);

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

    }

}

import org.gvsig.tools.util.GetItemByKey;

        } else if( obj instanceof GetItemByKey ) {

            GetItemByKey l = (GetItemByKey)obj;

            Object key = getObject(args,1);

            value = l.get(key);