Application: gvSIG desktop

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

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.channels.FileChannel;

import java.nio.channels.WritableByteChannel;

import java.nio.charset.Charset;

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

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

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

import org.gvsig.data.exception.DataException;

import org.gvsig.data.exception.InitializeWriterException;

import org.gvsig.data.exception.OpenException;

import org.gvsig.data.exception.ReadException;

import org.gvsig.data.exception.UnsupportedEncodingException;

import org.gvsig.data.exception.WriteException;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureStore;

import org.gvsig.data.vectorial.IFeatureType;

public class DBFFeaturesWriter implements IFeaturesWriter {

        private DbaseFileWriter dbfWrite;

        private DbaseFileHeader myHeader;

        private IFeatureType featureType;

        private File dbfFile;

        protected int numRows;

        private Charset charset = Charset.forName("ISO-8859-1");

        public void setFile(File file){

                dbfFile=file;

        }

        public void init(IFeatureStore store) throws InitializeWriterException {

                DBFStoreParameters parameters=(DBFStoreParameters)store.getParameters();

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

        }

        public void postProcess() throws OpenException, WriteException {

                // TODO: Elimiar las copias generadas del fichero de copia

                //   para el cancelProcess ??

                try {

                        myHeader.setNumRecords(numRows);

                        dbfWrite = new DbaseFileWriter(myHeader,

                                        (FileChannel) getWriteChannel(dbfFile.getAbsolutePath()));

                } catch (IOException e) {

                        throw new WriteException(DBFStore.DATASTORE_NAME,e);

                }

        }

        public void preProcess() throws WriteException, ReadException {

                // TODO: Hacer copias de los fichero si ya existen para

                // en cancelProcess ???

                myHeader = DbaseFileHeader.createDbaseHeader(featureType);

                myHeader.setNumRecords(0);

                numRows = 0;

                try {

                        dbfWrite = new DbaseFileWriter(myHeader,

                                        (FileChannel) getWriteChannel(dbfFile.getAbsolutePath()));

                        dbfWrite.setCharset(charset);

                } catch (IOException e) {

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

                }

        }

        public void insertFeature(IFeature feature) throws WriteException, UnsupportedEncodingException {

                dbfWrite.write(feature);

                numRows++;

        }

        public void updateFeatureType(IFeatureType featureType) {

                this.featureType=featureType;

        }

        protected static WritableByteChannel getWriteChannel(String path) throws IOException {

                WritableByteChannel 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);

                        }

                }

                RandomAccessFile raf = new RandomAccessFile(f, "rw");

                channel = raf.getChannel();

                return channel;

        }

        public static void create(DBFStoreParameters parameters, IFeatureType featureType)throws OpenException, WriteException {

                DbaseFileHeader myHeader = DbaseFileHeader.createDbaseHeader(featureType);

                try {

                        FileChannel filechannel=(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.IFeaturesWriter#cancelProcess()

         */

        public void cancelProcess() throws WriteException {

                // TODO Auto-generated method stub

                // RESTAURAR Ficheros anteriores????

        }

        /* (non-Javadoc)

         * @see org.gvsig.data.datastores.vectorial.IFeaturesWriter#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;

        }

}