Application: gvSIG desktop

            AutomaticDetectionOfTypes x = new AutomaticDetectionOfTypes(

                    this.getFullFileName()

            );

            types = x.detect(

                    headers.length, 

                    reader, 

                    CSVStoreParameters.isFirstLineHeader(getCSVParameters()), 

                    CSVStoreParameters.getLocale(getCSVParameters())

            );

package org.gvsig.fmap.dal.store.csv;

import java.io.IOException;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

import java.util.Locale;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypesManager;

/**

 *

 * @author jjdelcerro

 */

public class AutomaticDetectionOfTypes {

    public interface Rows {

        public List<String> nextRowValues();

    }

    private static class PossibleDataType {

        public boolean possibleInt = true;

        public boolean possibleFloat = true;

        public boolean possibleDouble = true;

        public boolean possibleLong = true;

        public boolean possibleURL = true;

        public boolean possibleDate = true;

        public boolean possibleGeometry = true;

    }

    private final String filename;

    public AutomaticDetectionOfTypes() {

        this("(unknown)");

    }

    public AutomaticDetectionOfTypes(String filename) {

        this.filename = filename;

    }

    private String getFullFileName() {

        return this.filename;

    }

    @SuppressWarnings({"UseSpecificCatch", "ResultOfObjectAllocationIgnored"})

    public int[] detect(int columns, Rows rows, boolean isFirstLineHeader, Locale locale) throws IOException {

        List<PossibleDataType> possibleDataTypes;

        int[] types = null;

        int lineno = 0;

        try {

            if (isFirstLineHeader) {

                rows.nextRowValues();

                lineno++;

            }

            possibleDataTypes = new ArrayList<>(columns);

            for (int i = 0; i < columns; i++) {

                possibleDataTypes.add(new PossibleDataType());

            }

            if (locale == null) {

                locale = Locale.getDefault();

            }

            DataTypesManager typeManager = ToolsLocator.getDataTypesManager();

            DataTypesManager.CoercionWithLocale toDouble = (DataTypesManager.CoercionWithLocale) typeManager.getCoercion(DataTypes.DOUBLE);

            DataTypesManager.CoercionWithLocale toFloat = (DataTypesManager.CoercionWithLocale) typeManager.getCoercion(DataTypes.FLOAT);

            DataTypesManager.CoercionWithLocale toDate = (DataTypesManager.CoercionWithLocale) typeManager.getCoercion(DataTypes.DATE);

            DataTypesManager.CoercionWithLocale toInt = (DataTypesManager.CoercionWithLocale) typeManager.getCoercion(DataTypes.INT);

            DataTypesManager.CoercionWithLocale toLong = (DataTypesManager.CoercionWithLocale) typeManager.getCoercion(DataTypes.LONG);

            DataTypesManager.Coercion toGeom = typeManager.getCoercion(DataTypes.GEOMETRY);

            List<String> row = rows.nextRowValues();

            lineno++;

            while (row != null) {

                for (int i = 0; i < row.size(); i++) {

                    while( possibleDataTypes.size()<row.size() ) {

                        possibleDataTypes.add(new PossibleDataType());

                    }

                    String rawvalue = row.get(i);

                    PossibleDataType possibleDataType = possibleDataTypes.get(i);

                    if (possibleDataType.possibleDouble) {

                        try {

                            toDouble.coerce(rawvalue, locale);

                            possibleDataType.possibleDouble = true;

                        } catch (Exception ex) {

                            possibleDataType.possibleDouble = false;

                        }

                    }

                    if (possibleDataType.possibleFloat) {

                        try {

                            toFloat.coerce(rawvalue, locale);

                            possibleDataType.possibleFloat = true;

                        } catch (Exception ex) {

                            possibleDataType.possibleFloat = false;

                        }

                    }

                    if (possibleDataType.possibleLong) {

                        possibleDataType.possibleLong = isValidLong(rawvalue);

                    }

                    if (possibleDataType.possibleInt) {

                        possibleDataType.possibleInt = isValidInteger(rawvalue);

                    }

                    if (possibleDataType.possibleDate) {

                        try {

                            toDate.coerce(rawvalue, locale);

                            possibleDataType.possibleDate = true;

                        } catch (Exception ex) {

                            possibleDataType.possibleDate = false;

                        }

                    }

                    if (possibleDataType.possibleURL) {

                        try {

                            new URL((String) rawvalue);

                            possibleDataType.possibleURL = true;

                        } catch (Exception ex) {

                            possibleDataType.possibleURL = false;

                        }

                    }

                    if (possibleDataType.possibleGeometry) {

                        try {

                            toGeom.coerce((String) rawvalue);

                            possibleDataType.possibleGeometry = true;

                        } catch (Exception ex) {

                            possibleDataType.possibleGeometry = false;

                        }

                    }

                }

                row = rows.nextRowValues();

            }

            int n = 0;

            types = new int[possibleDataTypes.size()];

            for (PossibleDataType possibleDataType : possibleDataTypes) {

                if (possibleDataType.possibleInt) {

                    types[n++] = DataTypes.INT;

                    continue;

                }

                if (possibleDataType.possibleLong) {

                    types[n++] = DataTypes.LONG;

                    continue;

                }

                if (possibleDataType.possibleFloat) {

                    // Forzamos los float a double para evitar perder precision

                    types[n++] = DataTypes.DOUBLE;

                    continue;

                }

                if (possibleDataType.possibleDouble) {

                    types[n++] = DataTypes.DOUBLE;

                    continue;

                }

                if (possibleDataType.possibleURL) {

                    types[n++] = DataTypes.URL;

                    continue;

                }

                if (possibleDataType.possibleDate) {

                    types[n++] = DataTypes.DATE;

                    continue;

                }

                if (possibleDataType.possibleGeometry) {

                    types[n++] = DataTypes.GEOMETRY;

                    continue;

                }

                types[n++] = DataTypes.STRING;

            }

        } catch (Exception ex) {

            throw new RuntimeException("Problems reading file '" + this.getFullFileName() + "' near line " + lineno + ".", ex);

        }

        return types;

    }

