Application: gvSIG desktop

package org.gvsig.data.vectorial;

import java.lang.ref.Reference;

import java.util.Iterator;

import org.gvsig.data.IDataCollection;

import org.gvsig.data.IDataStoreParameters;

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

import org.gvsig.util.observer.IObservable;

import org.gvsig.util.observer.IObserver;

public abstract class AbstractFeatureStore implements IFeatureStore {

        protected IDataStoreParameters parameters;

        protected IDataCollection selection;

        protected ICommandsRecord commands;

        protected boolean alterMode = false;

        protected Observable observable=new Observable();

        protected IDataCollection locked;

        protected FeatureManager featureManager;

        protected SpatialManager spatialManager;

        protected AttributeManager attributeManager;

        public void init(IDataStoreParameters parameters) throws InitializeException {

                this.parameters = parameters;

        }

        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 void setSelection(IDataCollection selection) {

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_SELECTIONCHANGE)

                        );

                this.selection = selection;

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_SELECTIONCHANGE)

                        );

        }

        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 void setLocked(IDataCollection locked) {

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_LOCKEDCHANGE)

                        );

                this.locked = locked;

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_LOCKEDCHANGE)

                        );

        }

        public boolean isLocked(IFeatureID id) {

        return locked.contains(id);

    }

    public boolean lock(IFeatureID id) {

            this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_LOCKEDCHANGE)

                        );

                locked.add(id);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_LOCKEDCHANGE)

                        );

                return true;

    }

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

                        );

//                commands.clear();

                initExpansionManager();

                initSpatialManager();

                initAttributeManager();

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

                alterMode = true;

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_STARTEDITING)

                        );

        }

        public void delete(IFeatureAttributeDescriptor attributeDescriptor) {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,AttributeStoreNotification.BEFORE_DELETE_ATTRIBUTE,attributeDescriptor)

                        );

                commands.delete(attributeDescriptor);

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,AttributeStoreNotification.AFTER_DELETE_ATTRIBUTE,attributeDescriptor)

                        );

        }

        public void insert(IFeatureAttributeDescriptor attributeDescriptor) {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

//                attributeDescriptor.validateModification(this);

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,AttributeStoreNotification.BEFORE_INSERT_ATTRIBUTE,attributeDescriptor)

                        );

                commands.insert(attributeDescriptor);

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,FeatureStoreNotification.AFTER_INSERT,attributeDescriptor)

                        );

        }

        public void update(IFeatureAttributeDescriptor attributeDescriptor) {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

//                feature.validateModification(this);

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,AttributeStoreNotification.BEFORE_UPDATE_ATTRIBUTE,attributeDescriptor)

                        );

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

                ((DefaultAttributeDescriptor)attributeDescriptor).stopEditing();

                this.observable.notifyObservers(this,

                                new AttributeStoreNotification(this,AttributeStoreNotification.AFTER_UPDATE_ATTRIBUTE,attributeDescriptor)

                        );

        }

        public void delete(IFeature feature) {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_DELETE,feature)

                        );

                commands.delete(feature);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_DELETE,feature)

                        );

        }

        public void insert(IFeature feature) {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                feature.validateModification(this);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_INSERT,feature)

                        );

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

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_INSERT,feature)

                        );

        }

        public void update(IFeature feature) {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                feature.validateModification(this);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_UPDATE,feature)

                        );

                Feature oldFeature = (Feature)feature;

                IFeature newFeature=oldFeature.getNewFeature();

                oldFeature.stopEditing();

                commands.update(newFeature,oldFeature);

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_UPDATE,feature)

                        );

        }

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

                );

                commands.redo();

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_REDO,redo)

                        );

        }

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

                );

                commands.undo();

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_UNDO,undo)

                        );

        }

        public ICommandsRecord getCommandsRecord() {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                return commands;

        }

        protected void doCancelEditing(){

        }

        public final void cancelEditing() {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                this.observable.notifyObservers(this,

                        new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_CANCELEDITING)

                );

                doCancelEditing();

                commands.clear();

                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 abstract void doDispose();

//

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

//                this.observable.notifyObservers(this,

//                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_DISPOSE)

//            );

//        doDispose();

//        this.observable.notifyObservers(this,

//                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_DISPOSE)

//            );

//        }

}