| gvSIG desktop 1

/* 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 IVER T.I. S.A.   {{Task}}

 */

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

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataQuery;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataSet;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.AlreadyEditingException;

import org.gvsig.fmap.dal.feature.exception.ConcurrentDataModificationException;

import org.gvsig.fmap.dal.feature.exception.CreateFeatureException;

import org.gvsig.fmap.dal.feature.exception.DataExportException;

import org.gvsig.fmap.dal.feature.exception.FeatureIndexException;

import org.gvsig.fmap.dal.feature.exception.FinishEditingException;

import org.gvsig.fmap.dal.feature.exception.GetFeatureTypeException;

import org.gvsig.fmap.dal.feature.exception.IllegalFeatureException;

import org.gvsig.fmap.dal.feature.exception.IllegalFeatureTypeException;

import org.gvsig.fmap.dal.feature.exception.NeedEditingModeException;

import org.gvsig.fmap.dal.feature.exception.NoNewFeatureInsertException;

import org.gvsig.fmap.dal.feature.exception.NullFeatureTypeException;

import org.gvsig.fmap.dal.feature.exception.PersistenceCantFindDefaultFeatureTypeException;

import org.gvsig.fmap.dal.feature.exception.PersistenceCantFindFeatureTypeException;

import org.gvsig.fmap.dal.feature.exception.PersistenceStoreAlreadyLoadedException;

import org.gvsig.fmap.dal.feature.exception.SelectionNotAllowedException;

import org.gvsig.fmap.dal.feature.exception.StoreCancelEditingException;

import org.gvsig.fmap.dal.feature.exception.StoreDeleteEditableFeatureException;

import org.gvsig.fmap.dal.feature.exception.StoreDeleteFeatureException;

import org.gvsig.fmap.dal.feature.exception.StoreEditException;

import org.gvsig.fmap.dal.feature.exception.StoreInsertFeatureException;

import org.gvsig.fmap.dal.feature.exception.StoreUpdateFeatureException;

import org.gvsig.fmap.dal.feature.exception.StoreUpdateFeatureTypeException;

import org.gvsig.fmap.dal.feature.exception.ValidateFeaturesException;

import org.gvsig.fmap.dal.feature.exception.WriteNotAllowedException;

import org.gvsig.fmap.dal.feature.impl.expansionadapter.MemoryExpansionAdapter;

import org.gvsig.fmap.dal.feature.impl.featureset.DefaultFeatureSet;

import org.gvsig.fmap.dal.feature.impl.undo.DefaultFeatureCommandsStack;

import org.gvsig.fmap.dal.feature.impl.undo.FeatureCommandsStack;

import org.gvsig.fmap.dal.feature.spi.DefaultFeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices;

import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProvider;

import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProviderServices;

import org.gvsig.fmap.dal.impl.DefaultDataManager;

import org.gvsig.fmap.dal.resource.Resource;

import org.gvsig.fmap.dal.spi.DataStoreInitializer;

import org.gvsig.fmap.dal.spi.DataStoreProvider;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.exception.NotYetImplemented;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

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

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.undo.RedoException;

import org.gvsig.tools.undo.UndoException;

import org.gvsig.tools.undo.command.Command;

import org.gvsig.tools.visitor.Visitor;

