| gvSIG desktop 1

    public boolean areValid() {

        Iterator indexes = this.iterator();

        while (indexes.hasNext()) {

            FeatureIndex index = (FeatureIndex) indexes.next();

            if (!index.isValid()) {

                return false;

            }

        }

        return true;

    }

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

    private FeatureIndex index;

    public DefaultFeatureStoreNotification(DataStore source, String type,

        FeatureIndex index) {

        this.init(source, type);

        this.index = index;

    }

    public FeatureIndex getIndex() {

        return index;

    }

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

        FeatureIndexes indexes = store.getIndexes();

        if (this.queryForProvider.hasFilter() && indexes != null

            && indexes.areValid()) {

            this.provider =

                (FeatureSetProvider) indexes

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.observer.impl.BaseWeakReferencingObservable;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

public class DefaultFeatureIndex extends BaseWeakReferencingObservable

    implements FeatureIndexProviderServices {

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultFeatureIndex.class);

    public synchronized final void fill() throws FeatureIndexException {

        fill(false);

    }

    public void fill(boolean background) throws FeatureIndexException {

        if (background) {

            filling = true;

            Runnable task = new Runnable() {

                public void run() {

                    try {

                        clearAndFill();

                    } catch (DataException e) {

                        LOG.error("Error filling index: " + this, e);

                    }

                }

            };

            Thread thread = new Thread(task, "Fill index data");

            thread.start();

        } else {

            try {

                clearAndFill();

            } catch (DataException e) {

                throw new FeatureIndexException(e);

            }

        }

    }

    /**

     * @throws DataException

     */

    private void clearAndFill() throws DataException {

            filling = true;

            filling = false;

            notify(this, new DefaultFeatureStoreNotification(

                getFeatureStoreProviderServices().getFeatureStore(),

                FeatureStoreNotification.INDEX_FILLED_SUCCESSFULLY, this));

            filling = false;

            setValid(false);

            notify(this, new DefaultFeatureStoreNotification(

                getFeatureStoreProviderServices().getFeatureStore(),

                FeatureStoreNotification.INDEX_FILLING_ERROR, e));

    public synchronized final void insert(FeatureSet data) throws DataException {

        TaskStatusManager statusManager = ToolsLocator.getTaskStatusManager();

        SimpleTaskStatus status =

            statusManager.createDefaultSimpleTaskStatus("Filling index");

        status.setCancellable(false);

        // status.setRangeOfValues(0, data.getSize());

        status.add();

        long counter = 0;

                status.setCurValue(counter++);

        } catch (RuntimeException e) {

            status.abort();

            throw e;

            status.remove();

    public synchronized final void insert(Feature feat) {

    public synchronized final void delete(Feature feat) {

    public synchronized final void delete(FeatureSet data)

        throws FeatureIndexException {

                        "QuadtreeJts", null);

    DataStoreInitializer, FeatureStoreProviderServices, FeatureStore, Observer {

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultFeatureStore.class);

        this.dataManager = (DefaultDataManager) dataManager;

            return new DefaultFeatureProvider(type,

                this.provider.createNewOID());

            throw new PersistenceException(new IllegalStateException(

                this.getName()));

                        throw new PersistenceCantFindFeatureTypeException(

                            this.getName(), (String) entry.getKey());

            definition.addDynFieldObject("parameters")

                .setClassOfValue(DynObject.class).setMandatory(true)

                .setPersistent(true);

            definition.addDynFieldObject("selection")

                .setClassOfValue(FeatureSelection.class).setMandatory(false)

            definition.addDynFieldObject("transforms")

                .setClassOfValue(DefaultFeatureStoreTransforms.class)

                .setMandatory(true).setPersistent(true);

            definition.addDynFieldMap("evaluatedAttributes")

                .setClassOfItems(List.class) // List<DefaultFeatureAttributeDescriptor>

            definition.addDynFieldString("defaultFeatureTypeId")

                .setMandatory(true).setPersistent(true);

            LOG.error("Error notifying about the notification: " + notification

                + ", with the data: " + data, ex);

            LOG.warn("Locks not supporteds");

        setIndexesValidStatus(false);

    private void setIndexesValidStatus(boolean valid) {

    private void updateIndexes() throws FeatureIndexException {

            if (index instanceof FeatureIndexProviderServices) {

                FeatureIndexProviderServices indexServices =

                    (FeatureIndexProviderServices) index;

                indexServices.setValid(false);

                indexServices.fill();

                indexServices.setValid(true);

            updateIndexes();

                updateIndexes();

                        featureManager.getInserted(),

                        featureManager.getUpdated(),

                        featureTypeManager.getFeatureTypesChanged());

                updateIndexes();

        if ((featureQuery.getAttributeNames() != null)

            && (featureQuery.getAttributeNames().length > 0)) {

        Thread thread = new Thread(task, "Load Feature Set in background");

        thread.start();

            new DefaultFeature(this,

                this.provider.getFeatureProviderByReference(

        return createIndex(indexTypeName, featureType, attributeName,

            indexName, false, null);

    }

    public FeatureIndex createIndex(FeatureType featureType,

        String attributeName, String indexName, Observer observer)

        throws DataException {

        return createIndex(null, featureType, attributeName, indexName,

            observer);

    }

    public FeatureIndex createIndex(String indexTypeName,

        FeatureType featureType, String attributeName, String indexName,

        final Observer observer) throws DataException {

        return createIndex(indexTypeName, featureType, attributeName,

            indexName, true, observer);

    }

    private FeatureIndex createIndex(String indexTypeName,

        FeatureType featureType, String attributeName, String indexName,

        boolean background, final Observer observer) throws DataException {

                featureType, indexName,

                featureType.getAttributeDescriptor(attributeName));

        if (observer != null) {

            index.addObserver(observer);

        }

            index.fill(background);

    /**

     * Returns if all the indexes are valid and might be used to get Features.

     * 

     * @return if the indexes are valid

     */

    public boolean areValid();

 *

 * 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 {{Company}}   {{Task}}

 */

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

import org.gvsig.tools.observer.Observable;

 * SPI for all index implementations.

 * 

 * This observable object provides notificationswhen the index has finished

 * filling with data and is available to be used. The observer will

 * receive then a {@link FeatureStoreNotification#INDEX_FILLED_SUCCESSFULLY}

 * notification, with the index object if it has finished

 * successfully, or a {@link FeatureStoreNotification#INDEX_FILLING_ERROR}

 * notification with the exception object if there has been

 * any error in the process.

 * 

 * @see FeatureStoreNotification#INDEX_FILLED_SUCCESSFULLY

 * @see FeatureStoreNotification#INDEX_FILLING_ERROR

 * 

 * @author gvSIG team

public interface FeatureIndexProviderServices extends FeatureIndex, Observable {

    /** Initializes this provider */

    public void initialize() throws InitializeException;

    /** Column to which belongs this index */

    public FeatureAttributeDescriptor getFeatureAttributeDescriptor();

    /** FeatureType to which belongs this index */

    public FeatureType getFeatureType();

    /** FeatureStore to which belongs this index */

    public FeatureStoreProviderServices getFeatureStoreProviderServices();

    /**

     * Returns the absolute path (directory + filename) where this index is or

     * will be stored

     */

    public String getFileName();

    /**

     * Returns a temporary absolute path (directory + filename) according to the

     * system environment

     */

    public String getTemporaryFileName();

    /**

     * Calculates and returns a new filename for an index, using the given

     * prefix and suffix

     */

    public String getNewFileName(String prefix, String sufix);

    /**

     * Fills this index with the store's data. This operation will not return

     * until the index has filled with all the store's data.

     * 

     * @throws FeatureIndexException

     *             if there is an error while filling the index

     */

    public void fill() throws FeatureIndexException;

    /**

     * Fills this index with the store's data.

     * 

     * @param background

     *            if the filling must be performed in background

     * 

     * @throws FeatureIndexException

     *             if there is an error while filling the index

     */

    public void fill(boolean background) throws FeatureIndexException;

    /**

     * Sets the index as valid or invalid, so it may be used or not.

     * 

     * @param valid

     *            status to set the index to

     */

    public void setValid(boolean valid);