Application: gvSIG desktop

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

import java.lang.ref.WeakReference;

import java.security.KeyException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

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

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

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

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

import org.gvsig.data.vectorial.AttributeDescriptor;

import org.gvsig.data.vectorial.FeatureStore;

import org.gvsig.data.vectorial.FeatureStoreNotification;

import org.gvsig.data.vectorial.FeatureType;

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.exceptions.BaseException;

import org.gvsig.metadata.IMetadata;

import org.gvsig.metadata.IMetadataManager;

import org.gvsig.metadata.MetadataManager;

public class DBFStore extends FeatureStore{

        public static String DATASTORE_NAME = "DBFStore";

        protected DBFResource dbf= null;

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

        protected IFeatureType featureType;

        protected IMetadata metadata;

        private DBFStoreParameters dbfParameters=null;

         public void init(IDataStoreParameters parameters) throws InitializeException {

                super.init(parameters);

                    dbfParameters=(DBFStoreParameters)parameters;

                    DBFResource tmpResoure = new DBFResource(dbfParameters.getDBFFile());

                    ResourceManager resMan = ResourceManager.getResourceManager();

                    try {

                                this.dbf = (DBFResource)resMan.addResource(tmpResoure);

                        } catch (DataException e1) {

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

                        }

//                        this.dbf.open();

//                        this.dbf.addObserver(this);

                    int fieldCount = -1;

                    try{

                            fieldCount =dbf.getFieldCount();

                    } catch (DataException e) {

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

                        }

                        featureType=new FeatureType();

                            for (int i = 0; i < fieldCount; i++) {

                                    IFeatureAttributeDescriptor fad;

                                        try {

                                                fad = createFeatureAttribute(i);

                                        } catch (IsNotAttributeSettingException e) {

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

                                        } catch (ReadException e) {

                                                // TODO Auto-generated catch block

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

                                        }

                        featureType.add(fad);

                    }

            }

         private IFeatureAttributeDescriptor createFeatureAttribute(int i) throws ReadException, IsNotAttributeSettingException {

                char fieldType = dbf.getFieldType(i);

                AttributeDescriptor dad=new AttributeDescriptor();

                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;

        }

        protected void doOpen() throws OpenException {

                //No hace nada

        }

        protected void doClose() throws CloseException {

                try {

                        dbf.close();

                } catch (DataException e) {

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

                }

        }

        protected void doDispose() throws CloseException {

                ResourceManager resMan = ResourceManager.getResourceManager();

            try {

                        resMan.remove(this.dbf);

                } catch (DataException e1) {

                        throw new CloseException(this.getName(),e1);

                } catch (KeyException e) {

                        // TODO Auto-generated catch block

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

                }

                this.dbf = null;

                this.featureType=null;

                this.metadata=null;

        }

        public boolean isEditable() {

                if (dbf.getFile().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() throws ReadException{

                return dbf.getRecordCount();

        }

        public IDataStoreParameters getParameters() {

                return parameters;

        }

        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;

        }

}