Application: gvSIG desktop

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

import java.text.DateFormat;

import java.text.ParseException;

import java.util.Date;

import java.util.List;

import java.util.Locale;

import org.gvsig.data.DataException;

import org.gvsig.data.ReadException;

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

import org.gvsig.data.vectorial.AbstractFeature;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.Envelope;

public class ShpFeature extends AbstractFeature {

        protected static Locale ukLocale = new Locale("en", "UK");

        private SHPStore store;

        private long featureIndex;

        ShpFeature(FeatureType featureType, SHPStore store, long featureIndex) throws ReadException {

                super(featureType);

                this.store = store;

                this.featureIndex = featureIndex;

        }

        void load(Geometry geometry) throws ReadException, IsNotFeatureSettingException {

                for (int i = 0; i < featureType.size(); i++) {

                        FeatureAttributeDescriptor descriptor = (FeatureAttributeDescriptor) featureType

                                        .get(i);

                        String fieldType = descriptor.getDataType();

                        if (fieldType.equals(FeatureAttributeDescriptor.TYPE_GEOMETRY)) {

                                setGeometry(i, geometry);

                        }

                }

        }

        void load(DbaseFile dbf, Geometry geometry) throws ReadException, IsNotFeatureSettingException {

                loading();

                for (int i = 0; i < featureType.size(); i++) {

                        FeatureAttributeDescriptor descriptor = (FeatureAttributeDescriptor) featureType

                                        .get(i);

                        String fieldType = descriptor.getDataType();

                        if (fieldType.equals(FeatureAttributeDescriptor.TYPE_GEOMETRY)) {

                                this.setGeometry(i, geometry);

                        }

                        if (dbf.getFieldCount() <= i)

                                return;

                        String value = dbf.getStringFieldValue((int) this.featureIndex, i);

                        value = value.trim();

                        if (fieldType.equals(FeatureAttributeDescriptor.TYPE_STRING)) {

                                this.set(i, value);

                        } else if (fieldType

                                        .equals(FeatureAttributeDescriptor.TYPE_DOUBLE)) {

                                try {

                                        Double.parseDouble(value);

                                } catch (NumberFormatException e) {

                                        value = "0";

                                }

                                this.set(i, Double.parseDouble(value));

                        } else if (fieldType.equals(FeatureAttributeDescriptor.TYPE_INT)) {

                                this.set(i, Integer.parseInt(value));

                        } else if (fieldType.equals(FeatureAttributeDescriptor.TYPE_FLOAT)) {

                                this.set(i, Float.parseFloat(value));

                        } else if (fieldType.equals(FeatureAttributeDescriptor.TYPE_LONG)) {

                                this.set(i, Long.parseLong(value));

                        } else if (fieldType

                                        .equals(FeatureAttributeDescriptor.TYPE_BOOLEAN)) {

                                this.set(i, Boolean.valueOf(value));

                        } else if (fieldType.equals(FeatureAttributeDescriptor.TYPE_BYTE)) {

                                this.set(i, Byte.parseByte(value));

                        } else if (fieldType.equals(FeatureAttributeDescriptor.TYPE_DATE)) {

                                String year = value.substring(0, 4);

                                String month = value.substring(4, 6);

                                String day = value.substring(6, 8);

                                DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT,

                                                ukLocale);

                                /*

                                 * Calendar c = Calendar.getInstance(); c.clear();

                                 * c.set(Integer.parseInt(year), Integer.parseInt(month),

                                 * Integer.parseInt(day)); c.set(Calendar.MILLISECOND, 0);

                                 */

                                String strAux = month + "/" + day + "/" + year;

                                Date dat = null;

                                try {

                                        dat = df.parse(strAux);

                                } catch (ParseException e) {

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

                                }

                                this.set(i, dat);

                        } else {

                                this.set(i, null);

                        }

                }

                stopLoading();

        }

        public FeatureID getID() {

                return new ShpFeatureID(this.store, featureIndex);

        }

        public Envelope getExtent() {

                return store.getBoundingBox(featureIndex);

        }

        public List getAllSRS() {

                // TODO Auto-generated method stub

                return null;

        }

        public String getDefaultSRS() {

                // TODO Auto-generated method stub

                return null;

        }

        protected Feature cloneFeature() throws DataException {

                try {

                        return new ShpFeature(this.featureType,(SHPStore)this.store,this.featureIndex);

                } catch (ReadException e) {

                        throw new IsNotFeatureSettingException("Clone");

                }

        }

        // public int[] getGeometryTypes() {

        // IGeometry geometry= (IGeometry)getDefaultGeometry();

        // if (geometry!=null)

        // return new int[]{geometry.getGeometryType()};

        // return null;

        // }

        public int[] getGeometryTypes() {

                Geometry geometry= (Geometry)getDefaultGeometry();

                if (geometry!=null)

                        return new int[]{geometry.getType()};

                return null;

        }

}