Application: gvSIG desktop

package org.gvsig.fmap.data.feature.file.dbf.deprecated;

import java.lang.ref.WeakReference;

import java.security.KeyException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import org.gvsig.fmap.data.DataSet;

import org.gvsig.fmap.data.DataExplorer;

import org.gvsig.fmap.data.DataExplorerParameters;

import org.gvsig.fmap.data.DataManager;

import org.gvsig.fmap.data.DataStoreParameters;

import org.gvsig.fmap.data.exceptions.CloseException;

import org.gvsig.fmap.data.exceptions.DataException;

import org.gvsig.fmap.data.exceptions.InitializeException;

import org.gvsig.fmap.data.exceptions.OpenException;

import org.gvsig.fmap.data.exceptions.ReadException;

import org.gvsig.fmap.data.exceptions.WriteException;

import org.gvsig.fmap.data.feature.Feature;

import org.gvsig.fmap.data.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.data.feature.FeatureSet;

import org.gvsig.fmap.data.feature.FeatureReference;

import org.gvsig.fmap.data.feature.FeatureType;

import org.gvsig.fmap.data.feature.exceptions.InitializeWriterException;

import org.gvsig.fmap.data.feature.file.FileExplorerParameters;

import org.gvsig.fmap.data.feature.file.FileStore;

import org.gvsig.fmap.data.feature.impl.DefaultFeatureType;

import org.gvsig.fmap.data.feature.impl.FeaturesWriter;

import org.gvsig.fmap.data.feature.spi.FeatureData;

import org.gvsig.fmap.data.impl.DefaultDataManager;

import org.gvsig.fmap.data.resource.ResourceManager;

import org.gvsig.fmap.data.resource.impl.DefaultResourceManager;

import org.gvsig.metadata.DefaultMetadataManager;

import org.gvsig.metadata.Metadata;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.tools.exception.BaseException;

/**

 * @deprecated

 *

 * @author jjdelcerro

 * 

 */

public class DBFStore extends FileStore {

        public static String DATASTORE_NAME = "DBFStore";

        private DBFResource dbf= null;

        protected Metadata metadata;

        private DBFStoreParameters dbfParameters=null;

         public void init(DataStoreParameters parameters) throws InitializeException {

                 dbfParameters=(DBFStoreParameters)parameters;

                 DBFResource tmpResource = new DBFResource(dbfParameters);

                 DefaultResourceManager resMan = DefaultResourceManager.getResourceManager();

                 try {

                         this.dbf = (DBFResource) resMan.addResource(tmpResource, this);

                 } catch (DataException e1) {

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

                 }

                 super.init(parameters,this.dbf);

//                 this.dbf.open();

//                 this.dbf.addObserver(this);

                 this.initFeatureType();

         }

         private void initFeatureType() throws InitializeException{

                 int fieldCount = -1;

                 try {

                         fieldCount = dbf.getFieldCount();

                } catch (DataException e) {

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

                }

                 defaultFeatureType = new DefaultFeatureType();

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

                         FeatureAttributeDescriptor fad;

                        try {

                                fad = createFeatureAttribute(

                                                (DefaultFeatureType) defaultFeatureType, i);

                        } catch (IsNotAttributeSettingException e) {

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

                        } catch (ReadException e) {

                                // TODO Auto-generated catch block

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

                        }

                        defaultFeatureType.add(fad);

                }

                 this.featureTypes = new ArrayList();

