| gvSIG desktop 1

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

import java.text.DateFormat;

import java.text.ParseException;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import org.gvsig.fmap.data.DataException;

import org.gvsig.fmap.data.ReadException;

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

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

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

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

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

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

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

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

public class DBFFeature extends AbstractFeature{

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

        protected DBFStore store;

        protected long featureIndex;

        protected DBFFeature(FeatureType featureType, DBFStore store, long featureIndex) throws ReadException {

                super(featureType);

                this.store=store;

                this.featureIndex=featureIndex;

                load();

        }

        /* (non-Javadoc)

         * @see org.gvsig.fmap.data.feature.AbstractFeature#cloneFeature()

         */

        protected Feature cloneFeature() throws DataException {

                try {

                        return new DBFFeature(this.featureType,this.store,this.featureIndex);

                } catch (ReadException e) {

                        throw new IsNotFeatureSettingException("Clone");

                }

        }

        private void load() throws ReadException{

                Iterator iterator=featureType.iterator();

                this.loading();

                while (iterator.hasNext()) {

                        FeatureAttributeDescriptor descriptor = (FeatureAttributeDescriptor) iterator.next();

                        try {

                                this.loadValue(descriptor);

                        } catch (IsNotFeatureSettingException e) {

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

                        }

                }

                this.stopLoading();

        }

        protected void loadValue(FeatureAttributeDescriptor descriptor)  throws ReadException, IsNotFeatureSettingException{

                int i=((AttributeDescriptor)descriptor).originalPosition();

                String value = null;

                try{

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

                } catch (DataException e){

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

                }

                value=value.trim();

                String fieldType=descriptor.getDataType();

                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.parseBoolean(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,descriptor.getDefaultValue());

                }

        }

        public FeatureID getID() {

                return new DBFFeatureID(this.store,featureIndex);

        }

        public Envelope getExtent(){

                return null;

        }

        public List getAllSRS() {

                return null;

        }

        public String getDefaultSRS() {

                return null;

        }

}