| gvSIG desktop 1

package org.gvsig.fmap.data.feature;

import java.lang.ref.Reference;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.data.CloseException;

import org.gvsig.fmap.data.DataCollection;

import org.gvsig.fmap.data.DataException;

import org.gvsig.fmap.data.DataManager;

import org.gvsig.fmap.data.DataStoreParameters;

import org.gvsig.fmap.data.InitializeException;

import org.gvsig.fmap.data.OpenException;

import org.gvsig.fmap.data.ReadException;

import org.gvsig.fmap.data.Resource;

import org.gvsig.fmap.data.ResourceNotification;

import org.gvsig.fmap.data.WriteException;

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

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

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

import org.gvsig.fmap.data.feature.expansionadapter.ExpansionAdapter;

import org.gvsig.fmap.data.feature.expansionadapter.MemoryExpansionAdapter;

import org.gvsig.fmap.data.feature.expressionevaluator.AttributeValueEvaluator;

import org.gvsig.fmap.data.index.IndexException;

import org.gvsig.fmap.data.index.IndexStore;

import org.gvsig.fmap.data.index.spatial.PersistentSpatialIndex;

import org.gvsig.fmap.data.index.spatial.SpatialIndex;

import org.gvsig.fmap.data.index.spatial.SpatialIndexFactory;

import org.gvsig.fmap.data.index.spatial.SpatialIndexParameters;

import org.gvsig.fmap.data.operation.DataStoreOperationContext;

import org.gvsig.fmap.data.operation.DataStoreOperationException;

import org.gvsig.fmap.data.operation.DataStoreOperationNotSupportedException;

import org.gvsig.fmap.geom.Geometry;

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

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 com.iver.utiles.XMLEntity;

import com.iver.utiles.XMLException;

public abstract class AbstractFeatureStore implements FeatureStore {

        protected DataStoreParameters parameters = null;

        protected DataCollection selection;

        protected CommandsRecord commands;

        protected boolean alterMode = false;

//        protected ComplexObservable observable=new ComplexObservable();

        protected DataCollection locked;

        protected DefaultObservable observable=new DefaultObservable();

        protected FeatureManager featureManager;

        protected SpatialManager spatialManager;

        protected AttributeManager attributeManager;

        protected ArrayList resouceObservers = new ArrayList();

        protected FeatureType defaultFeatureType = null;

        protected Observer selectionObserver = null;

        protected IndexStore indexStore = null;

        public void init(DataStoreParameters parameters) throws InitializeException {

                if (this.parameters != null) {

                        throw new InitializeException("initialized two times", this

                                        .getName());

                }

                this.parameters = parameters;

        }

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

                if (this.parameters != null) {

                        throw new InitializeException("initialized two times", this

                                        .getName());

                }

                this.parameters = parameters;

