Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

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

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.evaluator.AndEvaluator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * Defines the properties of a collection of Features, as a result of a query

 * through a FeatureStore.

 * <p>

 * A FeatureQuery is always defined by a FeatureType, or by the list of

 * attribute names of the FeatureStore to return.

 * </p>

 * <p>

 * The filter allows to select Features whose properties have values with the

 * characteristics defined by the filter.

 * </p>

 * <p>

 * The order is used to set the order of the result FeatureCollection, based on

 * the values of the properties of the Features.

 * </p>

 * <p>

 * The scale parameter can be used by the FeatureStore as a hint about the

 * quality or resolution of the data needed to view or operate with the data

 * returned. As an example, the FeatureStore may use the scale to return only a

 * representative subset of the data, or maybe to return Features with less

 * detail, like a point or a line instead of a polygon.

 * </p>

 * <p>

 * If an implementation of FeatureStore is able to get other parameters to

 * customize the behavior of the getDataCollection methods, there is an option

 * to set more parameters through the setAttribute method.

 * </p>

 *

 * @author 2009- <a href="cordinyana@gvsig.org">C?sar Ordi?ana</a> - gvSIG team

 */

public class DefaultFeatureQuery implements FeatureQuery {

    public static final String SCALE_PARAM_NAME = "Scale";

    private Map queryParameters = new HashMap();

    private String featureTypeId = null;

    private List attributeNames = new ArrayList();

    private List constantsAttributeNames = new ArrayList();

    private Evaluator filter;

    /**

     * This boolean value is used to know if the current filter

     * has been added using the {@link FeatureQuery#addFilter(Evaluator)}

     * method or the {@link FeatureQuery#setFilter(Evaluator)} method.

     */

//    private boolean isAddFilter = true;

    private FeatureQueryOrder order = new FeatureQueryOrder();

    private long limit;

    private long pageSize;

    private boolean group = false;

    /**

     * Creates a FeatureQuery which will load all available Features of a type.

     *

     */

    public DefaultFeatureQuery() {

        super();

    }

    /**

     * Creates a FeatureQuery which will load all available Features of a type.

     *

     * @param featureType

     *            the type of Features of the query

     */

    public DefaultFeatureQuery(FeatureType featureType) {

        super();

        this.setFeatureType(featureType);

    }

    /**

     * Creates a FeatureQuery with the type of features, a filter and the order

     * for the FeatureCollection.

     *

     * @param featureType

     *            the type of Features of the query

     * @param filter

     *            based on the properties of the Features

     */

    public DefaultFeatureQuery(FeatureType featureType, Evaluator filter) {

        super();

        this.setFeatureType(featureType);

        this.filter = filter;

    }

    /**

     * Creates a FeatureQuery with the type of features, a filter, the order for

     * the FeatureCollection and the view scale.

     *

     * @param featureType

     *            the type of Features of the query

     * @param filter

     *            based on the properties of the Features

     * @param scale

     *            to view the Features.

     */

    public DefaultFeatureQuery(FeatureType featureType, Evaluator filter,

        double scale) {

        this.setFeatureType(featureType);

        this.filter = filter;

        this.setScale(scale);

    }

    /**

     * Creates a FeatureQuery which will load a list of attribute names of all

     * available Features.

     *

     * @param attributeNames

     *            the list of attribute names to load

     */

    public DefaultFeatureQuery(String[] attributeNames) {

        super();

        setAttributeNames(attributeNames);

    }

    /**

     * Creates a FeatureQuery with the list of attribute names of feature, a

     * filter and the order for the FeatureCollection.

     *

     * @param attributeNames

     *            the list of attribute names to load

     * @param filter

     *            based on the properties of the Features

     */

    public DefaultFeatureQuery(String[] attributeNames, Evaluator filter) {

        super();

        setAttributeNames(attributeNames);

        this.filter = filter;

    }

    /**

     * Creates a FeatureQuery with the list of attribute names of feature, a

     * filter, the order for the FeatureCollection and the view scale.

     *

     * @param attributeNames

     *            the list of attribute names to load

     * @param filter

     *            based on the properties of the Features

     * @param scale

     *            to view the Features.

     */

    public DefaultFeatureQuery(String[] attributeNames, Evaluator filter,

        double scale) {

        setAttributeNames(attributeNames);

        this.filter = filter;

        this.setScale(scale);

    }

    @Override

    public double getScale() {

        Double scale = (Double) this.getQueryParameter(SCALE_PARAM_NAME);

        if (scale == null) {

            return 0;

        }

        return scale;

    }

    @Override

    public void setScale(double scale) {

        this.setQueryParameter(SCALE_PARAM_NAME, scale);

    }

    @Override

    public Object getQueryParameter(String name) {

        return queryParameters.get(name);

    }

    @Override

    public void setQueryParameter(String name, Object value) {

        queryParameters.put(name, value);

    }

    @Override

    public void setFeatureType(FeatureType featureType) {

        this.featureTypeId = featureType.getId();

    }

    @Override

    public String[] getAttributeNames() {

        return (String[])attributeNames.toArray(new String[attributeNames.size()]);

    }

