Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.store.dbf.utils;

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.Buffer;

import java.nio.ByteBuffer;

import java.nio.channels.FileChannel;

import java.nio.charset.Charset;

import java.util.Date;

import org.gvsig.fmap.dal.exception.CloseException;

import org.gvsig.fmap.dal.exception.FileNotFoundException;

import org.gvsig.fmap.dal.exception.UnsupportedEncodingException;

import org.gvsig.fmap.dal.exception.UnsupportedVersionException;

import org.gvsig.fmap.dal.exception.WriteException;

import org.gvsig.fmap.dal.feature.exception.AttributeFeatureTypeNotSuportedException;

import org.gvsig.utils.bigfile.BigByteBuffer2;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Class to read and write data to a dbase III format file. Creation date:

 * (5/15/2001 5:15:13 PM)

 */

public class DbaseFile {

    private static final Logger logger = LoggerFactory.getLogger(DbaseFile.class);

    public static final int MAX_FIELD_NAME_LENGTH = 10;

    // Header information for the DBase File

    private DbaseFileHeader myHeader;

    private File file;

    private RandomAccessFile raf;

    private FileChannel channel;

    private BigByteBuffer2 buffer;

    private FileChannel.MapMode mode;

    private FieldFormatter formatter = new FieldFormatter();

    private long posActual = -1;

    private long recordOffset;

    private ByteBuffer cachedRecord = null;

    private byte[] bytesCachedRecord = null;

    private final Number NULL_NUMBER = 0;

    private final String NULL_STRING = "";

    private final String NULL_DATE = "        ";

    private Charset chars = null;

    private Charset charsOriginal;

    private boolean isOpen = false;

    private boolean allowDuplicatedFieldNames;

    public DbaseFile(File afile) {

        this(afile, null);

    }

    public DbaseFile(File afile, Charset chars) {

        this(afile, chars, false);

    }

    public DbaseFile(File afile, Charset chars, boolean allowDuplicatedFieldNames) {

        this.file = afile;

        this.chars = chars;

        this.allowDuplicatedFieldNames = allowDuplicatedFieldNames;

    }

    public DbaseFileHeader getHeader() {

        return myHeader;

    }

//

//    /**

//     * @deprecated Use {@link #getCodePageInt()} instead

//     */

//    @Deprecated

//        public byte getCodePage() {

//                return (byte) myHeader.getLanguageID();

//        }

    public int getCodePageInt() {

        return myHeader.getLanguageID();

    }

    /**

     * Returns the charset used to read/write this dbf. Maybe different from the

     * declared in the file if we have forced a different one

     */

    public String getCharsetName() {

        return chars.name();

        //return myHeader.getCharsetName();

    }

    /**

     * Returns the charset declared on the dbf file (or the default one if none

     * is declared)

     */

    public String getOriginalCharsetName() {

        return myHeader.getOriginalCharset();

    }

    // Retrieve number of records in the DbaseFile

    public int getRecordCount() {

        return myHeader.getNumRecords();

    }

    public int getFieldCount() {

        return myHeader.getNumFields();

    }

    public boolean getBooleanFieldValue(long rowIndex, int fieldId) {

        DbaseFieldDescriptor descriptor = this.myHeader.getFieldDescription(fieldId);

        long recordOffset = (myHeader.getRecordLength() * rowIndex)

                + myHeader.getHeaderLength() + 1;

        // Se calcula el offset del campo

        int fieldOffset = 0;

        for (int i = 0; i < (fieldId - 1); i++) {

            fieldOffset += descriptor.getSize();

        }

        buffer.position(recordOffset + fieldOffset);

        char bool = (char) buffer.get();

        return ((bool == 't') || (bool == 'T') || (bool == 'Y') || (bool == 'y'));

    }

    public String getStringFieldValue(long rowIndex, int fieldId)

            throws UnsupportedEncodingException {

        DbaseFieldDescriptor descriptor = this.myHeader.getFieldDescription(fieldId);

        int fieldOffset = descriptor.getOffsetInRecord();

        byte[] data = new byte[descriptor.getSize()];

        if (rowIndex != posActual) {

            recordOffset = (myHeader.getRecordLength() * rowIndex)

                    + myHeader.getHeaderLength() + 1;

            /*

                         * System.err.println("getStringFieldValue: rowIndex = " +

                         * rowIndex); System.err.println("recordOffset = " + recordOffset + "

                         * fieldOffset=" + fieldOffset);

             */

            buffer.position(recordOffset);

            buffer.get(bytesCachedRecord);

            cachedRecord = ByteBuffer.wrap(bytesCachedRecord);

            posActual = rowIndex;

        }

        ((Buffer) cachedRecord).position(fieldOffset);

        cachedRecord.get(data);

        return new String(data, chars);

    }