                this.observeResource(resource);

        }

        public void setXMLEntity(XMLEntity xmlEntity) throws XMLException {

                DataManager manager = DataManager.getManager();

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

                if (paramsXML == null) {

                        throw new XMLInitializeException("parameters not found", this

                                        .getName());

                }

                try {

                DataStoreParameters params = manager

                                        .createDataStoreParameters(paramsXML);

                this.init(params);

                } catch (InitializeException e) {

                        throw new XMLInitializeException("inititalize", e);

                }

                //TODO Selection and Lock persistence

        }

        public XMLEntity getXMLEntity() {

                XMLEntity xml = new XMLEntity();

                XMLEntity paramsXML = this.parameters.getXMLEntity();

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

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

                xml.addChild(paramsXML);

                //TODO Selection and Lock persistence... IndexParams???

                return xml;

        }

        protected final void observeResource(Resource resource){

                ResourceChangedObserver observer=new ResourceChangedObserver(this);

                resource.addObserver(observer);

                this.resouceObservers.add(observer);

        }

        protected final void clearResourceObservers() {

                this.resouceObservers.clear();

        }

        protected void initSpatialManager(){

                spatialManager=new SpatialManager();

        }

        protected void initAttributeManager() {

                ExpansionAdapter expansionAttributeAdapter=new MemoryExpansionAdapter();

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

        }

        protected void initExpansionManager() {

                ExpansionAdapter expansionFeatureAdapter=new MemoryExpansionAdapter();

                featureManager=new FeatureManager(expansionFeatureAdapter);

        }

        public DataCollection getDataCollection() throws ReadException {

                return getDataCollection(this.getDefaultFeatureType(), null, null);

        }

        public DataCollection getDataCollection(String[] fields, String filter,

                        String order) throws ReadException {

                try {

                        return getDataCollection(this.getDefaultFeatureType().getSubFeatureType(fields), filter, order);

                } catch (DataException e) {

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

                }

        }

        public void getDataCollection(Observer observer) {

                getDataCollection(this.getDefaultFeatureType(), null, null,observer);

        }

        public final void setSelection(DataCollection selection)

                        throws DataException {

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

                        return;

                }

                if (!selection.isFromStore(this)){

                        throw new DataException("selection not form this store");

                }

                doSetSelection(selection);

                this.notifySelectionChange();

        }

        protected void doSetSelection(DataCollection selection) {

                this.unsetSelectionObserver();

                if (this.getSelection().getClass().isInstance(selection)) {

                        this.selection = selection;

                } else {

                        this.selection = null;

                        this.getSelection().addAll(selection);

                }

                this.setSelectionObserver();

        }

        protected void setSelectionObserver(){

                if (this.selection instanceof Observable) {

                        Observable obSelection = (Observable) this.selection;

                        if (this.selectionObserver == null){

                                this.selectionObserver=new SelectionObserver(this);

                        }

                        obSelection.addObserver(this.selectionObserver);

                }

        }

        protected void unsetSelectionObserver() {

                if (this.selection instanceof Observable) {

                        Observable obSelection = (Observable) this.selection;

                        obSelection.deleteObserver(this.selectionObserver);

                }

        }

        public DataCollection createSelection() {

                MemoryFeatureCollection selection = new MemoryFeatureCollection(this);

                return selection;

        }

        public DataCollection getSelection() {

                if( selection == null ){

                        this.selection = createSelection();

                        this.setSelectionObserver();

                }

                return selection;

        }

        public DataCollection createLocked() {

                MemoryFeatureCollection locked = new MemoryFeatureCollection(this);

                return locked;

        }

        public DataCollection getLocked() {

                if( locked == null ){

                        locked = createLocked();

                }

                return locked;

        }

        public final void setLocked(DataCollection locked) {

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_LOCKEDCHANGE)

                        );

                doLocked(locked);

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.AFTER_LOCKEDCHANGE)

                        );

        }

        protected void doLocked(DataCollection locked) {

                this.locked = locked;

        }

        public boolean isLocked(FeatureID id) {

        return locked.contains(id);

    }

    public final boolean lock(FeatureID id) {

            this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_LOCKEDCHANGE)

                        );

                doLock(id);

            this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.AFTER_LOCKEDCHANGE)

                        );

                return true;

    }

        protected void doLock(FeatureID 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 DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_STARTEDITING)

                        );

                doStartEditing();

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.AFTER_STARTEDITING)

                        );

        }

        protected void doStartEditing() {

//                commands.clear();

                initExpansionManager();

                initSpatialManager();

                initAttributeManager();

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

                alterMode = true;

        }

        public final void delete(FeatureAttributeDescriptor 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 DefaultAttributeStoreNotification(this,DefaultAttributeStoreNotification.BEFORE_DELETE_ATTRIBUTE,attributeDescriptor)

                        );

                doDelete(attributeDescriptor);

                this.observable.notifyObservers(this,

                                new DefaultAttributeStoreNotification(this,DefaultAttributeStoreNotification.AFTER_DELETE_ATTRIBUTE,attributeDescriptor)

                        );

        }

        protected void doDelete(FeatureAttributeDescriptor attributeDescriptor) {

                commands.delete(attributeDescriptor);

        }

        public final void insert(FeatureAttributeDescriptor 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 DefaultAttributeStoreNotification(this,DefaultAttributeStoreNotification.BEFORE_INSERT_ATTRIBUTE,attributeDescriptor)

                        );

                doInsert(attributeDescriptor);

                this.observable.notifyObservers(this,

                                new DefaultAttributeStoreNotification(this,DefaultFeatureStoreNotification.AFTER_INSERT,attributeDescriptor)

                        );

        }

        protected void doInsert(FeatureAttributeDescriptor attributeDescriptor) {

                ((AttributeDescriptor)attributeDescriptor).stopEditing();

                commands.insert(attributeDescriptor);

        }

        public final void update(FeatureAttributeDescriptor 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 DefaultAttributeStoreNotification(this,DefaultAttributeStoreNotification.BEFORE_UPDATE_ATTRIBUTE,attributeDescriptor)

                        );

                doUpdate(attributeDescriptor);

                this.observable.notifyObservers(this,

                                new DefaultAttributeStoreNotification(this,DefaultAttributeStoreNotification.AFTER_UPDATE_ATTRIBUTE,attributeDescriptor)

                        );

        }

        protected void doUpdate(FeatureAttributeDescriptor attributeDescriptor) {

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

                ((AttributeDescriptor)attributeDescriptor).stopEditing();

        }

        public final void delete(Feature feature) {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_DELETE,feature)

                        );

                doDelete(feature);

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.AFTER_DELETE,feature)

                        );

        }

        protected void doDelete(Feature feature) {

                commands.delete(feature);

        }

        public final void insert(Feature 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 DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_INSERT,feature)

                        );

        doInsert(feature);

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.AFTER_INSERT,feature)

                        );

        }

        protected void doInsert(Feature feature) {

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

        }

        public final void update(Feature 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 DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_UPDATE,feature)

                        );

                doUpdate(feature);

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.AFTER_UPDATE,feature)

                        );

        }

        protected void doUpdate(Feature feature) {

                feature.validateModification(this);

                AbstractFeature oldFeature = (AbstractFeature)feature;

                Feature newFeature=oldFeature.getNewFeature();

                oldFeature.stopEditing();

                commands.update(newFeature,oldFeature);

        }

        public final void redo() {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                Command redo = commands.getNextRedoCommand();

                this.observable.notifyObservers(this,

                        new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_REDO,redo)

                );

                doRedo();

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.AFTER_REDO,redo)

                        );

        }

        protected void doRedo() {

                commands.redo();

        }

        public final void undo() {

                if( !alterMode ) {

                        throw new RuntimeException("alterMode is false");

                }

                Command undo = commands.getNextUndoCommand();

                this.observable.notifyObservers(this,

                        new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_UNDO,undo)

                );

                doUndo();

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.AFTER_UNDO,undo)

                        );

        }

        protected void doUndo() {

                commands.undo();

        }

        public CommandsRecord 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 DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_CANCELEDITING)

                );

                doCancelEditing();

                alterMode = false;

                this.observable.notifyObservers(this,

                        new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.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 DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_FINISHEDITING)

                );

                this.validateEndEditing();

                doFinishEdition();

                commands.clear();

                featureManager=null;

                spatialManager=null;

                attributeManager=null;

                commands = null;

                alterMode = false;

                this.observable.notifyObservers(this,

                        new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.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(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();

        }

        public boolean isEditing() {

                return alterMode;

        }

        protected void validateEndEditing() throws ReadException{

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

                Iterator iter = collection.iterator();

                while (iter.hasNext()){

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

                }

        }

        public void disableNotifications() {

                this.observable.diableNotifications();

        }

        public void enableNotifications() {

                this.observable.enableNotifications();

        }

        public void getDataCollection(String[] fields, String filter, String order,

                        Observer observer) throws DataException {

                this.getDataCollection(this.getDefaultFeatureType().getSubFeatureType(fields), filter, order, observer);

        }

        public void getDataCollection(FeatureType type, String filter, String order,Observer observer) {

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

            Thread thread = new Thread(task);

            thread.run();

    }

         private class LoadInBackGround implements Runnable{

                    private FeatureStore store;

                    private FeatureType type;

                    private String filter;

                    private String order;

                    private Observer observer;

                        public DataCollection collection = null;

                    public LoadInBackGround(FeatureStore store,FeatureType type, String filter, String order,Observer 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 DefaultFeatureStoreNotification(

                                                                        this.store,

                                                                        FeatureStoreNotification.LOAD_FINISHED,

                                                                        e)

                                                        );

                                }

                                this.observer.update(

                                                this.store, new DefaultFeatureStoreNotification(

                                                                        this.store,

                                                                        FeatureStoreNotification.LOAD_FINISHED,

                                                                        collection)

                                                );

                        }

            }

         public Feature createFeature(FeatureType type, boolean defaultValues) throws InitializeException {

                 Feature feature;

                 try {

                         feature = new CreatedFeature(type,defaultValues);

                 } catch (ReadException e) {

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

                 }

                 return feature;

         }

         public Feature createDefaultFeature(boolean defaultValues) throws InitializeException{

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

         }

        public DataStoreParameters 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.clearResourceObservers();

                this.resouceObservers = null;

        }

        public final void open() throws OpenException {

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_OPEN)

                );

                doOpen();

                this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.AFTER_OPEN)

                );

        }

        public final void close() throws CloseException {

                this.observable.notifyObservers(this,

                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_CLOSE)

            );

                doClose();

        this.observable.notifyObservers(this,

                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.AFTER_CLOSE)

            );

        }

        public final void dispose() throws CloseException{

                this.observable.notifyObservers(this,

                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.BEFORE_DISPOSE)

            );

        doDispose();

        }

        protected abstract void doRefresh() throws OpenException,InitializeException;

        public final void refresh() throws OpenException,InitializeException{

        doRefresh();

        }

        public void notifyResourceChange(){

        this.observable.notifyObservers(this,

                new DefaultFeatureStoreNotification(this,DefaultFeatureStoreNotification.RESOURCE_CHANGED)

            );

        }

        private class ResourceChangedObserver implements Observer{

                private AbstractFeatureStore theStore;

                public ResourceChangedObserver(AbstractFeatureStore theStore){

                        this.theStore = theStore;

                }

                /* (non-Javadoc)

                 * @see org.gvsig.tools.observer.Observer#update(org.gvsig.util.observer.Observable, java.lang.Object)

                 */

                public void update(Observable observable, Object notification) {

                        if (!(notification instanceof ResourceNotification)){

                                return;

                        }

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

                                return;

                        }

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

                                this.theStore.notifyResourceChange();

                        }

                }

        }

        /* (non-Javadoc)

         * @see org.gvsig.fmap.data.feature.FeatureStore#getDefaultFeatureType()

         */

        public FeatureType 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;

        }

        public Feature getFeatureByID(FeatureID id) throws ReadException {

                return this.getFeatureByID(id, null);

        }

        public Object invokeOperation(int code, DataStoreOperationContext context)

                        throws DataStoreOperationException,

                        DataStoreOperationNotSupportedException {

                DataManager manager = DataManager.getManager();

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

        }

        public Object invokeOperation(String name, DataStoreOperationContext context)

                        throws DataStoreOperationException,

                        DataStoreOperationNotSupportedException {

                DataManager manager = DataManager.getManager();

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

        }

        public boolean implementsOperation(int code) {

                DataManager manager = DataManager.getManager();

                return manager.implementsDataStoreOperation(this.getName(), code);

        }

        public boolean implementsOperation(String name) {

                DataManager manager = DataManager.getManager();

                return manager.implementsDataStoreOperation(this.getName(), name);

        }

        private void notifySelectionChange() {

        this.observable.notifyObservers(this,

                                new DefaultFeatureStoreNotification(this,

                                                DefaultFeatureStoreNotification.SELECTION_CHANGE));

        }

        public class SelectionObserver implements Observer {

                private AbstractFeatureStore store;

                public SelectionObserver(AbstractFeatureStore store) {

                        this.store = store;

                }

                public void update(Observable observable, Object notification) {

                        this.store.notifySelectionChange();

                }

        }

        /**

         * Create a default spatial index. If a filename is provided then the index will be persistent

         * (the extension of the resulting index file depends on each implementation).

         *

         * Convenience method for creating a default spatial index that any AbstractFeatureStore subclass can use

         */

        protected void createDefaultSpatialIndex(FeatureType fType, String colName, String filename) throws IndexException {

                // the column must be a geometry, otherwise throw an exception

                FeatureAttributeDescriptor fad = fType.get(colName);

                if (!fad.getDataType().equals(FeatureAttributeDescriptor.TYPE_GEOMETRY)) {

                        throw new IllegalArgumentException("Can't create spatial index because " + colName + " is not a GEOMETRY.");

                }

                SpatialIndex index = null;

                FeatureStore fstore = this;

                try {

                        SpatialIndexFactory factory = SpatialIndexFactory.getFactory(SpatialIndexFactory.Factories.GT2_QUADTREE);

                        SpatialIndexParameters param = new SpatialIndexParameters();

                        param.setEnvelope((Envelope) fstore.getMetadata().get("extent"));

                        DataCollection data = getDataCollection();

                        param.setFeatureCount(data.size());

                        //param.setFilename(((FileStoreParameters) getParameters()).getFile().getAbsolutePath());

                        param.setFilename(filename);

                        param.setOverwrite(true);

                        index = factory.createSpatialIndex(param);

                        Iterator it = data.iterator();

                        int i=0;

                        while (it.hasNext()) {

                                Feature feat = (Feature) it.next();

                                Geometry geom = (Geometry) feat.get(colName);

                                index.insert(geom.getEnvelope(), feat.getID());

                        }

                        indexStore.addIndex(fType, colName, index);

                        if (index instanceof PersistentSpatialIndex) {

                                ((PersistentSpatialIndex)index).flush();

                        }

                } catch (IllegalAccessException e) {

                        throw new IndexException(e);

                } catch (InstantiationException e) {

                        throw new IndexException(e);

                } catch (ReadException e) {

                        throw new IndexException(e);

            } catch (BaseException e) {

                        throw new IndexException(e);

            }

        }

        public boolean hasIndex(FeatureType fType, String colName) {

                return indexStore.contains(fType, colName);

        }

        public FeatureAttributeDescriptor addEvaluatedAttribute(

                        FeatureType featureType, String attributeName,

                        String attributeType, String expression,

                        AttributeValueEvaluator evaluator) throws ReadException {

                if (featureType == null) {

                        featureType = this.getDefaultFeatureType();

                } else {

                        List types = this.getFeatureTypes();

                        if (!types.contains(featureType)) {

                                throw new ReadException("Incompatible feature type", this

                                                .getName());

                        }

                }

                if (evaluator == null) {

                        evaluator = DataManager.getManager().getExpressionParser()

                                        .newAttributeValueEvaluator();

                }

                AttributeDescriptor attr = (AttributeDescriptor) featureType

                                .createNewAttributeDescriptor();

                attr.loading();

                try {

                        attr.setEvalued(true);

                        attr.setName(attributeName);

                        attr.setType(attributeType);

                        attr.setExpression(expression);

                        attr.setEvaluator(evaluator);

                } catch (IsNotAttributeSettingException e) {

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

                }

                featureType.add(attr);

                return attr;

        }

        public void removeEvaluatedAttribute(FeatureAttributeDescriptor attibute)

                        throws DataException {

                // TODO Auto-generated method stub

        }

        public String getClassName() {

                return this.getClass().getName();

        }

        protected FeatureType checkFeatureTypeForCollection(FeatureType fType)

                        throws DataException {

                FeatureType defType = this.getDefaultFeatureType();

                if (fType == null || fType.equals(defType)) {

                        //TODO we must return a copy of Ftype but there are probles with

                        // weakRefs of Ftype of Attributes in edition mode

                        //                        return defType.getSubFeatureType(null);

                        return defType;

                }

                if (fType.isSubtypeOf(defType)) {

                        return fType;

                }

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

                FeatureType tmpType;

                while (iter.hasNext()) {

                        tmpType = (FeatureType) iter.next();

                        if (fType.isSubtypeOf(tmpType)) {

                                return fType;

                        }

                }

                throw new ReadException("invalid type", this.getName());

        }

}