Application: gvSIG desktop

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

import java.io.File;

import java.io.IOException;

import java.sql.Types;

import java.util.List;

import org.apache.log4j.Logger;

import org.gvsig.data.CloseException;

import org.gvsig.data.DataCollection;

import org.gvsig.data.DataExplorer;

import org.gvsig.data.DataStoreParameters;

import org.gvsig.data.InitializeException;

import org.gvsig.data.OpenException;

import org.gvsig.data.ReadException;

import org.gvsig.data.WriteException;

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

import org.gvsig.data.datastores.vectorial.file.shp.SHPStoreParameters;

import org.gvsig.data.datastores.vectorial.file.shp_mem.simplify.DbfMemoryDataSource;

import org.gvsig.data.datastores.vectorial.file.shp_mem.simplify.MemoryShpDriver;

import org.gvsig.data.datastores.vectorial.file.shp_util.DBFDataSource;

import org.gvsig.data.datastores.vectorial.file.shp_util.IGeometricDataStore;

import org.gvsig.data.datastores.vectorial.file.shp_util.NewSHPDataCollection;

import org.gvsig.data.datastores.vectorial.file.shp_util.NewSHPFeature;

import org.gvsig.data.datastores.vectorial.file.shp_util.NewShpFeatureID;

import org.gvsig.data.spatialprovisionalold.Extent;

import org.gvsig.data.spatialprovisionalold.IExtent;

import org.gvsig.data.vectorial.AbstractFeatureStore;

import org.gvsig.data.vectorial.AttributeDescriptor;

import org.gvsig.data.vectorial.DefaultAttributeDescriptor;

import org.gvsig.data.vectorial.DefaultFeatureType;

import org.gvsig.data.vectorial.Feature;

import org.gvsig.data.vectorial.FeatureAttributeDescriptor;

import org.gvsig.data.vectorial.FeatureID;

import org.gvsig.data.vectorial.FeatureType;

import org.gvsig.data.vectorial.IsNotAttributeSettingException;

import org.gvsig.data.vectorial.NewFeatureStoreParameters;

import org.gvsig.exceptions.BaseException;

import org.gvsig.exceptions.DriverException;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.metadata.IMetadata;

import org.opengis.filter.Filter;

import org.opengis.filter.sort.SortBy;