    @SuppressWarnings("UseSpecificCatch")

    private boolean isValidLong(String s) {

        if (s == null) {

            return true;

        }

        s = s.trim().toLowerCase();

        if (s.isEmpty()) {

            return true;

        }

        try {

            if (s.startsWith("0x")) {

                Long.valueOf(s.substring(2), 16);

            } else {

                Long.valueOf(s);

            }

            return true;

        } catch (Exception ex) {

            return false;

        }

    }

    @SuppressWarnings("UseSpecificCatch")

    private boolean isValidInteger(String s) {

        if (s == null) {

            return true;

        }

        s = s.trim().toLowerCase();

        if (s.isEmpty()) {

            return true;

        }

        try {

            if (s.startsWith("0x")) {

                Integer.valueOf(s.substring(2), 16);

            } else {

                Integer.valueOf(s);

            }

            return true;

        } catch (Exception ex) {

            return false;

        }

    }

}

    @Override

    public List<String> nextRowValues() {

        try {

            return this.read();

        } catch (IOException ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public List<String> nextRowValues() {

        try {

            return this.read();

        } catch (IOException ex) {

            throw new RuntimeException(ex);

        }

    }

import org.gvsig.fmap.dal.store.csv.AutomaticDetectionOfTypes.Rows;

public interface SimpleReader extends Closeable, Rows {

        } else if ((mode & EDITED) == EDITED) {

            long mySize = provider.getSize()

                + store.getFeatureManager().getDeltaSize();

            return (limit>0 && mySize>limit)? limit:mySize;

        }

        @Override

    public int size() {

        return this.data.getType().size();

    }

    public boolean isEmpty() {

        return false;

    }

    public Iterator<String> iterator() {

        final Iterator<FeatureAttributeDescriptor> x = this.data.getType().iterator();

        return new Iterator<String>() {

            @Override

            public boolean hasNext() {

                return x.hasNext();

            }

            @Override

            public String next() {

                return x.next().getName();

            }

        };

    }

    public boolean containsKey(String key) {

        return this.data.getType().get(key)!=null;

    }

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.SymbolTable;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

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;

/**

 *

 * @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 {

            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 {

            FeatureStore store = feature.getStore();

            FeatureSelection selection = store.getFeatureSelection();

            return selection.isSelected(feature);

        }

    }

    private Feature feature;

    private FeatureType type;

    public DefaultFeatureSymbolTable() {

        super("DAL.FeatureSymbolTable");

        this.addFunction(new FeatureFunction());

        this.addFunction(new FeatureStoreFunction());

        this.addFunction(new IsSelectedFunction());

    }

    public final void addFunction(Function function) {

        if (function == null) {

            throw new IllegalArgumentException("function can't be null");

        }

        this.getFunctions().put(function.name().toUpperCase(), function);

    }

    @Override

    public FeatureSymbolTable clone() throws CloneNotSupportedException {

        DefaultFeatureSymbolTable other = (DefaultFeatureSymbolTable) super.clone();

        return other;

    }

    @Override

    public boolean exists(String name) {

        if (type.get(name) != null) {

            return true;

        }

        return false;

    }

    @Override

    public Object value(String name) {

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

    }

}

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

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorFactory;

/**

 *

 * @author jjdelcerro

 */

public class DefaultEvaluatorFactory implements EvaluatorFactory {

    @Override

    public Evaluator createEvaluator(String phrase) {

        Evaluator e = new DefaultExpressionEvaluator(phrase);

        return e;

    }

    @Override

    public String getName() {

        return "DAL expression evaluator";

    }

}

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

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Function;

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

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

import org.gvsig.tools.evaluator.AbstractEvaluator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

import org.gvsig.tools.evaluator.EvaluatorWithDescriptions;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.gvsig.tools.lang.Cloneable;

public class DefaultExpressionEvaluator 

        extends AbstractEvaluator 

        implements EvaluatorWithDescriptions, Cloneable 

    {

    private static class DescriptionAdapter implements Description {

        Function function;

        public DescriptionAdapter(Function function) {

            this.function = function;

        }

        @Override

        public String getName() {

            return this.function.name();

        }

        @Override

        public String getDescription() {

            return this.function.description();

        }

        @Override

        public String getTemplate() {

            return this.function.template();

        }

        @Override

        public int getDataTypeCategories() {

            switch (this.function.group()) {

                case Function.GROUP_STRING:

                    return Description.DATATYPE_CATEGORY_STRING;

                case Function.GROUP_BOOLEAN:

                    return Description.DATATYPE_CATEGORY_BOOLEAN;

                case Function.GROUP_DATETIME:

                    return Description.DATATYPE_CATEGORY_DATETIME;

                case Function.GROUP_NUMERIC:

                    return Description.DATATYPE_CATEGORY_NUMBER;

                case Function.GROUP_OGC:

                    return Description.DATATYPE_CATEGORY_ALL;

                default:

                    return Description.DATATYPE_CATEGORY_ALL;

            }

        }

    }

    private FeatureSymbolTable featureSymbolTable;

    private Compiler compiler;

    private Interpreter interpreter;

    private Code code;

    private String source;

    private Description[] availableOperators;

    private Description[] availableFunctions;

    public DefaultExpressionEvaluator(String source) {

        this.featureSymbolTable = new DefaultFeatureSymbolTable();

        this.source = source;

    }

    private void compile() {

        this.code = this.compiler.compileExpression(source);

    }

    @Override

    public Object evaluate(EvaluatorData data) throws EvaluatorException {

        if (this.code == null) {

            this.compile();

        }

        Interpreter theInterpreter = this.getInterpreter();

        theInterpreter.getSymbolTable().addSymbolTable(this.featureSymbolTable);

        this.featureSymbolTable.setFeature((Feature) data);

        Object v = this.interpreter.run(code);

        return v;

    }

    @Override

    public String getName() {

        return "Genereric expression";

    }

    @Override

    public EvaluatorFieldsInfo getFieldsInfo() {

        final Set<String> names = new HashSet<>();

        try {

            this.code.accept(new Visitor() {

                @Override

                public void visit(Object code) throws VisitCanceledException, BaseException {

                    if (code instanceof Code.Identifier) {

                        Code.Identifier identifier = (Code.Identifier) code;

                        names.add(identifier.name());

                    }

                }

            });

            EvaluatorFieldsInfo info = new EvaluatorFieldsInfo();

            for (String name : names) {

                info.addFieldValue(name);

            }

            return info;

        } catch (BaseException ex) {

            throw new RuntimeException("Can't calculate fields information.", ex);

        }

    }

    @Override

    public Description[] getAvailableOperators() {

        if (availableOperators == null) {

            List<Description> l = new ArrayList<>();

            for (Function function : getSymbolTable()) {

                if (function.isOperator()) {

                    l.add(new DescriptionAdapter(function));

                }

            }

            this.availableOperators = l.toArray(new Description[l.size()]);

        }

        return availableOperators;

    }

    @Override

    public Description[] getAvailableFunctions() {

        if (availableFunctions == null) {

            List<Description> l = new ArrayList<>();

            for (Function function : getSymbolTable()) {

                if (!function.isOperator()) {

                    l.add(new DescriptionAdapter(function));

                }

            }

            this.availableFunctions = l.toArray(new Description[l.size()]);

        }

        return availableFunctions;

    }

    private SymbolTable getSymbolTable() {

        return this.getInterpreter().getSymbolTable();

    }

    private Interpreter getInterpreter() {

        if (this.interpreter == null) {

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

            this.interpreter = manager.createInterpreter();

            this.interpreter.setAccuracy(ExpressionEvaluatorLocator.getManager().getAccuracy());

        }

        return interpreter;

    }

    @Override

    public Evaluator clone() throws CloneNotSupportedException {

        DefaultExpressionEvaluator other = (DefaultExpressionEvaluator) super.clone();

        other.code = this.code;

        other.source = this.source;

        other.availableFunctions = null;

        other.availableOperators = null;

        if (this.featureSymbolTable != null) {

            // evaluatorData don't support clone.

            other.featureSymbolTable = this.featureSymbolTable.clone();

        }

        if (this.compiler != null) {

            other.compiler = this.compiler.clone();

        }

        if (this.interpreter != null) {

            other.interpreter = this.interpreter.clone();

        }

        return other;

    }

}

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

import org.gvsig.fmap.dal.impl.expressionevaluator.DefaultEvaluatorFactory;

import org.gvsig.fmap.dal.impl.expressionevaluator.DefaultFeatureSymbolTable;

import org.gvsig.tools.evaluator.EvaluatorFactory;

    @Override

    public FeatureSymbolTable createFeatureSymbolTable() {

        FeatureSymbolTable symbolTable = new DefaultFeatureSymbolTable();

        return symbolTable;

    }

    @Override

    public EvaluatorFactory createEvaluatorFactory() {

        EvaluatorFactory f = new DefaultEvaluatorFactory();

        return f;

    }

import org.gvsig.fmap.dal.impl.expressionevaluator.DefaultFeatureSymbolTable;

        DefaultFeatureSymbolTable.selfRegister();

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.swing.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>commons-lang</groupId>

            <artifactId>commons-lang</artifactId>

            <scope>compile</scope>

        </dependency>

import org.gvsig.fmap.dal.swing.impl.expressionevaluator.FeatureStoreElementFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultDALSwingLibrary.class);

        try {

            DynFormSPIManager manager = DynFormSPILocator.getDynFormSPIManager();

            if( manager != null ) {

                    manager.addServiceFactory(new JDynFormFieldFeatureLinkFactory());

                    manager.addServiceFactory(new JDynFormFieldFeaturesTableLinkFactory());

            }

            DynObjectManager dynObjectmanager = ToolsLocator.getDynObjectManager();

            dynObjectmanager.registerDynMethod(new CreateComboModelFromTable("DAL.createComboModelFromTable", "XXXXXXXXXXXXXXXXXXXX."));

            DataStoreParametersPanelManager dataStoreParametersPanelManager = DALSwingLocator.getDataStoreParametersPanelManager();

            dataStoreParametersPanelManager.registerFactory(new DataStoreDynObjectParametersPanelFactory());

        } catch(Exception ex) {

            LOGGER.warn("Can't register DAL components in DynForms",ex);

        try {

            FeatureStoreElementFactory.selfRegister();

        } catch(Exception ex) {

            LOGGER.warn("Can't register DAL components in ExpressionEvaluator",ex);

        }

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

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.swing.Element;

import org.gvsig.expressionevaluator.swing.Element.GroupElement;

import org.gvsig.expressionevaluator.swing.ExpressionBuilderConfig;

import org.gvsig.expressionevaluator.swing.spi.AbstractElement;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

/**

 *

 * @author jjdelcerro

 */

public class FeatureStoreElement 

        extends AbstractElement

        implements GroupElement 

{

    final FeatureStore store;

    final FeatureType type;

    final List<Element> elements;

    final ExpressionBuilderConfig configPanel;

    public FeatureStoreElement(ExpressionBuilderConfig configPanel, FeatureStore store) {

        super(store.getName(), null, "expressionbuilder-element-table");

        this.configPanel = configPanel;

        try {

            this.store = store;

            this.type = this.store.getDefaultFeatureType();

            this.elements = new ArrayList<>();

            for (FeatureAttributeDescriptor attrdesc : type) {

                this.elements.add(new FeatureAttributeElement(

                                this.configPanel,

                                this.store,

                                attrdesc

                        )

                );

            }

            Collections.sort(elements, new Comparator<Element>() {

                @Override

                public int compare(Element o1, Element o2) {

                    return o1.getName().compareTo(o2.getName());

                }

            });

        } catch (DataException ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public Element get(int index) {

        return this.elements.get(index);

    }

    @Override

    public int size() {

        return this.type.size();

    }

    @Override

    public Iterator<Element> iterator() {

        return this.elements.iterator();

    }

    @Override

    public void addElement(Element element) {

    }

    @Override

    public void addElement(Function function) {

    }

    @Override

    public List<Element> getElements() {

        return Collections.unmodifiableList(this.elements);

    }

    @Override

    public boolean hasSubgroups() {

        return true;

    }

    @Override

    public boolean hasMoreElements() {

        return false;

    }

}

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

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.lang.mutable.MutableInt;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.swing.Element;

import org.gvsig.expressionevaluator.swing.Element.GroupElement;

import org.gvsig.expressionevaluator.swing.Element.SimpleElement;

import org.gvsig.expressionevaluator.swing.Element.VariableElement;

import org.gvsig.expressionevaluator.swing.ExpressionBuilderConfig;

import org.gvsig.expressionevaluator.swing.spi.AbstractElement;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

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

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

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

/**

 *

 * @author jjdelcerro

 */

public class FeatureAttributeElement        

        extends AbstractElement

        implements 

            GroupElement,

            SimpleElement,

            VariableElement

{

    final FeatureStore store;

    final FeatureAttributeDescriptor attrdesc;

    List<Element> elements;

    final ExpressionBuilderConfig configPanel;

    boolean hasMoreElements; 

    FeatureAttributeElement(ExpressionBuilderConfig configPanel, FeatureStore store, FeatureAttributeDescriptor attrdesc) {

        super(attrdesc.getName(), attrdesc.getDescription(), "expressionbuilder-element-table-field");

        this.configPanel = configPanel;

        this.store = store;

        this.attrdesc = attrdesc;

        this.elements = null;

        this.hasMoreElements = false;

    }

    @Override

    public String getTypeName() {

        return this.attrdesc.getDataTypeName();

    }

    @Override

    public Element get(int index) {

        return this.getElements().get(index);

    }

    @Override

    public int size() {

        return this.getElements().size();

    }

    @Override

    public Iterator<Element> iterator() {

        return this.getElements().iterator();

    }

    @Override

    public void addElement(Element element) {

    }

    @Override

    public void addElement(Function function) {

    }

    @Override

    public List<Element> getElements() {

        if( this.elements==null ) {

            hasMoreElements = false;

            final int limit = this.configPanel==null? 1000 : this.configPanel.getSimpleElementsLimit();

            ExpressionEvaluatorSwingManager manager = ExpressionEvaluatorSwingLocator.getManager();

            final List<Object> values = new ArrayList<>();

            try {

                FeatureSet set = this.store.getFeatureSet();

                final MutableInt count = new MutableInt(0);

                set.accept(new Visitor() {

                    @Override

                    public void visit(Object o) throws VisitCanceledException, BaseException {

                        Object value = ((Feature)o).get(attrdesc.getName());

                        if( !values.contains(value ) ) {

                            values.add(value);

                        }

                        count.increment();

                        if( count.intValue()>= limit ) {

                            hasMoreElements = true;

                            throw new VisitCanceledException();

                        }

                    }

                });

            } catch(VisitCanceledException ex) {

            } catch (Exception ex) {

                // FIXME

            }

            this.elements = new ArrayList<>();

            for (Object value : values) {

                this.elements.add(manager.createConstantElement(value));

            }

        }

        return this.elements;

    }

    @Override

    public boolean hasSubgroups() {

        return false;

    }

    @Override

    public String getSource() {

        return this.store.getName();

    }

    @Override

    public String getLabel() {

        return "Field";

    }

    @Override

    public boolean hasMoreElements() {

        return this.hasMoreElements;

    }

}

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

import java.net.URL;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.swing.Element;

import org.gvsig.expressionevaluator.swing.ExpressionBuilderConfig;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.expressionevaluator.swing.JExpressionBuilder;

import org.gvsig.expressionevaluator.swing.spi.AbstractElementFactory;

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

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.icontheme.IconTheme;

/**

 *

 * @author jjdelcerro

 */

public class FeatureStoreElementFactory extends AbstractElementFactory {

    public FeatureStoreElementFactory() {

        super("DAL.FeatureStoreElement", null);

    }

    @Override

    public Element createElement(Object... parameters) {

        ExpressionBuilderConfig config = (ExpressionBuilderConfig) parameters[0];

        FeatureStore store = (FeatureStore) parameters[1];

        Element e = new FeatureStoreElement(config, store);

        return e;

    }

    public static void selfRegister() {

        ExpressionEvaluatorSwingManager manager = ExpressionEvaluatorSwingLocator.getManager();

        manager.registerElement(new FeatureStoreElementFactory());

        URL url;

        IconTheme theme = ToolsSwingLocator.getIconThemeManager().getCurrent();

        url = FeatureStoreElementFactory.class.getResource("/org/gvsig/fmap/dal/swing/impl/expressionevaluator/expressionbuilder-element-table.png");

        theme.registerDefault("ExpressionBuilder", "element", "expressionbuilder-element-table", null, url);

        url = FeatureStoreElementFactory.class.getResource("/org/gvsig/fmap/dal/swing/impl/expressionevaluator/expressionbuilder-element-table-field.png");

        theme.registerDefault("ExpressionBuilder", "element", "expressionbuilder-element-table-field", null, url);

    }

}

package org.gvsig.fmap.dal.expressionevaluator;

import org.gvsig.expressionevaluator.SymbolTable;

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

/**

 *

 * @author jjdelcerro

 */

public interface FeatureSymbolTable extends SymbolTable {

    public void setFeature(Feature feature);

    @Override

    public FeatureSymbolTable clone() throws CloneNotSupportedException;

}

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

import org.gvsig.tools.evaluator.EvaluatorFactory;

    public EvaluatorFactory createEvaluatorFactory();

    public FeatureSymbolTable createFeatureSymbolTable();

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.expressionevaluator.lib.api</artifactId>

      <scope>compile</scope>

    </dependency>

            <groupId>commons-lang</groupId>

            <artifactId>commons-lang</artifactId>

            <version>2.6</version>

            <scope>compile</scope>

        </dependency>

        <dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.temporarystorage.lib.api</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.temporarystorage.lib.impl</artifactId>

            <scope>runtime</scope>

        </dependency>

package org.gvsig.h2spatial;