Application: gvSIG desktop

package org.gvsig.data.datastores.vectorial.file.dbf;

import java.io.File;

import java.lang.ref.WeakReference;

import java.text.DateFormat;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import org.gvsig.data.DataManager;

import org.gvsig.data.IDataCollection;

import org.gvsig.data.IDataExplorer;

import org.gvsig.data.IDataExplorerParameters;

import org.gvsig.data.IDataStoreParameters;

import org.gvsig.data.datastores.vectorial.IFeaturesWriter;

import org.gvsig.data.datastores.vectorial.file.DataExplorerFileParameters;

import org.gvsig.data.datastores.vectorial.file.dbf.utils.DbaseFile;

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.spatialprovisional.IExtent;

import org.gvsig.data.vectorial.AbstractFeatureStore;

import org.gvsig.data.vectorial.DefaultAttributeDescriptor;

import org.gvsig.data.vectorial.DefaultFeatureType;

import org.gvsig.data.vectorial.FeatureStoreNotification;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureAttributeDescriptor;

import org.gvsig.data.vectorial.IFeatureCollection;

import org.gvsig.data.vectorial.IFeatureID;

import org.gvsig.data.vectorial.IFeatureType;

import org.gvsig.data.vectorial.IsNotAttributeSettingException;

import org.gvsig.data.vectorial.IsNotFeatureSettingException;

import org.gvsig.exceptions.BaseException;

import org.gvsig.metadata.IMetadata;

import org.gvsig.metadata.IMetadataManager;

import org.gvsig.metadata.MetadataManager;

public class DBFStore extends AbstractFeatureStore{

        public static String DATASTORE_NAME = "DBFStore";

        protected DbaseFile dbf = new DbaseFile();

        protected List featureTypes = new ArrayList();//<IFeatureType>

        protected IFeatureType featureType;

        private File file;

        protected IMetadata metadata;

        private DBFStoreParameters dbfParameters=null;

         public void init(IDataStoreParameters parameters) throws InitializeException {

                super.init(parameters);

                    dbfParameters=(DBFStoreParameters)parameters;

                    file=dbfParameters.getDBFFile();

                        dbf.open(file);

                        featureType=new DefaultFeatureType();

                            for (int i = 0; i < dbf.getFieldCount(); i++) {

                                    IFeatureAttributeDescriptor fad;

                                        try {

                                                fad = createFeatureAttribute(i);

                                        } catch (IsNotAttributeSettingException e) {

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

                                        }

                        featureType.add(fad);

                    }

            }

         private IFeatureAttributeDescriptor createFeatureAttribute(int i) throws IsNotAttributeSettingException {

                char fieldType = dbf.getFieldType(i);

                DefaultAttributeDescriptor dad=new DefaultAttributeDescriptor();

                dad.loading();

                dad.setName(dbf.getFieldName(i));

                dad.setSize(dbf.getFieldLength(i));

                if (fieldType == 'L') {

                        dad.setType(IFeatureAttributeDescriptor.TYPE_BOOLEAN);

                } else if ((fieldType == 'F') || (fieldType == 'N')) {

                        int precision = dbf.getFieldDecimalLength(i);

                        if (precision > 0){

                                dad.setType(IFeatureAttributeDescriptor.TYPE_DOUBLE);

                                dad.setPrecision(precision);

                        } else{

                                dad.setType(IFeatureAttributeDescriptor.TYPE_INT);

                        }

                } else if (fieldType == 'C') {

                        dad.setType(IFeatureAttributeDescriptor.TYPE_STRING);

                } else if (fieldType == 'D') {

                        dad.setType(IFeatureAttributeDescriptor.TYPE_DATE);

                } else {

//                    throw new BadFieldDriverException(getName(),null,String.valueOf(fieldType));

                }

                dad.stopLoading();

                      return dad;

            }

        protected void doFinishEdition() throws WriteException, ReadException {

                IFeaturesWriter writer = getFeaturesWriter();

        writer.init(this);

        writer.updateFeatureType(getDefaultFeatureType());

        writer.preProcess();

        Collection collection=getDataCollection();

        Iterator iterator=collection.iterator();

        IFeature feature;

        while (iterator.hasNext()) {

                feature= (IFeature) iterator.next();

                        writer.insertFeature(feature);

                }

        writer.postProcess();

        }

