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

import java.util.Map.Entry;

import org.cresques.cts.IProjection;

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

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

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

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

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.task.Executor;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public final class DefaultFeatureStore extends AbstractDisposable implements

                DataStoreImplementation, FeatureStoreProviderServices, FeatureStore,

                Observer {

        final static private Logger logger = 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(DefaultDataManager dataManager,

                        DataStoreParameters parameters) throws InitializeException {

                DynObjectManager dynManager = ToolsLocator.getDynObjectManager();

                this.metadata = (DelegatedDynObject) dynManager

                                .createDynObject(

                                                METADATA_DEFINITION_NAME,

                                                MetadataManager.METADATA_NAMESPACE

                                );

                this.dataManager = 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 String getName() {

                return this.parameters.getDataStoreName();

        }

        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(FeatureStoreNotification.BEFORE_OPEN);

                this.provider.open();

                this.notifyChange(FeatureStoreNotification.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(FeatureStoreNotification.BEFORE_CLOSE);

                this.featureCount = null;

                this.provider.close();

                this.notifyChange(FeatureStoreNotification.AFTER_CLOSE);

        }

        protected void doDispose() throws BaseException {

                this.notifyChange(FeatureStoreNotification.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(FeatureStoreNotification.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(true)

                                        .setPersistent(true);

                        definition.addDynFieldObject("transforms")

                                        .setClassOfValue(DefaultFeatureStoreTransforms.class)

                                        .setMandatory(true)

                                        .setPersistent(true);

                        definition.addDynFieldMap("evaluatedAttributes")

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

                                        .setMandatory(true)

                                        .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) {

                        delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(

                                        this, notification));

                }

        }

        public void notifyChange(String notification, Feature feature) {

                delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(

                                this, notification, feature));

        }

        public void notifyChange(String notification, Command command) {

                delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(

                                this, notification, command));

        }

        public void notifyChange(String notification, EditableFeatureType type) {

                delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(this,

                                notification, type));

        }

        /*

         * (non-Javadoc)

         *

         * @see

         * org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices#notifyChange

         * (java.lang.String, org.gvsig.fmap.dal.resource.Resource)

         */

        public void notifyChange(String notification, Resource resource) {

                delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(this,

                                FeatureStoreNotification.RESOURCE_CHANGED));

        }

        //

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

        // Gestion de bloqueos

        //

        public boolean isLocksSupported() {

                return this.provider.isLocksSupported();

        }

        public FeatureLocks getLocks() throws DataException {

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

                        logger.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(FeatureStoreNotification.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);

                                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);

                                this.provider.beginAppend();

                                this.mode = MODE_APPEND;

                                hasInserts = false;

                                notifyChange(FeatureStoreNotification.AFTER_STARTEDITING);

                                break;

                        }

                } catch (Exception e) {

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

                }

        }

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

                        }

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

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

                                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.iterator();

                        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){

                        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;

                        private Executor executor;

                        private FeatureStoreNotification notification;

                        public LoadInBackGround(FeatureStore store, FeatureQuery query,

                                        Observer observer, Executor executor) {

                                this.store = store;

                                this.query = query;

                                this.observer = observer;

                                this.executor = executor;

                        }

                        void notify(FeatureStoreNotification theNotification) {

                                if (executor == null) {

                                        observer.update(store, theNotification);

                                        return;

                                }

                                this.notification = theNotification;

                                executor.execute(new Runnable() {

                                        public void run() {

                                                observer.update(store, notification);

                                        }

                                });

                        }

                        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) {

                        query = new DefaultFeatureQuery(this.getDefaultFeatureType());

                }

                Executor executor = ToolsLocator.getTaskManager().getExecutor();

                LoadInBackGround task = new LoadInBackGround(this, query, observer,

                                executor);

                Thread thread = new Thread(task);

                thread.run();

        }