Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* 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 2

* 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.

*

*/

/*

 * AUTHORS (In addition to CIT):

 * 2008 {DiSiD Technologies}  {Create Parameter object to define FeatureCollections queries}

 */

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

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.evaluator.Evaluator;

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 String[] attributeNames;

    private Evaluator filter;

    private FeatureQueryOrder order = new FeatureQueryOrder();

        private long limit;

        private long pageSize;

    /**

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

     *

     * @param featureType

     *            the type of Features of the query

     */

    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

     * @param order

     *            for the result

     */

    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 order

     *            for the result

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

        this.attributeNames = 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

         * @param order

         *            for the result

         */

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

        super();

        this.attributeNames = 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 order

         *            for the result

         * @param scale

         *            to view the Features.

         */

    public DefaultFeatureQuery(String[] attributeNames, Evaluator filter,

            double scale) {

        this.attributeNames = attributeNames;

        this.filter = filter;

        this.setScale(scale);

    }

        public double getScale() {

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

                if (scale == null) {

                        return 0;

                }

                return scale.doubleValue();

        }

        public void setScale(double scale) {

                this.setQueryParameter(SCALE_PARAM_NAME, new Double(scale));

        }

        public Object getQueryParameter(String name) {

                return queryParameters.get(name);

        }

        public void setQueryParameter(String name, Object value) {

                queryParameters.put(name, value);

        }

    public void setFeatureType(FeatureType featureType) {

        this.featureTypeId = featureType.getId();

        Iterator iter = featureType.iterator();

                String attrs[] = new String[featureType.size()];

                FeatureAttributeDescriptor attr;

                int i = 0;

                while (iter.hasNext()) {

                        attr = (FeatureAttributeDescriptor) iter.next();

                        attrs[i] = attr.getName();

                        i++;

                }

                this.attributeNames = attrs;

    }

    public String[] getAttributeNames() {

                return attributeNames;

    }

    public void setAttributeNames(String[] attributeNames) {

                this.attributeNames = attributeNames;

    }

    public Evaluator getFilter() {

        return filter;

    }

    public void setFilter(Evaluator filter) {

        this.filter = filter;

    }

    public FeatureQueryOrder getOrder() {

        return order;

    }

        public void setOrder(FeatureQueryOrder order) {

                this.order = order;

        }

        public boolean hasFilter() {

                return this.filter != null;

        }

        public boolean hasOrder() {

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

        }

        public Object clone() throws CloneNotSupportedException {

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

                // Clone attribute names array

                if (attributeNames != null) {

                clone.attributeNames = new String[attributeNames.length];

                System.arraycopy(attributeNames, 0, clone.attributeNames, 0,

                                attributeNames.length);

                }

                // Clone order

                if (order != null) {

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

                }

                return clone;

        }

        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;

        }

        public String getFeatureTypeId() {

                return featureTypeId;

        }

        public void setFeatureTypeId(String featureTypeId) {

                this.featureTypeId = featureTypeId;

        }

        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", Arrays.asList(this.attributeNames));

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

        }

        public void loadFromState(PersistentState state) throws PersistenceException {

                // FIXME: falta por terminar de implementar

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

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

                List attrNames = (List) state.get("attributeNames");

                if (attrNames == null) {

                        this.attributeNames = null;

                } else {

                        this.attributeNames = (String[]) attrNames

                                        .toArray(new String[attrNames.size()]);

                }

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

        }

        /**

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

                definition.addDynFieldList("attributeNames")

                        .setClassOfItems(String.class)

                        .setMandatory(true);

                definition.addDynFieldObject("filter")

                        .setClassOfValue(Evaluator.class)

                        .setMandatory(true);

        }

        public long getLimit() {

                return limit;

        }

        public long getPageSize() {

                return pageSize;

        }

        public void setLimit(long limit) {

                this.limit = limit;

        }

        public void setPageSize(long pageSize) {

                this.pageSize = pageSize;

        }

}