                 this.featureTypes.add(defaultFeatureType);

         }

         private FeatureAttributeDescriptor createFeatureAttribute(DefaultFeatureType fType, int i) throws ReadException, IsNotAttributeSettingException {

                char fieldType = dbf.getFieldType(i);

                AttributeDescriptor dad=(AttributeDescriptor) fType.createAttributeDescriptor();

                dad.loading();

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

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

                if (fieldType == 'L') {

                        dad.setType(FeatureAttributeDescriptor.BOOLEAN);

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

                        int precision = dbf.getFieldDecimalLength(i);

                        if (precision > 0){

                                dad.setType(FeatureAttributeDescriptor.DOUBLE);

                                dad.setPrecision(precision);

                        } else{

                                dad.setType(FeatureAttributeDescriptor.INT);

                        }

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

                        dad.setType(FeatureAttributeDescriptor.STRING);

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

                        dad.setType(FeatureAttributeDescriptor.DATE);

                } else {

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

                }

                dad.stopLoading();

                      return dad;

            }

        protected void doFinishEdition() throws WriteException, ReadException {

                FeaturesWriter writer = getFeaturesWriter();

        writer.init(this);

        writer.updateFeatureType(this.getDefaultFeatureType());

        this.dbf.editing();

        writer.preProcess();

        Collection collection=getDataSet();

        Iterator iterator=collection.iterator();

        Feature feature;

        while (iterator.hasNext()) {

                feature= (Feature) iterator.next();

                        writer.insertFeature(feature);

                }

        writer.postProcess();

        this.dbf.stopEditing();

        this.dbf.changed(this);

        }

        public DataSet getDataCollection(FeatureType type, String filter, String order) throws ReadException {

                try {

                        type = this.checkFeatureTypeForCollection(type);

                } catch (DataException e) {

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

                }

                FeatureSet 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 FeatureData getFeatureDataByID(FeatureReference id, FeatureType featureType)

                        throws DataException {

                if (featureType == null){

                        featureType=this.getDefaultFeatureType();

                } else{

                        if (!featureType.isSubtypeOf(this.getDefaultFeatureType())){

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

                        }

                }

                if (this.alterMode){

                    if (featureManager.contains(id)) {

                            return featureManager.getFeature(id,this,featureType);

                    }

            }

                return this.getFeatureByIndex(((DBFFeatureID) id).getIndex(),

                                featureType);

        }

        /**

         *

         * Only for persistenced features

         *

         * @param index

         * @param featureType

         * @return

         * @throws ReadException

         */

        protected Feature getFeatureByIndex(long index, FeatureType featureType)

                        throws ReadException {

                if (index >= this.getFeatureCount()) {

                        throw new ReadException(this.getName(),

                                        "Unsupported operation for not persistented features");

                }

                DBFFeature feature = new DBFFeature(featureType, this, index);

                return feature;

        }

        /***

         * NOT supported in Alter Mode

         *

         * @param index

         * @return

         * @throws ReadException

         */

        protected Feature getFeatureDataByIndex(long index) throws ReadException {

                return this.getFeatureByIndex(index, this.getDefaultFeatureType());

        }

        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 {

                super.doDispose();

                ResourceManager resMan = DefaultResourceManager.getResourceManager();

            try {

                        resMan.remove(this.dbf, this);

                } 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.metadata=null;

        }

        public boolean allowWrite() {

                return this.dbf.isEditable();

        }

        public Metadata getMetadata() throws BaseException {

                if (metadata==null){

                        MetadataManager manager=DefaultMetadataManager.getManager();

                        metadata=manager.create(DATASTORE_NAME);

                }

                return metadata;

        }

//        protected Feature getFeatureByPosition(FeatureType 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 FeaturesWriter getFeaturesWriter() throws InitializeWriterException{

                FeaturesWriter writer = new DBFFeaturesWriter();

//                writer.init(this);

                return writer;

        }

        protected long getFeatureCount() throws ReadException{

                return dbf.getRecordCount();

        }

        public DataStoreParameters getParameters() {

                return parameters;

        }

        public DataExplorer getExplorer() throws InitializeException {

                DataManager dsm=DefaultDataManager.getManager();

                DataExplorerParameters dsp = dsm.createExplorerParameters(

                                DBFDataExplorer.DATASOURCE_NAME);

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

                DataExplorer src=null;

                try {

                        src = dsm.createExplorer(dsp);

                } catch (InitializeException e1) {

                        e1.printStackTrace();

                }

                return src;

        }

        /* (non-Javadoc)

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

         */

        protected void doRefresh() throws OpenException, InitializeException {

                this.initFeatureType();

        }

        /**

         * @param i

         * @param i2

         * @return

         * @throws ReadException

         */

        protected String getStringFieldValue(int rowIndex, int fieldId) throws ReadException {

                return this.dbf.getStringFieldValue(rowIndex, fieldId);

        }

        public boolean canWriteGeometry(int gvSIGgeometryType) {

                try {

                        return getFeaturesWriter().canWriteGeometry(gvSIGgeometryType);

                } catch (InitializeWriterException e) {

                        e.printStackTrace();

                }

                return false;

        }

        public String getClassName() {

                // TODO Auto-generated method stub

                return null;

        }

}