Application: gvSIG desktop

package com.hardcode.gdbms.driver.dbf;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.io.UnsupportedEncodingException;

import java.nio.channels.FileChannel;

import java.nio.channels.WritableByteChannel;

import java.sql.Types;

import java.text.DateFormat;

import java.text.ParseException;

import java.util.Date;

import java.util.Locale;

import com.hardcode.gdbms.driver.DriverUtilities;

import com.hardcode.gdbms.engine.data.DataSourceFactory;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.hardcode.gdbms.engine.data.driver.FileDriver;

import com.hardcode.gdbms.engine.data.edition.DataWare;

import com.hardcode.gdbms.engine.data.file.FileDataWare;

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

import com.iver.cit.gvsig.fmap.drivers.dbf.DbaseFile;

import com.iver.cit.gvsig.fmap.drivers.shp.DbaseFileHeaderNIO;

import com.iver.cit.gvsig.fmap.drivers.shp.DbaseFileWriterNIO;

/**

 * DOCUMENT ME!

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class DBFDriver implements FileDriver {

    //private File file;

    private static Locale ukLocale = new Locale("en", "UK"); // English, UK version

    private DbaseFile dbf = new DbaseFile();

    private char[] fieldTypes;

    private DataSourceFactory dsf;

    /**

     * @see com.hardcode.driverManager.Driver#getName()

     */

    public String getName() {

        return "gdbms dbf driver";

    }

    /**

     * @see com.hardcode.gdbms.engine.data.GDBMSDriver#open(java.io.File)

     */

    public void open(File file) throws IOException {

         dbf.open(file);

        try {

            fieldTypes = new char[getFieldCount()];

            for (int i = 0; i < fieldTypes.length; i++) {

                fieldTypes[i] = dbf.getFieldType(i);

            }

        } catch (DriverException e) {

            throw new IOException(e.getMessage());

        }

    }

    /**

     * @see com.hardcode.gdbms.engine.data.GDBMSDriver#close()

     */

    public void close() throws IOException {

        dbf.close();

    }

    /**

     * @see com.hardcode.gdbms.engine.data.driver.ReadAccess#getFieldValue(long,

     *      int)

     */

    public Value getFieldValue(long rowIndex, int fieldId)

    throws DriverException {

            // Field Type (C  or M)

            char cfieldType = fieldTypes[fieldId];

            int fieldType = getFieldType(fieldId);

            String strValue;

            if (cfieldType == 'D') {

                    String date;

                    try {

                            date = dbf.getStringFieldValue((int) rowIndex, fieldId).trim();

                    } catch (UnsupportedEncodingException e1) {

                            throw new DriverException(e1);

                    }

                    // System.out.println(rowIndex + " data=" + date);

                    if (date.length() == 0) {

                            return null;

                    }

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

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

                    String day = date.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;

                    try {

                            dat = df.parse(strAux);

                    } catch (ParseException e) {

                            throw new DriverException("Bad Date Format");

                    }

                    // System.out.println("numReg = " + rowIndex + " date:" + dat.getTime());

                    return ValueFactory.createValue(dat);

            } else {

                    try {

                            strValue = dbf.getStringFieldValue((int) rowIndex, fieldId);

                    } catch (UnsupportedEncodingException e1) {

                            e1.printStackTrace();

                            throw new DriverException(e1);

                    }

                    strValue = strValue.trim();

                           if (fieldType == Types.BOOLEAN){

                                   strValue = strValue.toLowerCase();

                                 strValue = Boolean.toString(strValue.equals("t") || strValue.equals("y"));

                           }

                    try {

                            return ValueFactory.createValueByType(strValue, fieldType);

                    } catch (Exception e) {

                            if (fieldType == Types.INTEGER){

                                    // Habria que quejarse???

                                    return ValueFactory.createValue(0);

                            } else{

                                        // OJO: Habria que revisar el resto de tipos

                                        // De momento lanzamos la excepcion

                                    throw new DriverException("Bad Field Value: '" + strValue+"' (rowIndes: "+rowIndex + " fielId: "+ fieldId +" fieldType: " + fieldType + ")");

                            }

                    }

            }

    }

    /**

     * @see com.hardcode.gdbms.engine.data.driver.ReadAccess#getFieldCount()

     */

    public int getFieldCount() throws DriverException {

        return dbf.getFieldCount();

    }

    /**

     * @see com.hardcode.gdbms.engine.data.driver.ReadAccess#getFieldName(int)

     */

    public String getFieldName(int fieldId) throws DriverException {

        return dbf.getFieldName(fieldId);

    }

    /**

     * @see com.hardcode.gdbms.engine.data.driver.ReadAccess#getRowCount()

     */

    public long getRowCount() throws DriverException {

        return dbf.getRecordCount();

    }

    /**

     * @see com.hardcode.gdbms.engine.data.driver.FileDriver#fileAccepted(java.io.File)

     */

    public boolean fileAccepted(File f) {

        return f.getAbsolutePath().toUpperCase().endsWith("DBF");

    }

    /**

     * @see com.hardcode.gdbms.engine.data.driver.ObjectDriver#getFieldType(int)

     */

    public int getFieldType(int i) throws DriverException {

        char fieldType = fieldTypes[i];

        if (fieldType == 'L') {

            return Types.BOOLEAN;

        } else if ((fieldType == 'F') || (fieldType == 'N')) {

            return Types.DOUBLE;

        } else if (fieldType == 'C') {

            return Types.VARCHAR;

        } else if (fieldType == 'D') {

            return Types.DATE;

        } else {

            throw new DriverException("Unknown field type");

        }

    }

    /**

     * @see com.hardcode.gdbms.engine.data.driver.DriverCommons#setDataSourceFactory(com.hardcode.gdbms.engine.data.DataSourceFactory)

     */

    public void setDataSourceFactory(DataSourceFactory dsf) {

        this.dsf = dsf;

    }

    private void writeToTemp(DataWare dataWare, File file) throws DriverException {

        DbaseFileWriterNIO dbfWrite = null;

        DbaseFileHeaderNIO myHeader;

        Value[] record;

        try {

            myHeader = DbaseFileHeaderNIO.createDbaseHeader(dataWare);

            myHeader.setNumRecords((int) dataWare.getRowCount());

            dbfWrite = new DbaseFileWriterNIO(myHeader,

                    (FileChannel) getWriteChannel(file.getPath()));

            record = new Value[dataWare.getFieldCount()];

            for (int j = 0; j < dataWare.getRowCount(); j++) {

                for (int r = 0; r < dataWare.getFieldCount(); r++) {

                    record[r] = dataWare.getFieldValue(j, r);

                }

                dbfWrite.write(record);

            }

            dbfWrite.close();

        } catch (IOException e) {

            throw new DriverException(e);

        }

    }

    /**

     * @see com.hardcode.gdbms.engine.data.driver.FileDriver#writeFile(com.hardcode.gdbms.engine.data.file.FileDataWare,

     *      java.io.File)

     */

    public void writeFile(FileDataWare dataWare)

        throws DriverException {

        String temp = dsf.getTempFile();

        writeToTemp(dataWare, new File(temp));

        try {

            FileChannel fcout = dbf.getWriteChannel();

            FileChannel fcin = new FileInputStream(temp).getChannel();

            DriverUtilities.copy(fcin, fcout);

        } catch (IOException e) {

            throw new DriverException(e);

        }

    }

    /**

     * DOCUMENT ME!

     *

     * @param path DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     *

     * @throws IOException DOCUMENT ME!

     */

    private 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()) {

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

            }

        }

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

        channel = raf.getChannel();

        return channel;

    }

    public void createSource(String arg0, String[] arg1, int[] arg2) throws IOException {

        DbaseFileHeaderNIO myHeader;

        int[] lengths = new int[arg2.length];

        for (int i = 0; i < arg2.length; i++) {

            lengths[i] = 100;

        }

        myHeader = DbaseFileHeaderNIO.createDbaseHeader(arg1, arg2, lengths);

        myHeader.setNumRecords(0);

        DbaseFileWriterNIO dbfWrite = new DbaseFileWriterNIO(myHeader,

                (FileChannel) getWriteChannel(arg0));

        dbfWrite = new DbaseFileWriterNIO(myHeader,

                (FileChannel) getWriteChannel(arg0));

    }

        public int getFieldWidth(int i) throws DriverException {

                return dbf.getFieldLength(i);

        }

}