public class MemSHPStore extends AbstractFeatureStore implements

                IGeometricDataStore {

        private static Logger logger = Logger.getLogger(MemSHPStore.class);

        public static final String DATASTORE_NAME = "MemSHPStore";

        static {

                MemSHPRegister.selfRegister();

        }

        protected IMetadata metadata;

        private MemoryShpDriver shp_drv = null;

        private DbfMemoryDataSource dbf_drv = null;

        private File shp_file = null;

        protected FeatureType featureType = null;

        private IExtent extent = null;

        private boolean onlyGeometry = false;

        public void init(DataStoreParameters p) throws InitializeException {

                super.init(p);

                shp_drv = new MemoryShpDriver();

                shp_file = ((SHPStoreParameters) p).getSHPFile();

                File dbff = ((SHPStoreParameters) p).getDBFFile();

                dbf_drv = new DbfMemoryDataSource(dbff);

                featureType = new DefaultFeatureType();

                AttributeDescriptor dad = (AttributeDescriptor) featureType.createNewAttributeDescriptor();

                dad.setOrdinal(featureType.size());

                dad.loading();

                try {

                        dad.setName("GEOMETRY");

                        dad.setType(FeatureAttributeDescriptor.TYPE_GEOMETRY);

                } catch (IsNotAttributeSettingException e) {

                        logger.error("While setting att descriptor: " + e.getMessage());

                }

                dad.stopLoading();

                featureType.add(dad);

                featureType.setDefaultGeometry("GEOMETRY");

        }

        protected void doFinishEdition() throws WriteException, ReadException {

        }

        public DataCollection getDataCollection(FeatureType type, Filter filter,

                        SortBy[] order) throws ReadException {

                return new NewSHPDataCollection(this, shp_drv, dbf_drv, featureType,

                                onlyGeometry, filter, order);

        }

        public Feature getFeatureByID(FeatureID id, FeatureType ft) throws ReadException {

                NewShpFeatureID newid = (NewShpFeatureID) id;

                int ind = newid.getIndex();

                return getFeatureByPosition(ft, ind);

        }

        private Feature getFeatureByPosition(FeatureType ft, int ind) {

                Geometry ig = null;

                try {

                        ig = shp_drv.getShape(ind);

                } catch (IOException e) {

                        logger.debug("While getting geometry: " + e.getMessage());

                }

                NewSHPFeature item = null;

                try {

                        item = new NewSHPFeature(ft, ind, this);

                        item.load(dbf_drv, ig);

                } catch (ReadException e) {

                        logger.error("While loading feature: " + e.getMessage());

                }

                return item;

        }

        public List getFeatureTypes() {

                return null;

        }

        public FeatureType getDefaultFeatureType() {

                return featureType;

        }

        public boolean isWithDefaultLegend() {

                return false;

        }

        public Object getDefaultLegend() {

                return null;

        }

        public Object getDefaultLabelingStrategy() {

                return null;

        }

        public boolean canAlterFeatureType() {

                return false;

        }

        public String getName() {

                return DATASTORE_NAME;

        }

        public void doOpen() throws OpenException {

                try {

                        shp_drv.open(shp_file);

                        shp_drv.initialize();

                        extent = new Extent(shp_drv.getFullExtent());

                        dbf_drv.start();

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

                                featureType.add(createFeatureAttribute(dbf_drv, i, (DefaultFeatureType) featureType));

                        }

                } catch (Exception e) {

                        throw new OpenException(e.getMessage(), DATASTORE_NAME);

                }

        }

        private FeatureAttributeDescriptor createFeatureAttribute(

                        DBFDataSource dbf, int i, DefaultFeatureType ft_type) throws Exception {

                AttributeDescriptor dad = (AttributeDescriptor) ft_type.createNewAttributeDescriptor();

                dad.loading();

                int fieldType = dbf.getFieldType(i);

                // DefaultAttributeDescriptor dad = new DefaultAttributeDescriptor();

                dad.setOrdinal(i);

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

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

                switch (fieldType) {

                case Types.DOUBLE:

                        if (dbf instanceof DbfMemoryDataSource) {

                                DbfMemoryDataSource new_name = (DbfMemoryDataSource) dbf;

                                int prec = new_name.getFieldDecimalPrecision(i);

                                if (prec > 0) {

                                        dad.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                                        dad.setPrecision(prec);

                                } else {

                                        dad.setType(FeatureAttributeDescriptor.TYPE_INT);

                                }

                        } else {

                                dad.setType(FeatureAttributeDescriptor.TYPE_INT);

                        }

                        break;

                case Types.VARCHAR:

                        dad.setType(FeatureAttributeDescriptor.TYPE_STRING);

                        break;

                case Types.DATE:

                        dad.setType(FeatureAttributeDescriptor.TYPE_DATE);

                        break;

                case Types.BOOLEAN:

                        dad.setType(FeatureAttributeDescriptor.TYPE_BOOLEAN);

                        break;

                default:

                        dad.setType(FeatureAttributeDescriptor.TYPE_STRING);

                }

                dad.stopLoading();

                return dad;

        }

        public void doClose() throws CloseException {

                try {

                        shp_drv.close();

                        dbf_drv.stop();

                } catch (Exception e) {

                        throw new CloseException(e.getMessage(), DATASTORE_NAME);

                }

        }

        public void doDispose() {

                shp_drv = null;

        }

        public boolean isEditable() {

                return false;

        }

        public IMetadata getMetadata() throws BaseException {

                return metadata;

        }

        public IExtent getFullExtent() {

                return extent;

        }

        public void setOnlyGeometry(boolean b) {

                onlyGeometry = b;

        }

        public DataExplorer getExplorer() throws ReadException {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        protected void doRefresh() throws OpenException, InitializeException {

                // TODO Auto-generated method stub

        }

}