| gvSIG desktop 1

package org.gvsig.data.vectorial;

import java.lang.ref.Reference;

import java.util.ArrayList;

import java.util.Iterator;

import org.gvsig.data.IDataCollection;

import org.gvsig.data.IDataStoreParameters;

import org.gvsig.data.IResourceNotification;

import org.gvsig.data.Resource;

import org.gvsig.data.commands.ICommand;

import org.gvsig.data.commands.ICommandsRecord;

import org.gvsig.data.commands.implementation.FeatureCommandsRecord;

import org.gvsig.data.exception.CloseException;

import org.gvsig.data.exception.DataException;

import org.gvsig.data.exception.InitializeException;

import org.gvsig.data.exception.OpenException;

import org.gvsig.data.exception.ReadException;

import org.gvsig.data.exception.WriteException;

import org.gvsig.data.vectorial.expansionadapter.IExpansionAdapter;

import org.gvsig.data.vectorial.expansionadapter.MemoryExpansionAdapter;

import org.gvsig.util.observer.ComplexNotification;

import org.gvsig.util.observer.IObservable;

import org.gvsig.util.observer.IObserver;

import org.gvsig.util.observer.Observable;

public abstract class FeatureStore implements IFeatureStore {

        protected IDataStoreParameters parameters;

        protected IDataCollection selection;

        protected ICommandsRecord commands;

        protected boolean alterMode = false;

//        protected ComplexObservable observable=new ComplexObservable();

        protected IDataCollection locked;

        protected Observable observable=new Observable();

        protected FeatureManager featureManager;

        protected SpatialManager spatialManager;

        protected AttributeManager attributeManager;

        protected ArrayList resouceObservers = new ArrayList();

        protected IFeatureType defaultFeatureType = null;

        public void init(IDataStoreParameters parameters) throws InitializeException {

                this.parameters = parameters;

        }

        public void init(IDataStoreParameters parameters,Resource resource) throws InitializeException {

                this.parameters = parameters;

                this.observeResource(resource);

        }

        protected final void observeResource(Resource resource){

                ResourceChangedObserver observer=new ResourceChangedObserver(this);

                resource.addObserver(observer);

                this.resouceObservers.add(observer);

        }

        protected void initSpatialManager(){

                spatialManager=new SpatialManager();

        }

        protected void initAttributeManager() {

                IExpansionAdapter expansionAttributeAdapter=new MemoryExpansionAdapter();

                attributeManager=new AttributeManager(expansionAttributeAdapter,getDefaultFeatureType());

        }

        protected void initExpansionManager() {

                IExpansionAdapter expansionFeatureAdapter=new MemoryExpansionAdapter();

                featureManager=new FeatureManager(expansionFeatureAdapter);

        }

        public IDataCollection getDataCollection() throws ReadException {

                return getDataCollection(null, null, null);

        }

        public void getDataCollection(IObserver observer) {

                getDataCollection(null, null, null,observer);

        }