public final class DefaultFeatureStore extends AbstractDisposable implements

    DataStoreInitializer, FeatureStoreProviderServices, FeatureStore, Observer {

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultFeatureStore.class);

    private static final String PERSISTENCE_DEFINITION_NAME = "FeatureStore";

    private DataStoreParameters parameters = null;

    private FeatureSelection selection;

    private FeatureLocks locks;

    private DelegateWeakReferencingObservable delegateObservable =

        new DelegateWeakReferencingObservable(this);

    private FeatureCommandsStack commands;

    private FeatureTypeManager featureTypeManager;

    private FeatureManager featureManager;

    private SpatialManager spatialManager;

    private FeatureType defaultFeatureType = null;

    private List featureTypes = new ArrayList();

    private int mode = MODE_QUERY;

    private long versionOfUpdate = 0;

    private boolean hasStrongChanges = true;

    private boolean hasInserts = true;

    private DefaultDataManager dataManager = null;

    private FeatureStoreProvider provider = null;

    private DefaultFeatureIndexes indexes;

    private DefaultFeatureStoreTransforms transforms;

    private DelegatedDynObject metadata;

    private Set metadataChildren;

    private Long featureCount = null;

    private long temporalOid = 0;

    private FeatureCacheProvider cache;

    /*

     * TODO:

     * 

     * - Comprobar que solo se pueden a�adir reglas de validacion sobre un

     * EditableFeatureType. - Comprobar que solo se puede hacer un update con un

     * featureType al que se le han cambiado las reglas de validacion cuando

     * hasStrongChanges=false.

     */

    public DefaultFeatureStore() {

    }

    public void intializePhase1(DataManager dataManager,

        DataStoreParameters parameters) throws InitializeException {

        DynObjectManager dynManager = ToolsLocator.getDynObjectManager();

        this.metadata =

            (DelegatedDynObject) dynManager.createDynObject(

                METADATA_DEFINITION_NAME, MetadataManager.METADATA_NAMESPACE);

        this.dataManager = (DefaultDataManager) dataManager;

        this.parameters = parameters;

        this.transforms = new DefaultFeatureStoreTransforms(this);

        try {

            indexes = new DefaultFeatureIndexes(this);

        } catch (DataException e) {

            throw new InitializeException(e);

        }

    }

    public void intializePhase2(DataStoreProvider provider) {

        this.provider = (FeatureStoreProvider) provider;

        this.delegate(provider);

        this.metadataChildren = new HashSet();

        this.metadataChildren.add(provider);

    }

    public DataStoreParameters getParameters() {

        return parameters;

    }

    public int getMode() {

        return this.mode;

    }

    public DataManager getManager() {

        return this.dataManager;

    }

    public Iterator getChildren() {

        return this.provider.getChilds();

    }

    public FeatureStoreProvider getProvider() {

        return this.provider;

    }

    public FeatureManager getFeatureManager() {

        return this.featureManager;

    }

    public void setFeatureTypes(List types, FeatureType defaultType) {

        this.featureTypes = types;

        this.defaultFeatureType = defaultType;

    }

    public void open() throws OpenException {

        // TODO: Se puede hacer un open estando en edicion ?

        this.notifyChange(DataStoreNotification.BEFORE_OPEN);

        this.provider.open();

        this.notifyChange(DataStoreNotification.AFTER_OPEN);

    }

    public void refresh() throws OpenException, InitializeException {

        if (this.mode != MODE_QUERY) {

            throw new IllegalStateException();

        }

        this.notifyChange(FeatureStoreNotification.BEFORE_REFRESH);

        this.featureCount = null;

        this.provider.refresh();

        this.notifyChange(FeatureStoreNotification.AFTER_REFRESH);

    }

    public void close() throws CloseException {

        // TODO: Se puede hacer un close estando en edicion ?

        this.notifyChange(DataStoreNotification.BEFORE_CLOSE);

        this.featureCount = null;

        this.provider.close();

        this.notifyChange(DataStoreNotification.AFTER_CLOSE);

    }

    protected void doDispose() throws BaseException {

        this.notifyChange(DataStoreNotification.BEFORE_DISPOSE);

        this.provider.dispose();

        if (this.selection != null) {

            this.selection.dispose();

            this.selection = null;

        }

        this.commands = null;

        this.featureCount = null;

        if (this.locks != null) {

            // this.locks.dispose();

            this.locks = null;

        }

        if (this.featureTypeManager != null) {

            this.featureTypeManager.dispose();

            this.featureTypeManager = null;

        }

        this.featureManager = null;

        this.spatialManager = null;

        this.parameters = null;

        this.notifyChange(DataStoreNotification.AFTER_DISPOSE);

        if (delegateObservable != null) {

            this.delegateObservable.deleteObservers();

            this.delegateObservable = null;

        }

    }

    public boolean allowWrite() {

        return this.provider.allowWrite();

    }

    public boolean canWriteGeometry(int geometryType) throws DataException {

        return this.provider.canWriteGeometry(geometryType, 0);

    }

    public DataServerExplorer getExplorer() throws ReadException,

        ValidateDataParametersException {

        return this.provider.getExplorer();

    }

    /*

     * public Metadata getMetadata() throws MetadataNotFoundException {

     * // TODO:

     * // Si el provider devuelbe null habria que ver de construir aqui

     * // los metadatos basicos, como el Envelope y el SRS.

     * 

     * // TODO: Estando en edicion el Envelope deberia de

     * // actualizarse usando el spatialManager

     * return this.provider.getMetadata();

     * }

     */

    public Envelope getEnvelope() throws DataException {

        if (this.mode == MODE_FULLEDIT) {

            return this.spatialManager.getEnvelope();

        }

        return this.provider.getEnvelope();

    }

    /**

     * @deprecated use getDefaultFeatureType().getDefaultSRS()

     */

    public IProjection getSRSDefaultGeometry() throws DataException {

        return this.getDefaultFeatureType().getDefaultSRS();

    }

    public FeatureSelection createDefaultFeatureSelection()

        throws DataException {

        return new DefaultFeatureSelection(this);

    }

    public FeatureProvider createDefaultFeatureProvider(FeatureType type)

        throws DataException {

        if (type.hasOID()) {

            return new DefaultFeatureProvider(type,

                this.provider.createNewOID());

        }

        return new DefaultFeatureProvider(type);

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        if (this.mode != FeatureStore.MODE_QUERY) {

            throw new PersistenceException(new IllegalStateException(

                this.getName()));

        }

        state.set("dataStoreName", this.getName());

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

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

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

        // TODO locks persistence

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

        // TODO indexes persistence

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

        Map evaluatedAttr = new HashMap(1);

        Iterator iterType = featureTypes.iterator();

        Iterator iterAttr;

        FeatureType type;

        DefaultFeatureAttributeDescriptor attr;

        List attrs;

        while (iterType.hasNext()) {

            type = (FeatureType) iterType.next();

            attrs = new ArrayList();

            iterAttr = type.iterator();

            while (iterAttr.hasNext()) {

                attr = (DefaultFeatureAttributeDescriptor) iterAttr.next();

                if ((attr.getEvaluator() != null)

                    && (attr.getEvaluator() instanceof Persistent)) {

                    attrs.add(attr);

                }

            }

            if (!attrs.isEmpty()) {

                evaluatedAttr.put(type.getId(), attrs);

            }

        }

        if (evaluatedAttr.isEmpty()) {

            evaluatedAttr = null;

        }

        state.set("evaluatedAttributes", evaluatedAttr);

        state.set("defaultFeatureTypeId", defaultFeatureType.getId());

    }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        if (this.provider != null) {

            throw new PersistenceStoreAlreadyLoadedException(this.getName());

        }

        if (this.getManager() == null) {

            this.dataManager = (DefaultDataManager) DALLocator.getDataManager();

        }

        DataStoreParameters params =

            (DataStoreParameters) state.get("parameters");

        try {

            this.dataManager.intializeDataStore(this, params);

            this.selection = (FeatureSelection) state.get("selection");

            this.transforms =

                (DefaultFeatureStoreTransforms) state.get("transforms");

            Map evaluatedAttributes = (Map) state.get("evaluatedAttributes");

            if ((evaluatedAttributes != null) && !evaluatedAttributes.isEmpty()) {

                List attrs;

                Iterator iterEntries =

                    evaluatedAttributes.entrySet().iterator();

                Entry entry;

                while (iterEntries.hasNext()) {

                    entry = (Entry) iterEntries.next();

                    attrs = (List) entry.getValue();

                    if (attrs.isEmpty()) {

                        continue;

                    }

                    int fTypePos = -1;

                    DefaultFeatureType type = null;

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

                        type = (DefaultFeatureType) featureTypes.get(i);

                        if (type.getId().equals(entry.getKey())) {

                            fTypePos = i;

                            break;

                        }

                    }

                    if (fTypePos < 0) {

                        throw new PersistenceCantFindFeatureTypeException(

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

                    }

                    DefaultEditableFeatureType eType =

                        (DefaultEditableFeatureType) type.getEditable();

                    Iterator iterAttr = attrs.iterator();

                    FeatureAttributeDescriptor attr;

                    while (iterAttr.hasNext()) {

                        attr = (FeatureAttributeDescriptor) iterAttr.next();

                        eType.addLike(attr);

                    }

                    featureTypes.set(fTypePos, eType.getNotEditableCopy());

                }

            }

            String defFTypeid = state.getString("defaultFeatureTypeId");

            FeatureType ftype = null;

            if (!this.defaultFeatureType.getId().equals(

                state.getString("defaultFeatureTypeId"))) {

                ftype = getFeatureType(defFTypeid);

                if (ftype == null) {

                    throw new PersistenceCantFindDefaultFeatureTypeException(

                        this.getName(), defFTypeid);

                }

                this.defaultFeatureType = ftype;

            }

        } catch (InitializeException e) {

            throw new PersistenceException(e);

        } catch (DataException e) {

            throw new PersistenceException(e);

        }

    }

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(PERSISTENCE_DEFINITION_NAME) == null) {

            DynStruct definition =

                manager.addDefinition(DefaultFeatureStore.class,

                    PERSISTENCE_DEFINITION_NAME, PERSISTENCE_DEFINITION_NAME

                        + " Persistent definition", null, null);

            definition.addDynFieldString("dataStoreName").setMandatory(true)

                .setPersistent(true);

            definition.addDynFieldObject("parameters")

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

                .setPersistent(true);

            definition.addDynFieldObject("selection")

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

                .setPersistent(true);

            definition.addDynFieldObject("transforms")

                .setClassOfValue(DefaultFeatureStoreTransforms.class)

                .setMandatory(true).setPersistent(true);

            definition.addDynFieldMap("evaluatedAttributes")

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

                .setMandatory(false).setPersistent(true);

            definition.addDynFieldString("defaultFeatureTypeId")

                .setMandatory(true).setPersistent(true);

        }

    }

    public static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

        if (manager.getDefinition(METADATA_DEFINITION_NAME) == null) {

            DynStruct metadataDefinition =

                manager.addDefinition(METADATA_DEFINITION_NAME, null);

            metadataDefinition.extend(manager

                .getDefinition(DataStore.METADATA_DEFINITION_NAME));

        }

    }

    //

    // ====================================================================

    // Gestion de la seleccion

    //

    public void setSelection(DataSet selection) throws DataException {

        this.setSelection((FeatureSet) selection);

    }

    public DataSet createSelection() throws DataException {

        return createFeatureSelection();

    }

    public DataSet getSelection() throws DataException {

        return this.getFeatureSelection();

    }

    public void setSelection(FeatureSet selection) throws DataException {

        setSelection(selection, true);

    }

    /**

     * @see #setSelection(FeatureSet)

     * @param undoable

     *            if the action must be undoable

     */

    public void setSelection(FeatureSet selection, boolean undoable)

        throws DataException {

        if (selection == null) {

            if (undoable) {

                throw new SelectionNotAllowedException(getName());

            }

        } else {

            if (selection.equals(this.selection)) {

                return;

            }

            if (!selection.isFromStore(this)) {

                throw new SelectionNotAllowedException(getName());

            }

        }

        if (this.selection != null) {

            this.selection.deleteObserver(this);

        }

        if (selection == null) {

            if (this.selection != null) {

                this.selection.dispose();

            }

            this.selection = null;

            return;

        }

        if (selection instanceof FeatureSelection) {

            if (undoable && isEditing()) {

                commands.selectionSet(this, this.selection,

                    (FeatureSelection) selection);

            }

            if (this.selection != null) {

                this.selection.dispose();

            }

            this.selection = (FeatureSelection) selection;

        } else {

            if (undoable && isEditing()) {

                commands.startComplex("_selectionSet");

            }

            if (selection instanceof DefaultFeatureSelection) {

                DefaultFeatureSelection defSelection =

                    (DefaultFeatureSelection) selection;

                defSelection.deselectAll(undoable);

                defSelection.select(selection, undoable);

            } else {

                this.selection.deselectAll();

                this.selection.select(selection);

            }

            if (undoable && isEditing()) {

                commands.endComplex();

            }

        }

        this.selection.addObserver(this);

        this.notifyChange(DataStoreNotification.SELECTION_CHANGE);

    }

    public FeatureSelection createFeatureSelection() throws DataException {

        return this.provider.createFeatureSelection();

    }

    public FeatureSelection getFeatureSelection() throws DataException {

        if (selection == null) {

            this.selection = createFeatureSelection();

            this.selection.addObserver(this);

        }

        return selection;

    }

    //

    // ====================================================================

    // Gestion de notificaciones

    //

    public void notifyChange(String notification) {

        if (delegateObservable != null) {

            notifyChange(new DefaultFeatureStoreNotification(this, notification));

        }

    }

    public void notifyChange(String notification, FeatureProvider data) {

        try {

            notifyChange(notification, createFeature(data));

        } catch (DataException ex) {

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

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

        }

    }

    public void notifyChange(String notification, Feature feature) {

        notifyChange(new DefaultFeatureStoreNotification(this, notification,

            feature));

    }

    public void notifyChange(String notification, Command command) {

        notifyChange(new DefaultFeatureStoreNotification(this, notification,

            command));

    }

    public void notifyChange(String notification, EditableFeatureType type) {

        notifyChange(new DefaultFeatureStoreNotification(this, notification,

            type));

    }

    public void notifyChange(FeatureStoreNotification storeNotification) {

        delegateObservable.notifyObservers(storeNotification);

    }

    public void notifyChange(String notification, Resource resource) {

        notifyChange(new DefaultFeatureStoreNotification(this,

            DataStoreNotification.RESOURCE_CHANGED));

    }

    //

    // ====================================================================

    // Gestion de bloqueos

    //

    public boolean isLocksSupported() {

        return this.provider.isLocksSupported();

    }

    public FeatureLocks getLocks() throws DataException {

        if (!this.provider.isLocksSupported()) {

            LOG.warn("Locks not supporteds");

            return null;

        }

        if (locks == null) {

            this.locks = this.provider.createFeatureLocks();

        }

        return locks;

    }

    //

    // ====================================================================

    // Interface Observable

    //

    public void disableNotifications() {

        this.delegateObservable.disableNotifications();

    }

    public void enableNotifications() {

        this.delegateObservable.enableNotifications();

    }

    public void beginComplexNotification() {

        this.delegateObservable.beginComplexNotification();

    }

    public void endComplexNotification() {

        this.delegateObservable.endComplexNotification();

    }

    public void addObserver(Observer observer) {

        this.delegateObservable.addObserver(observer);

    }

    public void deleteObserver(Observer observer) {

        if (delegateObservable != null) {

            this.delegateObservable.deleteObserver(observer);

        }

    }

    public void deleteObservers() {

        this.delegateObservable.deleteObservers();

    }

    //

    // ====================================================================

    // Interface Observer

    //

    // Usado para observar:

    // - su seleccion

    // - sus bloqueos

    // - sus recursos

    //

    public void update(Observable observable, Object notification) {

        if (observable instanceof FeatureSet) {

            if (observable == this.selection) {

                this.notifyChange(DataStoreNotification.SELECTION_CHANGE);

            } else

                if (observable == this.locks) {

                    this.notifyChange(FeatureStoreNotification.LOCKS_CHANGE);

                }

        } else

            if (observable instanceof FeatureStoreProvider) {

                if (observable == this.provider) {

                }

            }

    }

    //

    // ====================================================================

    // Edicion

    //

    private void newVersionOfUpdate() {

        this.versionOfUpdate++;

    }

    private long currentVersionOfUpdate() {

        return this.versionOfUpdate;

    }

    private void checkInEditingMode() throws NeedEditingModeException {

        if (mode != MODE_FULLEDIT) {

            throw new NeedEditingModeException(this.getName());

        }

    }

    private void checkNotInAppendMode() throws IllegalStateException {

        if (mode == MODE_APPEND) {

            throw new IllegalStateException(this.getName());

        }

    }

    private void checkIsOwnFeature(Feature feature)

        throws IllegalFeatureException {

        if (((DefaultFeature) feature).getStore() != this) {

            throw new IllegalFeatureException(this.getName());

        }

        // FIXME: fixFeatureType no vale para el checkIsOwnFeature

        // fixFeatureType((DefaultFeatureType) feature.getType());

    }

    private void exitEditingMode() {

        if (commands != null) {

            commands.clear();

            commands = null;

        }

        if (featureTypeManager != null) {

            featureTypeManager.dispose();

            featureTypeManager = null;

        }

        // TODO implementar un dispose para estos dos

        featureManager = null;

        spatialManager = null;

        featureCount = null;

        mode = MODE_QUERY;

        hasStrongChanges = true; // Lo deja a true por si las moscas

        hasInserts = true;

    }

    synchronized public void edit() throws DataException {

        edit(MODE_FULLEDIT);

    }

    synchronized public void edit(int mode) throws DataException {

        try {

            if (this.mode != MODE_QUERY) {

                throw new AlreadyEditingException(this.getName());

            }

            if (!this.provider.supportsAppendMode()) {

                mode = MODE_FULLEDIT;

            }

            switch (mode) {

            case MODE_QUERY:

                throw new IllegalStateException(this.getName());

            case MODE_FULLEDIT:

                if (!this.transforms.isEmpty()) {

                    throw new IllegalStateException(this.getName());

                }

                notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);

                invalidateIndexes();

                featureManager =

                    new FeatureManager(new MemoryExpansionAdapter());

                featureTypeManager =

                    new FeatureTypeManager(this, new MemoryExpansionAdapter());

                spatialManager =

                    new SpatialManager(this, provider.getEnvelope());

                commands =

                    new DefaultFeatureCommandsStack(featureManager,

                        spatialManager, featureTypeManager);

                this.mode = MODE_FULLEDIT;

                hasStrongChanges = false;

                hasInserts = false;

                notifyChange(FeatureStoreNotification.AFTER_STARTEDITING);

                break;

            case MODE_APPEND:

                if (!this.transforms.isEmpty()) {

                    throw new IllegalStateException(this.getName());

                }

                notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);

                invalidateIndexes();

                this.provider.beginAppend();

                this.mode = MODE_APPEND;

                hasInserts = false;

                notifyChange(FeatureStoreNotification.AFTER_STARTEDITING);

                break;

            }

        } catch (Exception e) {

            throw new StoreEditException(e, this.getName());

        }

    }

    private void invalidateIndexes() {

        setIndexesValidStatus(false);

    }

    private void setIndexesValidStatus(boolean valid) {

        FeatureIndexes indexes = getIndexes();

        for (Iterator iterator = indexes.iterator(); iterator.hasNext();) {

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

            if (index instanceof DefaultFeatureIndex) {

                ((DefaultFeatureIndex) index).setValid(valid);

            }

        }

    }

    private void updateIndexes() throws FeatureIndexException {

        FeatureIndexes indexes = getIndexes();

        for (Iterator iterator = indexes.iterator(); iterator.hasNext();) {

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

            if (index instanceof FeatureIndexProviderServices) {

                FeatureIndexProviderServices indexServices =

                    (FeatureIndexProviderServices) index;

                indexServices.fill(true, null);

            }

        }

    }

    public boolean isEditing() {

        return mode == MODE_FULLEDIT;

    }

    public boolean isAppending() {

        return mode == MODE_APPEND;

    }

    synchronized public void update(EditableFeatureType type)

        throws DataException {

        try {

            checkInEditingMode();

            if (type == null) {

                throw new NullFeatureTypeException(getName());

            }

            // FIXME: Comprobar que es un featureType aceptable.

            notifyChange(FeatureStoreNotification.BEFORE_UPDATE_TYPE, type);

            newVersionOfUpdate();

            FeatureType oldt = type.getSource().getCopy();

            FeatureType newt = type.getNotEditableCopy();

            commands.update(newt, oldt);

            if (((DefaultEditableFeatureType) type).hasStrongChanges()) {

                hasStrongChanges = true;

            }

            notifyChange(FeatureStoreNotification.AFTER_UPDATE_TYPE, type);

        } catch (Exception e) {

            throw new StoreUpdateFeatureTypeException(e, this.getName());

        }

    }

    synchronized public void delete(Feature feature) throws DataException {

        try {

            checkInEditingMode();

            checkIsOwnFeature(feature);

            if (feature instanceof EditableFeature) {

                throw new StoreDeleteEditableFeatureException(getName());

            }

            notifyChange(FeatureStoreNotification.BEFORE_DELETE, feature);

            this.commands.delete(feature);

            newVersionOfUpdate();

            hasStrongChanges = true;

            notifyChange(FeatureStoreNotification.AFTER_DELETE, feature);

        } catch (Exception e) {

            throw new StoreDeleteFeatureException(e, this.getName());

        }

    }

    private static EditableFeature lastChangedFeature = null;

    synchronized public void insert(EditableFeature feature)

        throws DataException {

        try {

            switch (mode) {

            case MODE_QUERY:

                throw new NeedEditingModeException(this.getName());

            case MODE_APPEND:

                checkIsOwnFeature(feature);

                if (feature.getSource() != null) {

                    throw new NoNewFeatureInsertException(this.getName());

                }

                this.featureCount = null;

                notifyChange(FeatureStoreNotification.BEFORE_INSERT, feature);

                feature.validate(Feature.UPDATE);

                provider.append(((DefaultEditableFeature) feature).getData());

                hasStrongChanges = true;

                hasInserts = true;

                notifyChange(FeatureStoreNotification.AFTER_INSERT, feature);

                break;

            case MODE_FULLEDIT:

                checkIsOwnFeature(feature);

                if (feature.getSource() != null) {

                    throw new NoNewFeatureInsertException(this.getName());

                }

                notifyChange(FeatureStoreNotification.BEFORE_INSERT, feature);

                newVersionOfUpdate();

                if ((lastChangedFeature == null)

                    || (lastChangedFeature.getSource() != feature.getSource())) {

                    lastChangedFeature = feature;

                    feature.validate(Feature.UPDATE);

                    lastChangedFeature = null;

                }

                commands.insert(feature.getNotEditableCopy());

                hasStrongChanges = true;

                hasInserts = true;

                notifyChange(FeatureStoreNotification.AFTER_INSERT, feature);

                break;

            }

        } catch (Exception e) {

            throw new StoreInsertFeatureException(e, this.getName());

        }

    }

    synchronized public void update(EditableFeature feature)

        throws DataException {

        try {

            if ((feature).getSource() == null) {

                insert(feature);

                return;

            }

            checkInEditingMode();

            checkIsOwnFeature(feature);

            notifyChange(FeatureStoreNotification.BEFORE_UPDATE, feature);

            newVersionOfUpdate();

            if ((lastChangedFeature == null)

                || (lastChangedFeature.getSource() != feature.getSource())) {

                lastChangedFeature = feature;

                feature.validate(Feature.UPDATE);

                lastChangedFeature = null;

            }

            Feature oldf = feature.getSource();

            Feature newf = feature.getNotEditableCopy();

            commands.update(newf, oldf);

            hasStrongChanges = true;

            notifyChange(FeatureStoreNotification.AFTER_UPDATE, feature);

        } catch (Exception e) {

            throw new StoreUpdateFeatureException(e, this.getName());

        }

    }

    synchronized public void redo() throws RedoException {

        Command redo = commands.getNextRedoCommand();

        try {

            checkInEditingMode();

        } catch (NeedEditingModeException ex) {

            throw new RedoException(redo, ex);

        }

        notifyChange(FeatureStoreNotification.BEFORE_REDO, redo);

        newVersionOfUpdate();

        commands.redo();

        hasStrongChanges = true;

        notifyChange(FeatureStoreNotification.AFTER_REDO, redo);

    }

    synchronized public void undo() throws UndoException {

        Command undo = commands.getNextUndoCommand();

        try {

            checkInEditingMode();

        } catch (NeedEditingModeException ex) {

            throw new UndoException(undo, ex);

        }

        notifyChange(FeatureStoreNotification.BEFORE_UNDO, undo);

        newVersionOfUpdate();

        commands.undo();

        hasStrongChanges = true;

        notifyChange(FeatureStoreNotification.AFTER_UNDO, undo);

    }

    public List getRedoInfos() {

        if (isEditing() && (commands != null)) {

            return commands.getRedoInfos();

        } else {

            return null;

        }

    }

    public List getUndoInfos() {

        if (isEditing() && (commands != null)) {

            return commands.getUndoInfos();

        } else {

            return null;

        }

    }

    public synchronized FeatureCommandsStack getCommandsStack()

        throws DataException {

        checkInEditingMode();

        return commands;

    }

    synchronized public void cancelEditing() throws DataException {

        spatialManager.cancelModifies();

        try {

            checkInEditingMode();

            boolean clearSelection = this.hasStrongChanges;

            if (this.selection instanceof FeatureReferenceSelection) {

                clearSelection = this.hasInserts;

            }

            notifyChange(FeatureStoreNotification.BEFORE_CANCELEDITING);

            exitEditingMode();

            if (clearSelection) {

                ((FeatureSelection) this.getSelection()).deselectAll();

            }

            updateIndexes();

            notifyChange(FeatureStoreNotification.AFTER_CANCELEDITING);

        } catch (Exception e) {

            throw new StoreCancelEditingException(e, this.getName());

        }

    }

    synchronized public void finishEditing() throws DataException {

        try {

            switch (mode) {

            case MODE_QUERY:

                throw new NeedEditingModeException(this.getName());

            case MODE_APPEND:

                notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);

                provider.endAppend();

                exitEditingMode();

                updateIndexes();

                notifyChange(FeatureStoreNotification.AFTER_FINISHEDITING);

                break;

            case MODE_FULLEDIT:

                if (hasStrongChanges && !this.allowWrite()) {

                    throw new WriteNotAllowedException(getName());

                }

                notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);

                if (hasStrongChanges) {

                    validateFeatures(Feature.FINISH_EDITING);

                    provider.performChanges(featureManager.getDeleted(),

                        featureManager.getInserted(),

                        featureManager.getUpdated(),

                        featureTypeManager.getFeatureTypesChanged());

                }

                exitEditingMode();

                updateIndexes();

                notifyChange(FeatureStoreNotification.AFTER_FINISHEDITING);

                break;

            }

        } catch (Exception e) {

            throw new FinishEditingException(e);

        }

    }

    public void beginEditingGroup(String description)

        throws NeedEditingModeException {

        checkInEditingMode();

        commands.startComplex(description);

    }

    public void endEditingGroup() throws NeedEditingModeException {

        checkInEditingMode();

        commands.endComplex();

    }

    public boolean isAppendModeSupported() {

        return this.provider.supportsAppendMode();

    }

    public void export(DataServerExplorer explorer, String provider,

        NewFeatureStoreParameters params) throws DataException {

        if (this.getFeatureTypes().size() != 1) {

            throw new NotYetImplemented(

                "export whith more than one type not yet implemented");

        }

        FeatureSelection featureSelection = (FeatureSelection) getSelection();

        FeatureStore target = null;

        FeatureSet features = null;

        DisposableIterator iterator = null;

        try {

            FeatureType type = this.getDefaultFeatureType();

            if ((params.getDefaultFeatureType() == null)

                || (params.getDefaultFeatureType().size() == 0)) {

                params.setDefaultFeatureType(type.getEditable());

            }

            explorer.add(provider, params, true);

            DataManager manager = DALLocator.getDataManager();

            target = (FeatureStore) manager.openStore(provider, params);

            FeatureType targetType = target.getDefaultFeatureType();

            target.edit(MODE_APPEND);

            FeatureAttributeDescriptor[] pk = type.getPrimaryKey();

            if (featureSelection.getSize() > 0) {

                features = this.getFeatureSelection();

            } else {

                if ((pk != null) && (pk.length > 0)) {

                    FeatureQuery query = createFeatureQuery();

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

                        query.getOrder().add(pk[i].getName(), true);

                    }

                    features = this.getFeatureSet(query);

                } else {

                    features = this.getFeatureSet();

                }

            }

            iterator = features.fastIterator();

            while (iterator.hasNext()) {

                DefaultFeature feature = (DefaultFeature) iterator.next();

                target.insert(target.createNewFeature(targetType, feature));

            }

            target.finishEditing();

            target.dispose();

        } catch (Exception e) {

            throw new DataExportException(e, params.toString());

        } finally {

            dispose(iterator);

            dispose(features);

            dispose(target);

        }

    }

    //

    // ====================================================================

    // Obtencion de datos

    // getDataCollection, getFeatureCollection

    //

    public DataSet getDataSet() throws DataException {

        checkNotInAppendMode();

        FeatureQuery query =

            new DefaultFeatureQuery(this.getDefaultFeatureType());

        return new DefaultFeatureSet(this, query);

    }

    public DataSet getDataSet(DataQuery dataQuery) throws DataException {

        checkNotInAppendMode();

        return new DefaultFeatureSet(this, (FeatureQuery) dataQuery);

    }

    public void getDataSet(Observer observer) throws DataException {

        checkNotInAppendMode();

        this.getFeatureSet(null, observer);

    }

    public void getDataSet(DataQuery dataQuery, Observer observer)

        throws DataException {

        checkNotInAppendMode();

        this.getFeatureSet((FeatureQuery) dataQuery, observer);

    }

    public FeatureSet getFeatureSet() throws DataException {

        checkNotInAppendMode();

        FeatureQuery query =

            new DefaultFeatureQuery(this.getDefaultFeatureType());

        return new DefaultFeatureSet(this, query);

    }

    public FeatureSet getFeatureSet(FeatureQuery featureQuery)

        throws DataException {

        checkNotInAppendMode();

        return new DefaultFeatureSet(this, featureQuery);

    }

    public void accept(Visitor visitor) throws BaseException {

        FeatureSet set = getFeatureSet();

        try {

            set.accept(visitor);

        } finally {

            set.dispose();

        }

    }

    public void accept(Visitor visitor, DataQuery dataQuery)

        throws BaseException {

        FeatureSet set = getFeatureSet((FeatureQuery) dataQuery);

        try {

            set.accept(visitor);

        } finally {

            set.dispose();

        }

    }

    public FeatureType getFeatureType(FeatureQuery featureQuery)

        throws DataException {

        DefaultFeatureType fType =

            (DefaultFeatureType) this.getFeatureType(featureQuery

                .getFeatureTypeId());

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

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

            return fType.getSubtype(featureQuery.getAttributeNames());

        }

        return fType;

    }

    public void getFeatureSet(Observer observer) throws DataException {

        checkNotInAppendMode();

        this.getFeatureSet(null, observer);

    }

    public void getFeatureSet(FeatureQuery query, Observer observer)

        throws DataException {

        class LoadInBackGround implements Runnable {

            private FeatureStore store;

            private FeatureQuery query;

            private Observer observer;

            public LoadInBackGround(FeatureStore store, FeatureQuery query,

                Observer observer) {

                this.store = store;

                this.query = query;

                this.observer = observer;

            }

            void notify(FeatureStoreNotification theNotification) {

                observer.update(store, theNotification);

                return;

            }

            public void run() {

                FeatureSet set = null;

                try {

                    set = store.getFeatureSet(query);

                    notify(new DefaultFeatureStoreNotification(store,

                        FeatureStoreNotification.LOAD_FINISHED, set));

                } catch (Exception e) {

                    notify(new DefaultFeatureStoreNotification(store,

                        FeatureStoreNotification.LOAD_FINISHED, e));

                } finally {

                    dispose(set);

                }

            }

        }

        checkNotInAppendMode();

        if (query == null) {