Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Gobernment (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}  {Implement data selection}

 */

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

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.data.DataStoreNotification;

import org.gvsig.fmap.data.exceptions.DataException;

import org.gvsig.fmap.data.feature.*;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default implementation of the FeatureSelection interface. Internally, only

 * FeatureReference values are stored.

 * 

 * This implementation performs better if used with the selection related

 * methods: select, deselect and isSelected ones.

 * 

 * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>

 */

public class DefaultFeatureSelection extends DefaultFeatureReferenceSelection

        implements FeatureSelection {

    final Logger logger = LoggerFactory

            .getLogger(DefaultFeatureSelection.class);

    /**

     * Creates a DefaultFeatureSelection, with a FeatureStore.

     * 

     * @param featureStore

     *            the FeatureStore to load Features from

     * 

     * @see AbstractSetBasedDataSelection#DefaultSelection(int)

     */

    public DefaultFeatureSelection(FeatureStore featureStore) {

        super(featureStore);

    }

    /**

     * Creates a DefaultFeatureSelection, with a FeatureStore.

     * 

     * @param featureStore

     *            the FeatureStore to load Features from

     * @param totalSize

     *            the maximum number of Features that may be selected

     */

    public DefaultFeatureSelection(FeatureStore featureStore, long totalSize) {

        super(featureStore, totalSize);

    }

    public boolean select(Feature feature) {

        if (feature == null) {

            return false;

        }

        return select(feature.getReference());

    }

    public boolean select(FeatureSet features) throws DataException {

        // TODO: verificar si las features son del mismo FeatureStore

        boolean change = false;

        disableNotifications();

        for (Iterator iter = features.fastIterator(); iter.hasNext();) {

            change |= select((Feature) iter.next());

        }

        enableNotifications();

        if (change) {

            notifyObservers(DataStoreNotification.SELECTION_CHANGE);

        }

        return change;

    }

    public boolean deselect(Feature feature) {

        if (feature == null) {

            return false;

        }

        return deselect(feature.getReference());

    }

    public boolean deselect(FeatureSet features) throws DataException {

        // TODO: verificar si las features son del mismo FeatureStore

        boolean change = false;

        disableNotifications();

        for (Iterator iter = features.fastIterator(); iter.hasNext();) {

            change |= deselect((Feature) iter.next());

        }

        enableNotifications();

        if (change) {

            notifyObservers(DataStoreNotification.SELECTION_CHANGE);

        }

        return change;

    }

    public boolean isSelected(Feature feature) {

        if (feature == null) {

            return false;

        }

        return isSelected(feature.getReference());

    }

    public FeatureType getDefaultFeatureType() {

        try {

            return getFeatureStore().getDefaultFeatureType();

        } catch (DataException ex) {

            logger.error("Error getting the default feature type "

                    + "of the FeatureStore: " + getFeatureStore(), ex);

        }

        return null;

    }

    public List getFeatureTypes() {

        // TODO: implement

        throw new UnsupportedOperationException("Not implemented");

    }

    public long getSize() throws DataException {

        return getSelectedCount();

    }

    public boolean isEmpty() throws DataException {

        return getSelectedCount() == 0;

    }

    /**

     * Returns the list of selected values, or the deselected ones if the

     * selection has been reversed.

     */

    public Iterator iterator() {

        return iterator(0);

    }

    /**

     * Returns the list of selected values, or the deselected ones if the

     * selection has been reversed.

     * 

     * WARN: not very good performance implementation.

     */

    public Iterator iterator(long index) {

        // TODO: evaluar la opci?n de obtener las features

        // mediante una query al FeatureStore.

        Iterator iter = referenceIterator();

        for (long l = 0; l < index; l++) {

            iter.next();

        }

        return new FeatureIteratorFacade(iter);

    }

    /**

     * Returns the list of selected values, or the deselected ones if the

     * selection has been reversed.

     * 

     * WARN: not really a fast implementation.

     */

    public Iterator fastIterator() {

        return fastIterator(0);

    }

    /**

     * Returns the list of selected values, or the deselected ones if the

     * selection has been reversed.

     * 

     * WARN: not really a fast implementation.

     */

    public Iterator fastIterator(long index) {

        return iterator(index);

    }

   /**

     * Facade over a Iterator of FeatureReferences, to return Features instead.

     * 

     * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>

     */

    public class FeatureIteratorFacade implements Iterator {

        final Logger logger = LoggerFactory

                .getLogger(FeatureIteratorFacade.class);

        private Iterator refIterator;

        public FeatureIteratorFacade(Iterator refIterator) {

            this.refIterator = refIterator;

        }

        public boolean hasNext() {

            return refIterator.hasNext();

        }

        public Object next() {

            FeatureReference ref = nextFeatureReference();

            try {

                return getFeature(ref);

            } catch (DataException ex) {

                logger.error(

                        "Error loading the Feature with FeatureReference: "

                                + ref, ex);

                return null;

            }

        }

        /**

         * Returns the next FeatureReference.

         * 

         * @return the next FeatureReference

         */

        public FeatureReference nextFeatureReference() {

            return (FeatureReference) refIterator.next();

        }

        public void remove() {

            refIterator.remove();

        }

        /**

         * Returns a Feature for the FeatureReference.

         */

        protected Feature getFeature(FeatureReference ref) throws DataException {

            return ref.getFeature();

        }

    }

}