    @Override

    public void setAttributeNames(String[] attributeNames) {

        this.attributeNames.clear();

        if (attributeNames != null){

            for (int i=0 ; i<attributeNames.length ; i++){

                this.attributeNames.add(attributeNames[i]);

            }

        }

    }

    @Override

    public void retrievesAllAttributes() {

        this.attributeNames.clear();

    } 

    @Override

    public void addAttributeName(String attributeName){

        //If the attribute exists finish the method

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

            if (attributeNames.get(i).equals(attributeName)){

                return;

            }

        }

        this.attributeNames.add(attributeName);

    }

    @Override

    public void addEssentialAttributeNames(FeatureStore store) {

        FeatureType storeType;

        try {

            storeType = store.getDefaultFeatureType();

        } catch (DataException ex) {

            throw new RuntimeException("Can't access to the default feature type of tghe store", ex);

        }

        FeatureAttributeDescriptor[] pks = storeType.getPrimaryKey();

        if( storeType.hasOID() || ArrayUtils.isEmpty(pks) ) {

            FeatureAttributeDescriptor attrInt = null;

            FeatureAttributeDescriptor attrStr = null;

            FeatureAttributeDescriptor attrNotGeom = null;

            for (FeatureAttributeDescriptor attr : storeType) {

                if( attrInt == null && (attr.getType()==DataTypes.INT || attr.getType()==DataTypes.LONG) ) {

                    attrInt = attr;

                } else if( attrStr == null && attr.getType()==DataTypes.STRING ) {

                    attrStr = attr;

                } else if( attrNotGeom == null && attr.getType()!=DataTypes.GEOMETRY ) {

                    attrNotGeom = attr;

                }

            }

            if( attrInt != null ) {

                this.addAttributeName(attrInt.getName());

            } else if( attrStr != null ) {

                this.addAttributeName(attrStr.getName());

            } else if( attrNotGeom != null ) {

                this.addAttributeName(attrNotGeom.getName());

            } else {

                this.addAttributeName(storeType.getAttributeDescriptor(0).getName());

            }

        } else {

            for(FeatureAttributeDescriptor attr : pks ) {

                this.addAttributeName(attr.getName());

            }

        }

    }

    @Override

    public void addPrimaryKeyAttributeNames(FeatureStore store) {

        FeatureType storeType;

        try {

            storeType = store.getDefaultFeatureType();

        } catch (DataException ex) {

            throw new RuntimeException("Can't access to the default feature type of tghe store", ex);

        }

        for(FeatureAttributeDescriptor attr : storeType.getPrimaryKey() ) {

            this.addAttributeName(attr.getName());

        }

    }

    @Override

    public boolean hasAttributeNames() {

        return !this.attributeNames.isEmpty();

    }

    @Override

    public void clearAttributeNames() {

        this.attributeNames = new ArrayList();

    }

    @Override

    public Evaluator getFilter() {

        return filter;

    }

    @Override

    public void setFilter(Expression filter) {

        if( filter == null ) {

            this.clearFilter();

            return;

        }

        Evaluator x = new DefaultExpressionEvaluator(filter);

        this.setFilter(x);

    }

   @Override

    public void setFilter(String filter) {

        if( StringUtils.isEmpty(filter) ) {

            this.clearFilter();

            return;

        }

        try {

            this.setFilter(DALLocator.getDataManager().createExpresion(filter));

        } catch (Exception ex) {

            throw new RuntimeException("Can't create filter from '"+filter+"'",ex);

        }

    }

    @Override

    public void setFilter(Evaluator filter) {

        if( filter == null ) {

            this.clearFilter();

            return;

        }        

        this.filter = filter;

        addFilterAttributes(filter);

    }

    @Override

    public void addFilter(String filter) {

        if( StringUtils.isEmpty(filter) ) {

            return;

        }

        try {

            this.addFilter(DALLocator.getDataManager().createExpresion(filter));

        } catch (Exception ex) {

            throw new RuntimeException("Can't create filter from '"+filter+"'",ex);

        }

    }

    @Override

    public void addFilter(Expression filter) {

        Evaluator x = new DefaultExpressionEvaluator(filter);

        this.addFilter(x);

    }

    @Override

    public void addFilter(Evaluator evaluator) {

        if (evaluator == null) {

            return;

        }

        if (this.filter == null) {

            this.filter = evaluator;

        } else {

            if (this.filter instanceof AndEvaluator) {

                ((AndEvaluator) this.filter).addEvaluator(evaluator);

            } else {

                this.filter = new AndEvaluator(this.filter);

                ((AndEvaluator) this.filter).addEvaluator(evaluator);

            }

        }

        addFilterAttributes(evaluator);

    }

    @Override

    public void clearFilter() {

      this.filter = null;

    }

    private void addFilterAttributes(Evaluator evaluator){

        if (evaluator != null){

            EvaluatorFieldsInfo fieldsInfo = evaluator.getFieldsInfo();

            if (fieldsInfo == null){

                // FieldsInfo is not available in this evaluator

                return;

            }

            String[] fieldNames = fieldsInfo.getFieldNames();

            if (fieldNames== null){

                // fieldNames is not available in this evaluator

                return;

            }

            for (int i=0 ; i<fieldNames.length ; i++){

                addAttributeName(fieldNames[i]);

            }

        }

    }

    @Override

    public FeatureQueryOrder getOrder() {

        return order;

    }

    @Override

    public void setOrder(FeatureQueryOrder order) {

        this.order = order;

    }

    @Override

    public boolean hasFilter() {

        return this.filter != null;

    }

    @Override

    public boolean hasOrder() {

        return this.order != null && this.order.size() > 0;

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        DefaultFeatureQuery clone = (DefaultFeatureQuery) super.clone();

        // Clone attribute names array

        if (attributeNames != null) {

            clone.attributeNames = new ArrayList();

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

                clone.attributeNames.add(attributeNames.get(i));

            }

        }

        // Clone order

        if (order != null) {

            clone.order = (FeatureQueryOrder) order.clone();

        }

        return clone;

    }

    @Override

    public FeatureQuery getCopy() {

        try {

            return (FeatureQuery) clone();

        } catch (CloneNotSupportedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

            return null;

        }

        // DefaultFeatureQuery aCopy = new DefaultFeatureQuery();

        //

        // aCopy.featureTypeId = this.featureTypeId;

        //

        // if (this.attributeNames != null) {

        // aCopy.attributeNames = (String[]) Arrays

        // .asList(this.attributeNames).toArray(new String[0]);

        // }

        //

        // aCopy.filter = this.filter;

        //

        // if (this.order != null) {

        // aCopy.order = this.order.getCopy();

        // }

        //

        // return aCopy;

    }

    @Override

    public String getFeatureTypeId() {

        return featureTypeId;

    }

    @Override

    public void setFeatureTypeId(String featureTypeId) {

        this.featureTypeId = featureTypeId;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // FIXME: falta por terminar de implementar

        state.set("queryParameters", this.queryParameters);

        state.set("featureTypeId", this.featureTypeId);

        state.set("attributeNames", this.attributeNames);

        // state.set("filter", this.filter);

        state.set("limit", this.limit);

        state.set("pageSize", this.pageSize);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        // FIXME: falta por terminar de implementar

        this.queryParameters = (Map) state.get("queryParameters");

        this.featureTypeId = state.getString("featureTypeId");

        this.attributeNames = state.getList("attributeNames");

        this.filter = (Evaluator) state.get("filter");

        this.limit = state.getLong("limit");

        this.pageSize = state.getLong("pageSize");

    }

    /**

     * Register the class on PersistenceManager

     *

     */

    public static void registerPersistent() {

        DynStruct definition =

            ToolsLocator.getPersistenceManager()

            .addDefinition(DefaultFeatureQuery.class,

                "DefaultFeatureQuery",

                "DefaultFeatureQuery Persistent definition",

                null,

                null);

        definition.addDynFieldMap("queryParameters")

        .setClassOfItems(Object.class)

        .setMandatory(true);

        definition.addDynFieldString("featureTypeId").setMandatory(false);

        definition.addDynFieldList("attributeNames")

        .setClassOfItems(String.class)

        .setMandatory(false);

        definition.addDynFieldObject("filter")

        .setClassOfValue(Evaluator.class)

        .setMandatory(false);

        definition.addDynFieldObject("order")

        .setClassOfValue(FeatureQueryOrder.class)

        .setMandatory(false);

        definition.addDynFieldLong("limit").setMandatory(false);

        definition.addDynFieldLong("pageSize").setMandatory(false);

    }

    @Override

    public long getLimit() {

        return limit;

    }

    @Override

    public long getPageSize() {

        return pageSize;

    }

    @Override

    public void setLimit(long limit) {

        this.limit = limit;

    }

    @Override

    public void setPageSize(long pageSize) {

        this.pageSize = pageSize;

    }

    @Override

    public String[] getConstantsAttributeNames() {

        return (String[])constantsAttributeNames.toArray(new String[constantsAttributeNames.size()]);

    }

    @Override

    public void setConstantsAttributeNames(String[] constantsAttributeNames) {

        this.constantsAttributeNames.clear();

        if (constantsAttributeNames != null){

            for (int i=0 ; i<constantsAttributeNames.length ; i++){

                this.constantsAttributeNames.add(constantsAttributeNames[i]);

            }

        }

    }

    @Override

    public void addConstantAttributeName(String attributeName) {

        //If the attribute exists finish the method

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

            if (constantsAttributeNames.get(i).equals(attributeName)){

                return;

            }

        }

        this.constantsAttributeNames.add(attributeName);

    }

    @Override

    public boolean hasConstantsAttributeNames() {

        return !this.constantsAttributeNames.isEmpty();

    }

    @Override

    public void clearConstantsAttributeNames() {

        this.constantsAttributeNames = new ArrayList();

    }

    @Override

    public boolean isGrouped() {

        return this.group;

    }

    @Override

    public void setGroup(boolean group) {

        this.group = group;

    }

}