Application: gvSIG desktop

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

import java.util.*;

import org.gvsig.fmap.data.*;

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

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

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

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.expansionadapter.MemoryExpansionAdapter;

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

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

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.exception.NotYetImplemented;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.observer.WeakReferencingObservable;

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

import org.gvsig.tools.operations.OperationContext;

import org.gvsig.tools.operations.OperationException;

import org.gvsig.tools.operations.OperationNotSupportedException;

import org.gvsig.tools.persistence.AbstractPersistenceManager;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistentState;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

final public class DefaultFeatureStore implements

                FeatureStoreProviderServices,

                Observer {

    final static private Logger logger = LoggerFactory

            .getLogger(DefaultFeatureStore.class);

        private DataStoreParameters parameters = null;

        private FeatureSelection selection;

        private FeatureLocks locks;

        private DelegateWeakReferencingObservable delegateObservable = new DelegateWeakReferencingObservable(this);

        private AbstractCommandsRecord 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 DefaultDataManager dataManager = null;

        private FeatureStoreProvider provider = null;

        private DefaultFeatureIndexes indexes;

        /*

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

        }

        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 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.mode != MODE_QUERY) {

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

                this.delegateObservable = 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() {

                // FIXME: Y en edicion/append

                return this.provider.getEnvelope();

        }

        public FeatureIndexes getIndexes() {

                return this.indexes;

        }

        /**

         * @deprecated use getDefaultFeatureType().getDefaultSRS()

         */

        public String getSRSDefaultGeometry() throws DataException {

                return this.getDefaultFeatureType().getDefaultSRS();

        }

        public FeatureSelection createDefaultFeatureSelection()

                        throws DataException {

                return new DefaultFeatureSelection(this);

        }

        public FeatureData createDefaultFeatureData(FeatureType type)

                        throws DataException {

                return new DefaultFeatureData(type);

        }

        public PersistentState getState()

                        throws PersistenceException {

                return AbstractPersistenceManager.getState(this);

        }

        public void loadState(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");

                try {

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

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

                } catch (InitializeException e) {

                        throw new PersistenceException(e);

                } catch (DataException e) {

                        throw new PersistenceException(e);

                }

        }

        //

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

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

                        if (isEditing()) {

                                commands.selectionSet(this, this.selection,

                                                (FeatureSelection) selection);

                        }

                        this.selection = (FeatureSelection) selection;

                } else {

                        if (isEditing()) {

                                commands.startComplex("_selectionSet");

                        }

                        this.selection.deselectAll();

                        this.selection.select(selection);

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

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

        }

        //

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

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

        }

        //

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

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

        this.delegateObservable.deleteObserver(observer);

        }

        public void deleteObservers() {

                this.delegateObservable.deleteObservers();

        }

        //

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

        // Interface Observer

        //

        // Usado para observar:

        // - su seleccion

        // - sus bloqueos

        // - sus recursos

        //

        public void update(WeakReferencingObservable 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.dataManager.getOperationManager().invokeOperation(this, code, context);

        }

        public Object invokeOperation(String name, OperationContext context)

                        throws OperationException, OperationNotSupportedException {

                return this.dataManager.getOperationManager().invokeOperation(this, name, context);

        }

        public boolean hasOperation(int code) {

                return this.dataManager.getOperationManager().hasOperation(this, code);

        }

        public boolean hasOperation(String name) {

                return this.dataManager.getOperationManager().hasOperation(this, name);

        }

        public Object getOperation(int code) throws OperationException {

                return this.dataManager.getOperationManager().getOperation(this, code);

        }

        public Object getOperation(String name) throws OperationException {

                return this.dataManager.getOperationManager().getOperation(this, name);

        }

        //

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

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

                commands.clear();

                featureManager = null;

                spatialManager = null;

                featureTypeManager = null;

                commands = null;

                mode = MODE_QUERY;

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

        }

        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:

                                notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);

                                featureManager = new FeatureManager(new MemoryExpansionAdapter());

                                featureTypeManager = new FeatureTypeManager(

                                                new MemoryExpansionAdapter());

                                spatialManager = new SpatialManager();

                                commands = new FeatureCommandsRecord(featureManager,

                                                spatialManager, featureTypeManager);

                                this.mode = MODE_FULLEDIT;

                                hasStrongChanges = false;

                                notifyChange(FeatureStoreNotification.AFTER_STARTEDITING);

                                break;

                        case MODE_APPEND:

                                notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);

                                this.provider.beginAppend();

                                this.mode = MODE_APPEND;

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

                                }

                                notifyChange(FeatureStoreNotification.BEFORE_INSERT, feature);

                                feature.validate(Feature.UPDATE);

                                provider.append(feature);

                                hasStrongChanges = 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.getSource() != feature.getSource()) {

                                        lastChangedFeature = feature;

                                        feature.validate(Feature.UPDATE);

                                        lastChangedFeature = null;

                                }

                                commands.insert(feature.getNotEditableCopy());

                                hasStrongChanges = 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.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 {

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

                                        performLightEditing();

                                        return;

                                }

                                if (!this.allowWrite()) {

                                        throw new WriteNotAllowedException(getName());

                                }

                                notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);

                                validateFeatures(Feature.FINISH_EDITING);

                                provider.performEditing(featureManager.getInserted(),

                                                featureManager.getUpdated(), featureManager

                                                                .getDeleted());

                                exitEditingMode();

                                notifyChange(FeatureStoreNotification.AFTER_FINISHEDITING);

                                break;

                        }

                } catch (Exception e) {

                        throw new FinishEditingException(e);

                }

        }

        private void performLightEditing() throws DataException {

                throw new NotYetImplemented(

                                "lightFinishEdition not yet implemented");

                // TODO: implementar

                // notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);

                // exitEditingMode();

                // notifyChange(FeatureStoreNotification.AFTER_FINISHEDITING);

        }

        public boolean isAppendModeSupported() {

                return this.provider.supportsAppendMode();

        }

        public void export(FeatureExplorer explorer, FeatureStoreParameters params)

                        throws DataException {

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

                        throw new NotYetImplemented(

                                        "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

                                        .createStore(params);

                        target.edit();

                        FeatureSet features = this.getFeatureSet();

                        Iterator it1 = features.iterator();

                        while (it1.hasNext()) {

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

                                target.insert(target.createNewFeature(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 {

                checkNotInAppendMode();

                FeatureQuery query = new FeatureQuery(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 FeatureQuery(this.getDefaultFeatureType());

                return new DefaultFeatureSet(this, query);

        }

        public FeatureSet getFeatureSet(FeatureQuery featureQuery)

                        throws DataException {

                checkNotInAppendMode();

                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 {

                checkNotInAppendMode();

                this.getFeatureSet(null, observer);

        }

        public void getFeatureSet(FeatureQuery query, Observer observer)

                        throws DataException {

                class LoadInBackGround implements Runnable {

                        private FeatureStore store;

                        private FeatureQuery query;

                        private Observer observer;

                        public LoadInBackGround(FeatureStore store, FeatureQuery query,

                                        Observer observer) {

                                this.store = store;

                                this.query = query;

                                this.observer = observer;

                        }

                        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

                                                                )

                                                );

                                }

                        }

                }

                checkNotInAppendMode();

                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 {

                checkNotInAppendMode();

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

        }

        public Feature getFeatureByReference(FeatureReference reference, FeatureType featureType)

                        throws DataException {

                checkNotInAppendMode();

                featureType = fixFeatureType((DefaultFeatureType) featureType);

                // TODO comprobar que el id es de este store

                if (this.mode == MODE_FULLEDIT) {

                        Feature f = featureManager.get(reference, this, featureType);

                        if (f!=null) {

                                return f;

                        }

                }

                return new DefaultFeature(this, this.provider

                                .getFeatureDataByReference((FeatureReferenceProviderServices) reference));

        }

        //

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

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

                        checkNotInAppendMode();

                        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.getType(defaultFeatureType.getId());

                        }

                        return defaultFeatureType;

                } catch (Exception e) {

                        throw new GetFeatureTypeException(e, getName());

                }

        }

        public List getFeatureTypes() throws DataException {

                try {

                        List types;

                        if (isEditing()) {

                                types=new ArrayList();

                                Iterator it=featureTypes.iterator();

                                while (it.hasNext()) {

                                        FeatureType type = (FeatureType) it.next();

                                        type=featureTypeManager.getType(type.getId());

                                        if (type!=null) {

                                                types.add(type);

                                        }

                                }

                                it = featureTypeManager.newsIterator();

                                while (it.hasNext()) {

                                        FeatureType type = (FeatureType) it.next();

                                        types.add(type);

                                }

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

        }

        public Feature createFeature(FeatureData data, FeatureType type)

                        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.

                throw new NotYetImplemented();

        }

        public EditableFeature createNewFeature(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 createNewFeature(FeatureType type,

                        boolean defaultValues)

                        throws DataException {

                try {

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

                        DefaultEditableFeature feature = new DefaultEditableFeature(this, type);

                        if (defaultValues) {

                                feature.initializeValues();

                        }

                        return feature;

                } catch (Exception e) {

                        throw new CreateFeatureException(e, getName());

                }

        }

        public EditableFeature createNewFeature(boolean defaultValues)

                        throws DataException {

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

        }

        public EditableFeature createNewFeature() throws DataException {

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

        }

        public EditableFeatureType createFeatureType() {

                return new DefaultEditableFeatureType();

        }

        public boolean isLocksSupported() {

                return this.provider.isLocksSupported();

        }

        public Logger getLogger() {

                return DefaultFeatureStore.logger;

        }

        public FeatureIndex createIndex(FeatureType featureType,

                        String attributeName, String indexName) throws ProviderNotRegisteredException, InitializeException {

                checkNotInAppendMode();

                FeatureIndexProviderServices index = null;

                index = getManager().createFeatureIndexProvider(null, this, featureType, indexName, featureType.getAttributeDescriptor(attributeName));

                try {

                        index.fill();

                } catch (FeatureIndexException e) {

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

                }

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

                return index;

        }

        public void beginEditingGroup(String description)

                        throws NeedEditingModeException {

                checkInEditingMode();

                commands.startComplex(description);

        }

        public void endEditingGroup() throws NeedEditingModeException {

                checkInEditingMode();

                commands.endComplex();

        }

}