        public final void setSelection(IDataCollection selection) {

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_SELECTIONCHANGE)

                        );

                doSelection(selection);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_SELECTIONCHANGE)

                        );

        }

        protected void doSelection(IDataCollection selection) {

                this.selection = selection;

        }

        public IDataCollection createSelection() {

                MemoryFeatureCollection selection = new MemoryFeatureCollection();

                return selection;

        }

        public IDataCollection getSelection() {

                if( selection == null ){

                        selection = createSelection();

                }

                return selection;

        }

        public IDataCollection createLocked() {

                MemoryFeatureCollection locked = new MemoryFeatureCollection();

                return locked;

        }

        public IDataCollection getLocked() {

                if( locked == null ){

                        locked = createLocked();

                }

                return locked;

        }

        public final void setLocked(IDataCollection locked) {

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_LOCKEDCHANGE)

                        );

                doLocked(locked);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_LOCKEDCHANGE)

                        );

        }

        protected void doLocked(IDataCollection locked) {

                this.locked = locked;

        }

        public boolean isLocked(IFeatureID id) {

        return locked.contains(id);

    }

    public final boolean lock(IFeatureID id) {

            this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_LOCKEDCHANGE)

                        );

                doLock(id);

            this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_LOCKEDCHANGE)

                        );

                return true;

    }

        protected void doLock(IFeatureID id) {

                locked.add(id);

        }

        public final void startEditing() throws ReadException {

                if (!this.isEditable()) {

                        throw new ReadException("AbstractFeatureStore",

                                        new UnsupportedOperationException("Not editable"));

                }

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_STARTEDITING)

                        );

                doStartEditing();

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_STARTEDITING)

                        );

        }

        protected void doStartEditing() {

//                commands.clear();

                initExpansionManager();

                initSpatialManager();

                initAttributeManager();

                commands = new FeatureCommandsRecord(featureManager, spatialManager, attributeManager);

                alterMode = true;

        }

        public final void delete(IFeatureAttributeDescriptor attributeDescriptor) {

                //FIXME Comporobar que el attribute viene del Fype de este store

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,AttributeStoreNotification.BEFORE_DELETE_ATTRIBUTE,attributeDescriptor)

                        );

                doDelete(attributeDescriptor);

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,AttributeStoreNotification.AFTER_DELETE_ATTRIBUTE,attributeDescriptor)

                        );

        }

        protected void doDelete(IFeatureAttributeDescriptor attributeDescriptor) {

                commands.delete(attributeDescriptor);

        }

        public final void insert(IFeatureAttributeDescriptor attributeDescriptor) throws DataException {

                if( !alterMode ) {

                        throw new DataException("alterMode is false");

                }

                if (!((AttributeDescriptor)attributeDescriptor).isNew()){

                        throw new DataException("attribute is not new");

                }

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,AttributeStoreNotification.BEFORE_INSERT_ATTRIBUTE,attributeDescriptor)

                        );

                doInsert(attributeDescriptor);

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,FeatureStoreNotification.AFTER_INSERT,attributeDescriptor)

                        );

        }

        protected void doInsert(IFeatureAttributeDescriptor attributeDescriptor) {

                ((AttributeDescriptor)attributeDescriptor).stopEditing();

                commands.insert(attributeDescriptor);

        }

        public final void update(IFeatureAttributeDescriptor attributeDescriptor) {

                //FIXME Comporobar que el attribute viene del Fype de este store

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,AttributeStoreNotification.BEFORE_UPDATE_ATTRIBUTE,attributeDescriptor)

                        );

                doUpdate(attributeDescriptor);

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,AttributeStoreNotification.AFTER_UPDATE_ATTRIBUTE,attributeDescriptor)

                        );

        }

        protected void doUpdate(IFeatureAttributeDescriptor attributeDescriptor) {

                commands.update(((AttributeDescriptor)attributeDescriptor).getNewAttributeDescriptor(),attributeDescriptor);

                ((AttributeDescriptor)attributeDescriptor).stopEditing();

        }

        public final void delete(IFeature feature) {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_DELETE,feature)

                        );

                doDelete(feature);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_DELETE,feature)

                        );

        }

        protected void doDelete(IFeature feature) {

                commands.delete(feature);

        }

        public final void insert(IFeature feature) {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                // FIXME: Comprobar que la feature es de este store

                feature.validateModification(this);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_INSERT,feature)

                        );

        doInsert(feature);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_INSERT,feature)

                        );

        }

        protected void doInsert(IFeature feature) {

                commands.insert(((Feature)feature).getNewFeature());

        }

        public final void update(IFeature feature) {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                //        FIXME: Comprobar que la feature es de este store

                feature.validateModification(this);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_UPDATE,feature)

                        );

                doUpdate(feature);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_UPDATE,feature)

                        );

        }

        protected void doUpdate(IFeature feature) {

                feature.validateModification(this);

                Feature oldFeature = (Feature)feature;

                IFeature newFeature=oldFeature.getNewFeature();

                oldFeature.stopEditing();

                commands.update(newFeature,oldFeature);

        }

        public final void redo() {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                ICommand redo = commands.getNextRedoCommand();

                this.observable.notifyObservers(this,

                        new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_REDO,redo)

                );

                doRedo();

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_REDO,redo)

                        );

        }

        protected void doRedo() {

                commands.redo();

        }

        public final void undo() {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                ICommand undo = commands.getNextUndoCommand();

                this.observable.notifyObservers(this,

                        new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_UNDO,undo)

                );

                doUndo();

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_UNDO,undo)

                        );

        }

        protected void doUndo() {

                commands.undo();

        }

        public ICommandsRecord getCommandsRecord() {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                return commands;

        }

        protected void doCancelEditing(){

                commands.clear();

        }

        public final void cancelEditing() {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                this.observable.notifyObservers(this,

                        new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_CANCELEDITING)

                );

                doCancelEditing();

                alterMode = false;

                this.observable.notifyObservers(this,

                        new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_CANCELEDITING)

                );

        }

        public final void finishEditing() throws WriteException, ReadException{

                if( !alterMode ) {

                        //FIXME: OJO arreglar esta excepci?n!!!

                        throw new RuntimeException("alterMode is false");

                }

                this.observable.notifyObservers(this,

                        new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_FINISHEDITING)

                );

                this.validateEndEditing();

                doFinishEdition();

                commands.clear();

                featureManager=null;

                spatialManager=null;

                attributeManager=null;

                commands = null;

                alterMode = false;

                this.observable.notifyObservers(this,

                        new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_FINISHEDITING)

                );

        }

        protected abstract void doFinishEdition() throws WriteException, ReadException ;

        public Iterator getChilds() {

                return null;

        }

        public void beginComplexNotification() {

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

        }

        public void endComplexNotification() {

                this.observable.endComplexNotification(this);

        }

        public void addObserver(IObserver o) {

                this.observable.addObserver(o);

        }

        public void addObserver(Reference ref) {

                this.observable.addObserver(ref);

        }

        public void deleteObserver(IObserver o) {

                this.observable.deleteObserver(o);

        }

        public void deleteObserver(Reference ref) {

                this.observable.deleteObserver(ref);

        }

        public void deleteObservers() {

                this.observable.deleteObservers();

        }

        public boolean isEditing() {

                return alterMode;

        }

        protected void validateEndEditing() throws ReadException{

                IFeatureCollection collection = (IFeatureCollection)this.getDataCollection();

                Iterator iter = collection.iterator();

                while (iter.hasNext()){

                        ((IFeature)iter.next()).validateEnd(this);

                }

        }

        public void disableNotifications() {

                this.observable.diableNotifications();

        }

        public void enableNotifications() {

                this.observable.enableNotifications();

        }

        public void getDataCollection(IFeatureType type, String filter, String order,IObserver observer) {

            LoadInBackGround task = new LoadInBackGround(this,type,filter,order,observer);

            Thread thread = new Thread(task);

            thread.run();

    }

         private class LoadInBackGround implements Runnable{

                    private IFeatureStore store;

                    private IFeatureType type;

                    private String filter;

                    private String order;

                    private IObserver observer;

                        public IDataCollection collection = null;

                    public LoadInBackGround(IFeatureStore store,IFeatureType type, String filter, String order,IObserver observer){

                            this.store = store;

                            this.type = type;

                            this.filter = filter;

                            this.order = order;

                            this.observer = observer;

                    }

                        public void run() {

                                try{

                                        collection = getDataCollection(type, filter, order);

                                } catch (Exception e) {

                                        this.observer.update(this.store, new FeatureStoreNotification(

                                                                        this.store,

                                                                        IFeatureStoreNotification.LOAD_FINISHED,

                                                                        e)

                                                        );

                                }

                                this.observer.update(

                                                this.store, new FeatureStoreNotification(

                                                                        this.store,

                                                                        IFeatureStoreNotification.LOAD_FINISHED,

                                                                        collection)

                                                );

                        }

            }

         public IFeature createFeature(IFeatureType type) throws InitializeException {

                return this.createDefaultFeature(true);

         }

         public IFeature createDefaultFeature(boolean defaultValues) throws InitializeException{

                 IFeature feature;

                try {

                        feature = new CreatedFeature(getDefaultFeatureType(),defaultValues);

                } catch (ReadException e) {

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

                }

                 return feature;

         }

        public IDataStoreParameters getParameters() {

                return parameters;

        }

        protected abstract void doOpen() throws OpenException;

        protected abstract void doClose() throws CloseException;

        protected void doDispose() throws CloseException{

                this.parameters = null;

                if (this.selection != null){

                        this.selection.dispose();

                        this.selection = null;

                }

                this.commands = null;

                if (this.locked != null){

                        this.locked.dispose();

                        this.locked = null;

                }

                this.observable=null;

                this.featureManager = null;

                this.spatialManager = null;

                this.attributeManager = null;

                this.resouceObservers.clear();

                this.resouceObservers = null;

        }

        public final void open() throws OpenException {

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_OPEN)

                );

                doOpen();

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_OPEN)

                );

        }

        public final void close() throws CloseException {

                this.observable.notifyObservers(this,

                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_CLOSE)

            );

                doClose();

        this.observable.notifyObservers(this,

                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_CLOSE)

            );

        }

        public final void dispose() throws CloseException{

                this.observable.notifyObservers(this,

                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_DISPOSE)

            );

        doDispose();

        }

        protected abstract void doRefresh() throws OpenException,InitializeException;

        public final void refresh() throws OpenException,InitializeException{

        doRefresh();

        }

        private void notifyResourceChange(){

        this.observable.notifyObservers(this,

                new FeatureStoreNotification(this,FeatureStoreNotification.RESOURCE_CHANGED)

            );

        }

        private class ResourceChangedObserver implements IObserver{

                private FeatureStore theStore;

                public ResourceChangedObserver(FeatureStore theStore){

                        this.theStore = theStore;

                }

                /* (non-Javadoc)

                 * @see org.gvsig.util.observer.IObserver#update(org.gvsig.util.observer.IObservable, java.lang.Object)

                 */

                public void update(IObservable observable, Object notification) {

                        if (!(notification instanceof IResourceNotification)){

                                return;

                        }

                        if (((IResourceNotification)notification).getStore() == this.theStore){

                                return;

                        }

                        if (((IResourceNotification)notification).getType().equals(IResourceNotification.CHANGED)){

                                this.theStore.notifyResourceChange();

                        }

                }

        }

        /* (non-Javadoc)

         * @see org.gvsig.data.vectorial.IFeatureStore#getDefaultFeatureType()

         */

        public IFeatureType getDefaultFeatureType() {

                if (isEditing()){

//                    Aqu? hay que construir un FeatureType con los cambios que se hayan hecho en la edici?n.

                    return attributeManager.getFeatureType();

            }

        return defaultFeatureType;

        }

        /* (non-Javadoc)

         * @see org.gvsig.data.vectorial.IFeatureStore#createAttributeDescriptor()

         */

        public IFeatureAttributeDescriptor createAttributeDescriptor() {

                // FIXME Hay que identificar de que FType queremos crear el attributo

                // FIXME el Attribute lo deber?a de crea el FType

                return new AttributeDescriptor(true);

        }

}