        public IDataCollection getDataCollection(IFeatureType type, String filter, String order) throws ReadException {

                if (type==null){

                        type=getDefaultFeatureType();

                }

                IFeatureCollection coll;

                if (order == null){

                if (featureManager==null){

                                coll=new DBFFeatureCollectionBitSet(this,type,filter);

                        }else{

                                coll=new DBFFeatureCollection(featureManager,this,type,filter);

                        }

                }else{

                        coll=new DBFFeatureCollectionWithFeatureID(featureManager,this,type,filter,order);

                }

                this.addObserver(new WeakReference(coll));

                return coll;

        }

        public IFeature getFeatureByID(IFeatureID id) throws ReadException {

                if (this.alterMode){

                    if (featureManager.contains(id)) {

                            return featureManager.getFeature(id,this);

                    }

            }

                DBFFeature feature=new DBFFeature(getDefaultFeatureType(),this,((DBFFeatureID)id).getIndex());

                return feature;

//                return getFeatureByPosition(featureType,((DBFFeatureID)id).getIndex());

        }

        public List getFeatureTypes() {

                featureTypes.set(0,getDefaultFeatureType());

        return featureTypes;

        }

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

        }

        public boolean isWithDefaultLegend() {

                return false;

        }

        public Object getDefaultLegend() {

                return null;

        }

        public Object getDefaultLabelingStrategy() {

                return null;

        }

        public boolean canAlterFeatureType() {

                return true;

        }

        public String getName() {

                return DATASTORE_NAME;

        }

        public void open() throws OpenException {

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_OPEN)

                );

                //No hace nada

                this.observable.notifyObservers(this,

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_OPEN)

                );

        }

        public void close() throws CloseException {

                this.observable.notifyObservers(this,

                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_CLOSE)

            );

                dbf.close();

        this.observable.notifyObservers(this,

                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_CLOSE)

            );

        }

        public void dispose() {

                this.observable.notifyObservers(this,

                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_DISPOSE)

            );

        //No hace nada

        this.observable.notifyObservers(this,

                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_DISPOSE)

            );

        }

        public boolean isEditable() {

                if (file.canWrite()) return true;

                return false;

        }

        public IMetadata getMetadata() throws BaseException {

                if (metadata==null){

                        IMetadataManager manager=MetadataManager.getManager();

                        metadata=manager.create(DATASTORE_NAME);

                }

                if (this.alterMode){

                        IExtent extent=(IExtent)metadata.get("extent");

                        IFeatureCollection featureCollection=(IFeatureCollection)getDataCollection();

                    if (spatialManager.isFullExtentDirty()){

                            if (!featureCollection.isEmpty()){

                                    Iterator featureIterator=featureCollection.iterator();

                                    extent = ((IFeature)featureIterator.next()).getExtent();

                                    while(featureIterator.hasNext()){

                                            IFeature feature=(IFeature)featureIterator.next();

                                            IExtent boundExtent=feature.getExtent();

                                            if (boundExtent!=null)

                                                    extent.add(boundExtent);

                                    }

                            }

                    }

                    metadata.set("extent",extent);

                }

                return metadata;

        }

//        protected IFeature getFeatureByPosition(IFeatureType ft,long position) throws ReadException {

////                 Field Type (C  or M)

////       char cfieldType = fieldTypes[fieldId];

////       int fieldType = getFieldType(fieldId);

//                DBFFeature feature=new DBFFeature(ft,this,position);

//                feature.load(this.dbf);

//                return feature;

//        }

        protected IFeaturesWriter getFeaturesWriter() {

                IFeaturesWriter writer = new DBFFeaturesWriter();

//                writer.init(this);

                return writer;

        }

        protected long getFeatureCount(){

                return dbf.getRecordCount();

        }

        public IDataStoreParameters getParameters() {

                return parameters;

        }

        public DbaseFile getBaseFile(){

                return dbf;

        }

        public IDataExplorer getExplorer() {

                DataManager dsm=DataManager.getManager();

                IDataExplorerParameters dsp = dsm.createDataExplorerParameters(

                                DBFDataExplorer.DATASOURCE_NAME);

                ((DataExplorerFileParameters)dsp).setSource(dbfParameters.getFile().getParentFile());

                IDataExplorer src=null;

                try {

                        src = dsm.createDataExplorer(dsp);

                } catch (InitializeException e1) {

                        e1.printStackTrace();

                }

                return src;

        }

}