| gvSIG desktop 1

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

import org.gvsig.data.IDataExplorer;

import org.gvsig.data.IDataStoreParameters;

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

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

        static {

                Register.selfRegister();

        }

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

                        featureType.add(createFeatureAttribute(i));

                    }

            }

         private IFeatureAttributeDescriptor createFeatureAttribute(int i) {

                char fieldType = dbf.getFieldType(i);

                DefaultAttributeDescriptor dad=new DefaultAttributeDescriptor();

                dad.setOrdinal(i);

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

                }

                      return dad;

            }

        protected void doFinishEdition() throws WriteException, ReadException {

                IFeaturesWriter writer = getFeaturesWriter();

        writer.init(this);

        writer.updateFeatureType(featureType);

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

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

                    }

            }

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

        }

        public List getFeatureTypes() {

                featureTypes.set(0,getDefaultFeatureType());

        return featureTypes;

        }

        public IFeatureType getDefaultFeatureType() {

                IFeatureType ft = featureType;

            if (isEditing()){

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

                    return attributeManager.getFeatureType(ft);

            }

        return ft;

        }

        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(

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_OPEN)

                );

                //No hace nada

                this.observable.notifyObservers(

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_OPEN)

                );

        }

        public void close() throws CloseException {

                this.observable.notifyObservers(

                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_CLOSE)

            );

                dbf.close();

        this.observable.notifyObservers(

                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_CLOSE)

            );

        }

        public void dispose() {

                this.observable.notifyObservers(

                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_DISPOSE)

            );

        //No hace nada

        this.observable.notifyObservers(

                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 IDataExplorer getExplorer() {

                // TODO Auto-generated method stub

                return null;

        }

}