Application: gvSIG desktop

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

import java.io.File;

import java.io.IOException;

import org.gvsig.data.DataException;

import org.gvsig.data.OpenException;

import org.gvsig.data.ReadException;

import org.gvsig.data.WriteException;

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

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

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

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

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

import org.gvsig.data.vectorial.Feature;

import org.gvsig.data.vectorial.FeatureStore;

import org.gvsig.data.vectorial.FeatureType;

import org.gvsig.datasources.common.ICharset;

import org.gvsig.datasources.common.IRandomAccessFile;

import org.gvsig.datasources.common.IRandomFileChannel;

import org.gvsig.datasources.impljme.Impl;

public class DBFFeaturesWriter implements FeaturesWriter {

        private DbaseFileWriter dbfWrite;

        private DbaseFileHeader myHeader;

        private FeatureType featureType;

        private File dbfFile;

        protected int numRows;

        private ICharset charset = Impl.getCharsetForName("ISO-8859-1");

        public void setFile(File file) {

                dbfFile = file;

        }

        public void init(FeatureStore store) throws InitializeWriterException {

                DBFStoreParameters parameters = (DBFStoreParameters) store

                                .getParameters();

                dbfFile = ((DBFStoreParameters) parameters).getDBFFile();

        }

        public void postProcess() throws OpenException, WriteException {

                try {

                        myHeader.setNumRecords(numRows);

                        dbfWrite = new DbaseFileWriter(myHeader, getWriteChannel(dbfFile

                                        .getAbsolutePath()));

                } catch (IOException e) {

                        throw new WriteException(DBFStore.DATASTORE_NAME, e);

                }

        }

        public void preProcess() throws WriteException, ReadException {

                myHeader = DbaseFileHeader.createDbaseHeader(featureType);

                myHeader.setNumRecords(0);

                numRows = 0;

                try {

                        dbfWrite = new DbaseFileWriter(myHeader, getWriteChannel(dbfFile

                                        .getAbsolutePath()));

                        dbfWrite.setCharset(charset);

                } catch (IOException e) {

                        throw new InitializeWriterException("DBF Feature Writer", e);

                }

        }

        public void insertFeature(Feature feature) throws WriteException,

                        UnsupportedEncodingException {

                dbfWrite.write(feature);

                numRows++;

        }

        public void updateFeatureType(FeatureType featureType) {

                this.featureType = featureType;

        }

        protected static IRandomFileChannel getWriteChannel(String path)

                        throws IOException {

                IRandomFileChannel channel;

                File f = new File(path);

                if (!f.exists()) {

                        // System.out.println("Creando fichero " + f.getAbsolutePath());

                        if (!f.createNewFile()) {

                                System.err.print("Error al crear el fichero "

                                                + f.getAbsolutePath());

                                throw new IOException("Cannot create file " + f);

                        }

                }

                IRandomAccessFile raf = Impl.getRandomAccessFile(f, "rw");

                channel = raf.getChannel();

                return channel;

        }

        public static void create(DBFStoreParameters parameters,

                        FeatureType featureType) throws OpenException, WriteException {

                DbaseFileHeader myHeader = DbaseFileHeader

                                .createDbaseHeader(featureType);

                try {

                        IRandomFileChannel filechannel = getWriteChannel(parameters

                                        .getDBFFile().getAbsolutePath());

                        DbaseFileWriter dbfWrite = new DbaseFileWriter(myHeader,

                                        filechannel);

                        filechannel.close();

                } catch (IOException e) {

                        throw new InitializeWriterException("DBF Feature Writer", e);

                }

        }

        /* (non-Javadoc)

         * @see org.gvsig.data.datastores.vectorial.FeaturesWriter#cancelProcess()

         */

        public void cancelProcess() throws WriteException {

                // TODO Auto-generated method stub

                // RESTAURAR Ficheros anteriores????

        }

        /* (non-Javadoc)

         * @see org.gvsig.data.datastores.vectorial.FeaturesWriter#dispose()

         */

        public void dispose() throws DataException {

                this.dbfFile = null;

                if (this.dbfWrite != null){

                        this.dbfWrite.close();

                        this.dbfWrite = null;

                }

                this.featureType = null;

                this.myHeader = null;

        }

}