    public void setFieldValue(long rowIndex, int fieldId, Object obj) throws UnsupportedEncodingException, WriteException {

        try {

            DbaseFieldDescriptor descriptor = this.myHeader.getFieldDescription(fieldId);

            formatter.setRowIndex(rowIndex);

            formatter.setName(descriptor.getName());

            int fieldOffset = descriptor.getOffsetInRecord();

            String str = fieldString(obj, fieldId);

            byte[] data = new byte[descriptor.getSize()];

            recordOffset = (myHeader.getRecordLength() * rowIndex)

                    + myHeader.getHeaderLength() + 1;

            ByteBuffer aux = ByteBuffer.wrap(data);

            aux.put(str.getBytes(chars));

//                        raf.seek(recordOffset + fieldOffset);

//                        raf.writeBytes(str);

            aux.flip();

//                        int numBytesWritten = channel.write(aux, recordOffset + fieldOffset);

            channel.write(aux, recordOffset + fieldOffset);

            //channel.force(true);

        } catch (java.io.UnsupportedEncodingException e) {

            throw new UnsupportedEncodingException(e);

        } catch (IOException e) {

            throw new WriteException("DBF", e);

        }

    }

    /**

     * read the DBF file into memory.

     */

    public void open() throws FileNotFoundException,

            UnsupportedVersionException, IOException, AttributeFeatureTypeNotSuportedException {

        if (!file.exists()) {

            throw new FileNotFoundException(file);

        }

//                if (file.canWrite()) {

//                        try {

//                                raf = new RandomAccessFile(file, "rw");

//                                mode = FileChannel.MapMode.READ_WRITE;

//                        } catch (java.io.FileNotFoundException e) {

//                                raf = new RandomAccessFile(file, "r");

//                                mode = FileChannel.MapMode.READ_ONLY;

//                        }

//                } else {

        raf = new RandomAccessFile(file, "r");

        mode = FileChannel.MapMode.READ_ONLY;

//                }

        channel = raf.getChannel();

        // buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0,

        // channel.size());

        buffer = new BigByteBuffer2(channel, mode);

        // create the header to contain the header information.

        myHeader = new DbaseFileHeader();

        if (chars == null) {

            myHeader.read(buffer, null, allowDuplicatedFieldNames);

        } else {

            myHeader.read(buffer, chars.name(), allowDuplicatedFieldNames);

        }

        if (myHeader.getLanguageID() == 0x00) {

            // read from the .cpg file if ldid is 0x00

            DbaseCodepage cpReader = new DbaseCodepage(file);

            String charsetName = cpReader.read();

            if (charsetName == null) {

                charsetName = "ISO-8859-1"; // for compatibility with old gvSIG files

            }

            charsOriginal = Charset.forName(myHeader.mappingEncoding(charsetName));

        } else {

            charsOriginal = Charset.forName(myHeader.mappingEncoding(myHeader.getOriginalCharset()));

        }

        if (chars == null) {

            chars = charsOriginal;

        }

        bytesCachedRecord = new byte[myHeader.getRecordLength()];

        this.isOpen = true;

    }

    /**

     * Removes all data from the dataset

     */

    public void close() throws CloseException {

        logger.debug("Closing dbf file '" + this.file.getAbsolutePath() + "'");

        try {

            raf.close();

            channel.close();

            buffer = null;

            posActual = -1;

            myHeader = null;

        } catch (Exception e) {

            throw new CloseException("DBF", e);

        }

        this.isOpen = false;

    }

    public FileChannel getWriteChannel() {

        return channel;

    }

    private String fieldString(Object obj, final int col) {

        DbaseFieldDescriptor descriptor = this.myHeader.getFieldDescription(col);

        String o;

        final int fieldLen = descriptor.getSize();

        switch (descriptor.getType()) {

            case 'C':

            case 'c':

                o = formatter.format(

                        (obj == null) ? NULL_STRING : ((String) obj),

                        fieldLen

                );

                break;

            case 'L':

            case 'l':

                o = (obj == null) ? "F" : ((Boolean) obj) == true ? "T" : "F";

                break;

            case 'M':

            case 'G':

                o = formatter.format(

                        (obj == null) ? NULL_STRING : (String) obj,

                        fieldLen

                );

                break;

            case 'N':

            case 'n':

            case 'F':

            case 'f':

                Number number;

                if (obj == null) {

                    number = NULL_NUMBER;

                } else {

                    Number gVal = (Number) obj;

                    number = gVal.doubleValue();

                }

                o = formatter.format(

                        (double) number,

                        fieldLen,

                        descriptor.getScale()

                );

                break;

            case 'D':

            case 'd':

                if (obj == null) {

                    o = NULL_DATE;

                } else {

                    o = formatter.formatDate(((Date) obj));

                }

                break;

            default:

                throw new RuntimeException("Unknown type " + descriptor.getType());

        }

        return o;

    }

    public boolean isOpen() {

        return this.isOpen;

    }

    public int getFieldIndex(String name) {

        return myHeader.getFieldIndex(name);

    }

    public Charset getCurrenCharset() {

        return chars;

    }

    public Charset getOriginalCharset() {

        return charsOriginal;

    }

    public void setCharset(Charset chars) {

        this.chars = chars;

    }

    public boolean isWritable() {

        return this.file.canWrite();

    }

}