| gvSIG desktop 1

package com.iver.cit.gvsig.fmap.drivers.dbf;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

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 java.util.Properties;

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

import com.iver.cit.gvsig.fmap.drivers.ITableDefinition;

import com.iver.cit.gvsig.fmap.drivers.TableDefinition;

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

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

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.edition.IRowEdited;

import com.iver.cit.gvsig.fmap.edition.IWriteable;

import com.iver.cit.gvsig.fmap.edition.IWriter;

import com.iver.cit.gvsig.fmap.edition.fieldmanagers.AbstractFieldManager;

import com.iver.cit.gvsig.fmap.edition.writers.dbf.DbfWriter;

import com.iver.utiles.NumberUtilities;

/**

 * DOCUMENT ME!

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class DBFDriver extends AbstractFieldManager implements FileDriver, IWriteable, IWriter {

    //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;

    private DbfWriter dbfWriter = new DbfWriter();

        private File file = null;

        private static String tempDirectoryPath = System.getProperty("java.io.tmpdir");

        private File fTemp;

    private ITableDefinition tableDef;

    /**

     * @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 {

            this.file  = file;

        dbf.open(file);

        try {

            fieldTypes = new char[getFieldCount()];

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

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

            }

                    int aux = (int)(Math.random() * 1000);

                    fTemp = new File(tempDirectoryPath + "/tmpDbf" + aux + ".dbf");            

                    dbfWriter.setFile(fTemp);

        } 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 fieldType = fieldTypes[fieldId];

        if (fieldType == 'L') {

            return ValueFactory.createValue(dbf.getBooleanFieldValue(

                    (int) rowIndex, fieldId));

            /*                }else if (fieldType == 'N'){

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

               long value = Long.parseLong(strValue);

               if ((value > Integer.MIN_VALUE) && (value < Integer.MAX_VALUE)){

                       return new IntValue((int) value);

               }else{

                       return new LongValue(value);

               }

             */

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

            String strValue;

                        try {

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

                                                     .trim();

                        } catch (UnsupportedEncodingException e1) {

                                e1.printStackTrace();

                                throw new DriverException(e1);

                        }

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

                return null;

            }

            double value=0;

            try{

            value = Double.parseDouble(strValue);

            }catch (Exception e) {

                                return ValueFactory.createValue(0D);

                        }

            return ValueFactory.createValue(value);

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

            try {

                                return ValueFactory.createValue(dbf.getStringFieldValue(

                                        (int) rowIndex, fieldId).trim());

                        } catch (UnsupportedEncodingException e) {

                                throw new DriverException(e);

                        }

        } else if (fieldType == '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 {

            throw new DriverException("Unknown field type");

        }

    }

    /**

     * @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')) {

                if (dbf.getFieldDecimalLength(i)>0)

                        return Types.DOUBLE;

                else

                        return Types.INTEGER;

        } 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;

    }

    /* (non-Javadoc)

     * @see com.hardcode.gdbms.engine.data.driver.FileDriver#createSource(java.lang.String, java.lang.String[], int[])

     */

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

        }

        public IWriter getWriter() {

                return this;

        }

        public void preProcess() throws EditionException {

                dbfWriter.preProcess();

        }

        public void process(IRowEdited row) throws EditionException {

                dbfWriter.process(row);

        }

        public void postProcess() throws EditionException {

                dbfWriter.postProcess();

                try {

                        // Dbf

                        File dbfFile = fTemp;

                        FileChannel fcinDbf = new FileInputStream(dbfFile).getChannel();

                        FileChannel fcoutDbf = new FileOutputStream(file).getChannel();

                        DriverUtilities.copy(fcinDbf, fcoutDbf);

                        // Borramos los temporales

                        fTemp.delete();

                        // Reload

                        close();

                        open(file);

                } catch (FileNotFoundException e) {

                        throw new EditionException(e);

                } catch (IOException e) {

                        throw new EditionException(e);

                }

        }

        public String getCapability(String capability) {

                return dbfWriter.getCapability(capability);

        }

        public void setCapabilities(Properties capabilities) {

                dbfWriter.setCapabilities(capabilities);

        }

        public boolean canWriteAttribute(int sqlType) {

                return dbfWriter.canWriteAttribute(sqlType);

        }

        public void initialize(ITableDefinition tableDefinition) throws EditionException {

                dbfWriter.initialize(tableDefinition);

        }

        public ITableDefinition getTableDefinition() {

                tableDef = new TableDefinition();

                int numFields; 

                try {

                        numFields = getFieldCount();

                        FieldDescription[] fieldsDescrip = new FieldDescription[numFields];

                        for (int i = 0; i < numFields; i++) {

                                fieldsDescrip[i] = new FieldDescription();

                                int type = getFieldType(i);

                                fieldsDescrip[i].setFieldType(type);

                                fieldsDescrip[i].setFieldName(getFieldName(i));

                                fieldsDescrip[i].setFieldLength(getFieldWidth(i));

                                if (NumberUtilities.isNumeric(type))

                                {

                                        if (!NumberUtilities.isNumericInteger(type))

                                                // TODO: If there is a lost in precision, this should be changed.

                                                fieldsDescrip[i].setFieldDecimalCount(6);

                                }

                                else

                                        fieldsDescrip[i].setFieldDecimalCount(0);

                                // TODO: ?DEFAULTVALUE?

                                // fieldsDescrip[i].setDefaultValue(get)

                        }

                        tableDef.setFieldsDesc(fieldsDescrip);

                        return tableDef;

                } catch (DriverException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                return null;

//                return dbfWriter.getTableDefinition();

        }

        public boolean canAlterTable() {

                return true;

        }

        public boolean alterTable() throws EditionException {

                return true;

        }

        public boolean canSaveEdits() {

                if (file.canWrite()) return true;

                return false;

        }

        public boolean isWriteAll() {

                // TODO: DEVOLVER FALSE SI NO HA HABIDO CAMBIOS EN LOS CAMPOS.

                return true;

        }

}