| gvSIG desktop 1

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

import java.lang.ref.Reference;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.data.DALLocator;

import org.gvsig.fmap.data.DataExplorer;

import org.gvsig.fmap.data.DataManager;

import org.gvsig.fmap.data.DataQuery;

import org.gvsig.fmap.data.DataSet;

import org.gvsig.fmap.data.DataStoreNotification;

import org.gvsig.fmap.data.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.data.feature.exceptions.AlreadyEditingException;

import org.gvsig.fmap.data.feature.exceptions.ConcurrentDataModificationException;

import org.gvsig.fmap.data.feature.exceptions.CreateFeatureException;

import org.gvsig.fmap.data.feature.exceptions.DataExportException;

import org.gvsig.fmap.data.feature.exceptions.DataIndexException;

import org.gvsig.fmap.data.feature.exceptions.FinishEditingException;

import org.gvsig.fmap.data.feature.exceptions.GetFeatureTypeException;

import org.gvsig.fmap.data.feature.exceptions.IllegalFeatureException;

import org.gvsig.fmap.data.feature.exceptions.IllegalFeatureTypeException;

import org.gvsig.fmap.data.feature.exceptions.NeedEditingModeException;

import org.gvsig.fmap.data.feature.exceptions.NoNewFeatureInsertException;

import org.gvsig.fmap.data.feature.exceptions.NullFeatureTypeException;

import org.gvsig.fmap.data.feature.exceptions.SelectionNotAllowedException;

import org.gvsig.fmap.data.feature.exceptions.StoreCancelEditingException;

import org.gvsig.fmap.data.feature.exceptions.StoreDeleteEditableFeatureException;

import org.gvsig.fmap.data.feature.exceptions.StoreDeleteFeatureException;

import org.gvsig.fmap.data.feature.exceptions.StoreEditException;

import org.gvsig.fmap.data.feature.exceptions.StoreInsertFeatureException;

import org.gvsig.fmap.data.feature.exceptions.StoreRedoException;

import org.gvsig.fmap.data.feature.exceptions.StoreUndoException;

import org.gvsig.fmap.data.feature.exceptions.StoreUpdateFeatureException;

import org.gvsig.fmap.data.feature.exceptions.StoreUpdateFeatureTypeException;

import org.gvsig.fmap.data.feature.exceptions.ValidateFeaturesException;

import org.gvsig.fmap.data.feature.exceptions.WriteNotAllowedException;

import org.gvsig.fmap.data.feature.exceptions.XMLInitializeException;

import org.gvsig.fmap.data.feature.impl.commands.AbstractCommandsRecord;

import org.gvsig.fmap.data.feature.impl.commands.implementation.FeatureCommandsRecord;

import org.gvsig.fmap.data.feature.impl.featureSet.DefaultFeatureSet;

import org.gvsig.fmap.data.feature.spi.DefaultFeatureData;

import org.gvsig.fmap.data.feature.spi.FeatureData;

import org.gvsig.fmap.data.feature.spi.FeatureLocks;

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

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

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

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

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

import org.gvsig.metadata.Metadata;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.ComplexNotification;

import org.gvsig.tools.observer.DefaultObservable;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.operations.OperationContext;

import org.gvsig.tools.operations.OperationException;

import org.gvsig.tools.operations.OperationNotSupportedException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.XMLException;

final public class DefaultFeatureStore implements

                FeatureStoreProviderServices,

                Observer /* , Persistent */{

        private DataStoreParameters parameters = null;

        private FeatureSelection selection;

        private FeatureLocks locks;

        private DefaultObservable observable = new DefaultObservable();

        private AbstractCommandsRecord commands;

        private FeatureTypeManager featureTypeManager;

        private FeatureManager featureManager;

        private SpatialManager spatialManager;

        private FeatureType defaultFeatureType = null;

        private List featureTypes = new ArrayList();

        private boolean editingMode = false;

        private long versionOfUpdate = 0;

        private boolean hasStrongChanges = true;

        private DefaultDataManager dataManager = null;

        private FeatureStoreProvider provider = null;

        private DefaultFeatureIndexes indexes;

        private Logger logger = null;

        /*

         * 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 DefaultFeatureStore(DefaultDataManager manager,

                        DataStoreParameters parameters, FeatureStoreProvider provider)

                        throws InitializeException {

                initialize(manager, parameters, provider);

        }

        public DefaultFeatureStore(DefaultDataManager manager, XMLEntity xmlEntity)

                        throws XMLException {

                this.dataManager = manager;

                this.setXMLEntity(xmlEntity);

        }

        private void initialize(DefaultDataManager manager,

                        DataStoreParameters parameters, FeatureStoreProvider provider)

                        throws InitializeException {

                this.dataManager = manager;

                this.provider = provider;

                this.parameters = parameters;

                this.provider.initialize(this);

        }

        public String getName() {

                return this.parameters.getDataStoreName();

        }

        public String getClassName() {

                return this.getClass().getName();

        }

        public DataStoreParameters getParameters() {

                return parameters;

        }

        public DefaultDataManager getManager() {

                return this.dataManager;

        }

        public Iterator getChilds() {

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

                        throw new IllegalStateException();

                }

                this.notifyChange(FeatureStoreNotification.BEFORE_REFRESH);

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

                this.notifyChange(FeatureStoreNotification.AFTER_CLOSE);

        }

        public void dispose() throws CloseException {

                this.notifyChange(FeatureStoreNotification.BEFORE_DISPOSE);

                this.provider.dispose();

                if (this.selection != null) {

                        this.selection.dispose();

                        this.selection = null;

                }

                this.commands = null;

                if (this.locks != null) {

                        this.locks.dispose();

                        this.locks = null;

                }

                this.featureManager = null;

                this.spatialManager = null;

                this.parameters = null;

                this.notifyChange(FeatureStoreNotification.AFTER_DISPOSE);

                this.observable.deleteObservers();

                this.observable = null;

        }

        public boolean allowWrite() {

                return this.provider.allowWrite();

        }

        public boolean canWriteGeometry(int geometryType) {

                return this.provider.canWriteGeometry(geometryType);

        }

        public DataExplorer getExplorer() throws ReadException {

                return this.provider.getExplorer();

        }

        public Metadata getMetadata() throws BaseException {

                // TODO:

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

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

                return this.provider.getMetadata();

        }

        public Envelope getEnvelope() {

                return this.provider.getEnvelope();

        }

        public FeatureIndexes getIndexes() {

                return this.indexes;

        }

        public String getSRSDefaultGeometry() throws DataException {

                DefaultFeatureType type = (DefaultFeatureType) this

                                .getDefaultFeatureType();

                int index = type.getDefaultGeometryAttributeIndex();

                return type.getAttributeDescriptor(index).getSRS();

        }

        public FeatureSelection createDefaultFeatureSelection()

                        throws DataException {

                return new DefaultFeatureSelection(this);

        }

        public FeatureData createDefaultFeatureData(FeatureType type)

                        throws DataException {

                return new DefaultFeatureData(type);

        }

        //

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

        // Persistencia

        // Interface IPersistence

        //

        public void setXMLEntity(XMLEntity xmlEntity) throws XMLException {

                if (this.provider != null) {

                        throw new XMLInitializeException("already initialized", this

                                        .getName());

                }

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

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

                }

                XMLEntity paramsXML = xmlEntity.firstChild("type", "parameters");

                if (paramsXML == null) {

                        throw new XMLInitializeException("parameters not found", this

                                        .getName());

                }

                FeatureStoreProvider provider ;

                DataStoreParameters params ;

                XMLEntity providerXML = xmlEntity.firstChild("type", "provider");

                try {

                        params = this.getManager().createDataStoreParameters(paramsXML);

                } catch (Exception e) {

                        throw new XMLInitializeException("can't create parameters", this

                                        .getName());

                }

                try {

                        Class providerClass = Class.forName(providerXML.getStringProperty("className"));

                        provider = (FeatureStoreProvider) providerClass.newInstance();

                } catch (Exception e) {

                        throw new XMLInitializeException(

                                        "can't create provider",

                                        this.getName()

                                );

                }

                provider.setXMLEntity(providerXML);

                try {

                        initialize(this.getManager(), params, provider);

                } catch (InitializeException e1) {

                        throw new XMLInitializeException("Initialize Exception", e1);

                }

                XMLEntity selectionXML = xmlEntity.firstChild("type", "selection");

                if (selectionXML != null) {

                        try {

                                selection = createFeatureSelection();

                        } catch (Exception e) {

                                throw new XMLInitializeException("can't reload selection", this

                                                .getName());

                        }

                        selection.setXMLEntity(selectionXML);

                }

        }

        public XMLEntity getXMLEntity() throws XMLException {

                XMLEntity xml = new XMLEntity();

                xml.putProperty("dataStoreName", this.getName());

                xml.putProperty("className", this.getClassName());

                XMLEntity paramsXML = this.parameters.getXMLEntity();

                paramsXML.putProperty("type", "parameters");

                xml.addChild(paramsXML);

                XMLEntity providerXML = this.provider.getXMLEntity();

                providerXML.putProperty("className", this.provider.getClassName());

                providerXML.putProperty("type", "provider");

                xml.addChild(providerXML);

                XMLEntity selectionXML = this.selection.getXMLEntity();

                selectionXML.putProperty("type", "selection");

                xml.addChild(selectionXML);

                return xml;

        }

        /*

        public void getState(PersistentState state) throws PersistenceException {

                state.setTheClass(this);

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

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

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

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

        }

        public void setState(PersistentState state) throws PersistenceException {

                if (this.provider != null) {

                        throw new PersistenceException(null);

                }

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

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

                }

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

                FeatureStoreProvider provider = (FeatureStoreProvider) state.get("provider");

                initialize(this.getManager(), params, provider);

                setSelection((FeatureSelection) state.get("selection"));

        }

        */

        //

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

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

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

                        return;

                }

                if (!selection.isFromStore(this)) {

                        throw new SelectionNotAllowedException(getName());

                }

                this.selection.deleteObserver(this);

                if (selection instanceof FeatureSelection) {

                        this.selection = (FeatureSelection) selection;

                } else {

                        this.selection.deselectAll();

                        this.selection.select(selection);

                }

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

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this, notification));

        }

        public void notifyChange(String notification, Feature feature) {

                this.observable

                                .notifyObservers(this, new DefaultFeatureStoreNotification(

                                                this, notification, feature));

        }

        public void notifyChange(String notification, Command command) {

                this.observable

                                .notifyObservers(this, new DefaultFeatureStoreNotification(

                                                this, notification, command));

        }

        public void notifyChange(String notification, EditableFeatureType type) {

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this, notification, type));

        }

        //

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

        // Gestion de bloqueos

        //

        public FeatureSet getLocks() throws DataException {

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

                        getLogger().warn("Locks not supporteds");

                        return null;

                }

                if (locks == null) {

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

                }

                return locks;

        }

        //

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

        // Gestion de observers

        //

        public void disableNotifications() {

                this.observable.diableNotifications();

        }

        public void enableNotifications() {

                this.observable.enableNotifications();

        }

        public void beginComplexNotification() {

                this.observable.beginComplexNotification(new ComplexNotification());

        }

        public void endComplexNotification() {

                this.observable.endComplexNotification(this);

        }

        public void addObserver(Observer o) {

                this.observable.addObserver(o);

        }

        public void addObserver(Reference ref) {

                this.observable.addObserver(ref);

        }

        public void deleteObserver(Observer o) {

                this.observable.deleteObserver(o);

        }

        public void deleteObserver(Reference ref) {

                this.observable.deleteObserver(ref);

        }

        public void deleteObservers() {

                this.observable.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);

                        }

                }

        }

        //

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

        // Gestion de operaciones

        // Interface ExtendedOperations

        //

        public Object invokeOperation(int code, OperationContext context)

                        throws OperationException, OperationNotSupportedException {

                return this.getManager().invokeDataStoreOperation(this, code, context);

        }

        public Object invokeOperation(String name, OperationContext context)

                        throws OperationException, OperationNotSupportedException {

                return this.getManager().invokeDataStoreOperation(this, name, context);

        }

        public boolean implementsOperation(int code) {

                return this.getManager().implementsDataStoreOperation(this.getName(),

                                code);

        }

        public boolean implementsOperation(String name) {

                return this.getManager().implementsDataStoreOperation(this.getName(),

                                name);

        }

        // TODO: Y la implementacion de esto ?

        public Object getOperation(int code) throws OperationException {

                return null;

        }

        public Object getOperation(String name) throws OperationException {

                return null;

        }

        //

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

        // Edicion

        //

        private void newVersionOfUpdate() {

                this.versionOfUpdate++;

        }

        private long currentVersionOfUpdate() {

                return this.versionOfUpdate;

        }

        private void checkInEditingMode()

                        throws NeedEditingModeException {

                if (!editingMode) {

                        throw new NeedEditingModeException(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() {

                commands.clear();

                featureManager = null;

                spatialManager = null;

                featureTypeManager = null;

                commands = null;

                editingMode = false;

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

        }

        synchronized public void edit() throws DataException {

                try {

                        if (isEditing()) {

                                throw new AlreadyEditingException(this.getName());

                        }

                        notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);

                        featureManager = new FeatureManager(this.provider

                                        .createTemporaryContainer());

                        featureTypeManager = new FeatureTypeManager(this.provider

                                        .createTemporaryContainer());

                        spatialManager = new SpatialManager();

                        commands = new FeatureCommandsRecord(featureManager,

                                        spatialManager, featureTypeManager);

                        editingMode = true;

                        hasStrongChanges = false;

                        notifyChange(FeatureStoreNotification.AFTER_STARTEDITING);

                } catch (Exception e) {

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

                }

        }

        public boolean isEditing() {

                return editingMode;

        }

        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 {

                        checkInEditingMode();

                        checkIsOwnFeature(feature);

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

                                throw new NoNewFeatureInsertException(this.getName());

                        }

                        notifyChange(FeatureStoreNotification.BEFORE_INSERT, feature);

                        newVersionOfUpdate();

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

                                lastChangedFeature = feature;

                                feature.validate(Feature.UPDATE);

                                lastChangedFeature = null;

                        }

                        commands.insert(feature.getNotEditableCopy());

                        hasStrongChanges = true;

                        notifyChange(FeatureStoreNotification.AFTER_INSERT, feature);

                } 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.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 DataException {

                try {

                        checkInEditingMode();

                        Command redo = commands.getNextRedoCommand();

                        notifyChange(FeatureStoreNotification.BEFORE_REDO, redo);

                        newVersionOfUpdate();

                        commands.redo();

                        hasStrongChanges = true;

                        notifyChange(FeatureStoreNotification.AFTER_REDO, redo);

                } catch (Exception e) {

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

                }

        }

        synchronized public void undo() throws DataException {

                try {

                        checkInEditingMode();

                        Command undo = commands.getNextUndoCommand();

                        notifyChange(FeatureStoreNotification.BEFORE_UNDO, undo);

                        newVersionOfUpdate();

                        commands.undo();

                        hasStrongChanges = true;

                        notifyChange(FeatureStoreNotification.AFTER_UNDO, undo);

                } catch (Exception e) {

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

                }

        }

        synchronized public CommandsRecord getCommandsRecord() throws DataException {

                checkInEditingMode();

                return commands;

        }

        synchronized public void cancelEditing() throws DataException {

                try {

                        checkInEditingMode();

                        notifyChange(FeatureStoreNotification.BEFORE_CANCELEDITING);

                        exitEditingMode();

                        notifyChange(FeatureStoreNotification.AFTER_CANCELEDITING);

                } catch (Exception e) {

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

                }

        }

        synchronized public void finishEditing() throws DataException {

                try {

                        checkInEditingMode();

                        if (!hasStrongChanges) {

                                performLightEditing();

                                return;

                        }

                        if (!this.allowWrite()) {

                                throw new WriteNotAllowedException(getName());

                        }

                        notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);

                        validateFeatures(Feature.FINISH_EDITING);

                        provider.performEditing();

                        exitEditingMode();

                        notifyChange(FeatureStoreNotification.AFTER_FINISHEDITING);

                } catch (Exception e) {

                        throw new FinishEditingException(e);

                }

        }

        private void performLightEditing() throws DataException {

                throw new UnsupportedOperationException(

                                "lightFinishEdition not yet implemented");

                // TODO: implementar

                // notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);

                // exitEditingMode();

                // notifyChange(FeatureStoreNotification.AFTER_FINISHEDITING);

        }

        public void export(FeatureExplorer explorer, FeatureStoreParameters params)

                        throws DataException {

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

                        throw new UnsupportedOperationException(

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

                }

                try {

                        FeatureType type = this.getDefaultFeatureType();

                        params.setDefaultFeatureType(type);

                        explorer.add(params);

                        DataManager manager = DALLocator.getDataManager();

                        FeatureStore target = (FeatureStore) manager

                                        .createDataStore(params);

                        target.edit();

                        FeatureSet features = this.getFeatureSet();

                        Iterator it1 = features.iterator();

                        while (it1.hasNext()) {

                                Feature feature = (Feature) it1.next();

                                target.insert(target.createFeature(type, feature));

                        }

                        features.dispose();

                        target.finishEditing();

                        target.dispose();

                } catch (Exception e) {

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

                }

        }

        //

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

        // Obtencion de datos

        // getDataCollection, getFeatureCollection

        //

        public DataSet getDataSet() throws DataException {

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

                return new DefaultFeatureSet(this, query);

        }

        public DataSet getDataSet(DataQuery dataQuery)

                        throws DataException {

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

        }

        public void getDataSet(Observer observer) throws DataException {

                this.getFeatureSet(null, observer);

        }

        public void getDataSet(DataQuery dataQuery, Observer observer)

                        throws DataException {

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

        }

        public FeatureSet getFeatureSet() throws DataException {

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

                return new DefaultFeatureSet(this, query);

        }

        public FeatureSet getFeatureSet(FeatureQuery featureQuery)

                        throws DataException {

                fixFeatureQuery(featureQuery);

                return new DefaultFeatureSet(this, featureQuery);

        }

        private void fixFeatureQuery(FeatureQuery featureQuery)

                        throws DataException {

                featureQuery.setFeatureType(this.fixFeatureType((DefaultFeatureType) featureQuery.getFeatureType()));

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

                        DefaultFeatureType originalType = (DefaultFeatureType) featureQuery

                                        .getFeatureType();

                        featureQuery.setFeatureType(originalType.getSubtype(featureQuery

                                        .getAttributeNames()));

                }

        }

        public void getFeatureSet(Observer observer)

                        throws DataException {

                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;

                        }

                        public void run() {

                                try {

                                        FeatureSet collection = store.getFeatureSet(query);

                                        observer.update(

                                                        store,

                                                        new DefaultFeatureStoreNotification(

                                                                        store,

                                                                        FeatureStoreNotification.LOAD_FINISHED,

                                                                        collection

                                                                )

                                                );

                                } catch (Exception e) {

                                        observer.update(

                                                        store,

                                                        new DefaultFeatureStoreNotification(

                                                                        store,

                                                                        FeatureStoreNotification.LOAD_FINISHED,

                                                                        e

                                                                )

                                                );

                                }

                        }

                }

                if (query == null) {

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

                }

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

                Thread thread = new Thread(task);

                thread.run();

        }

        public Feature getFeatureByReference(FeatureReference reference) throws DataException {

                return this.getFeatureByReference(reference, this.getDefaultFeatureType());

        }

        public Feature getFeatureByReference(FeatureReference reference, FeatureType featureType)

                        throws DataException {

                featureType = fixFeatureType((DefaultFeatureType) featureType);

                // TODO comprobar que el id es de este store

                if (this.editingMode) {

                        if (featureManager.contains(reference)) {

                                return featureManager.getFeature(reference, this, featureType);

                        }

                }

                return this.createFeature(featureType, this.provider

                                .getFeatureDataByReference(reference, featureType));

        }

        //

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

        // Gestion de features

        //

        private FeatureType fixFeatureType(DefaultFeatureType type)

                        throws DataException {

                FeatureType defaultType = this.getDefaultFeatureType();

                if (type == null || type.equals(defaultType)) {

                        return defaultType;

                }

                if (type.isSubtypeOf(defaultType)) {

                        return type;

                }

                Iterator iter = this.getFeatureTypes().iterator();

                FeatureType tmpType;

                while (iter.hasNext()) {

                        tmpType = (FeatureType) iter.next();

                        if (type.equals(tmpType) || type.isSubtypeOf(tmpType)) {

                                return type;

                        }

                }

                throw new IllegalFeatureTypeException(getName());

        }

        public void validateFeatures(int mode) throws DataException {

                try {

                        FeatureSet collection = this.getFeatureSet();

                        Iterator iter = collection.iterator();

                        long previousVersionOfUpdate = currentVersionOfUpdate();

                        while (iter.hasNext()) {

                                ((DefaultFeature) iter.next()).validate(mode);

                                if (previousVersionOfUpdate != currentVersionOfUpdate()) {

                                        throw new ConcurrentDataModificationException(getName());

                                }

                        }

                } catch (Exception e) {

                        throw new ValidateFeaturesException(e, getName());

                }

        }

        public FeatureType getDefaultFeatureType() throws DataException {

                try {

                        if (isEditing()) {

                                return featureTypeManager.getFeatureType();

                        }

                        return defaultFeatureType;

                } catch (Exception e) {

                        throw new GetFeatureTypeException(e, getName());

                }

        }

        public List getFeatureTypes() throws DataException {

                try {

                        List types;

                        if (isEditing()) {

                                types = featureTypeManager.getFeatureTypes();

                        } else {

                                types = featureTypes;

                        }

                        return Collections.unmodifiableList(types);

                } catch (Exception e) {

                        throw new GetFeatureTypeException(e, getName());

                }

        }

        public Feature createFeature(FeatureData data)

                        throws DataException {

                DefaultFeature feature = new DefaultFeature(this, data);

                return feature;

        }

        /**

         * @deprecated

         */

        public Feature createFeature(FeatureType type, FeatureData data)

                        throws DataException {

                // FIXME: falta por implementar

                // Comprobar si es un subtipo del feature de data

                // y construir un feature usando el subtipo.

                // Probablemente requiera generar una copia del data.

                return null;

        }

        public EditableFeature createFeature(FeatureType type,

                        Feature defaultValues)

                        throws DataException {

                try {

                        type = this.fixFeatureType((DefaultFeatureType) type);

                        FeatureData data = this.provider.createFeatureData(type);

                        DefaultEditableFeature feature = new DefaultEditableFeature(this,

                                        data);

                        feature.initializeValues(defaultValues);

                        return feature;

                } catch (Exception e) {

                        throw new CreateFeatureException(e, getName());

                }

        }

        public EditableFeature createFeature(FeatureType type,

                        boolean defaultValues)

                        throws DataException {

                try {

                        type = this.fixFeatureType((DefaultFeatureType) type);

                        FeatureData data = this.provider.createFeatureData(type);

                        DefaultEditableFeature feature = new DefaultEditableFeature(this,

                                        data);

                        if (defaultValues) {

                                feature.initializeValues();

                        }

                        return feature;

                } catch (Exception e) {

                        throw new CreateFeatureException(e, getName());

                }

        }

        public EditableFeature createFeature(boolean defaultValues)

                        throws DataException {

                return this.createFeature(this.getDefaultFeatureType(), defaultValues);

        }

        public EditableFeature createFeature() throws DataException {

                return this.createFeature(this.getDefaultFeatureType(), true);

        }

        public EditableFeatureType createFeatureType() {

                return new DefaultEditableFeatureType();

        }

        public boolean isLocksSupported() {

                return this.provider.isLocksSupported();

        }

        public Logger getLogger() {

                if (this.logger == null) {

                        this.logger = LoggerFactory.getLogger(this.getClass());

                }

                return this.logger;

        }

        public FeatureIndex createIndex(FeatureType featureType,

                        String attributeName, String indexName) throws ProviderNotRegisteredException, InitializeException {

                FeatureIndexProviderServices index = null;

                index = getManager().createDataIndexProvider(this, featureType, featureType.getAttributeDescriptor(attributeName));

                try {

                        index.fill();

                } catch (DataIndexException e) {

                        throw new InitializeException(index.getName(), e);

                }

                ((DefaultFeatureIndexes) getIndexes()).addIndex(index);

                return index;

        }

}