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

import java.io.UnsupportedEncodingException;

import java.nio.Buffer;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.channels.FileChannel;

import java.nio.charset.Charset;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.SortedMap;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataTypes;

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

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

import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureType;

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

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

import org.gvsig.fmap.dal.store.dbf.DBFStoreProvider;

import org.gvsig.fmap.dal.store.dbf.DuplicatedFieldNameException;

import static org.gvsig.fmap.dal.store.dbf.utils.DbaseFieldDescriptor.DBFTYPE_BOOLEAN;

import static org.gvsig.fmap.dal.store.dbf.utils.DbaseFieldDescriptor.DBFTYPE_DATE;

import static org.gvsig.fmap.dal.store.dbf.utils.DbaseFieldDescriptor.DBFTYPE_FLOAT;

import static org.gvsig.fmap.dal.store.dbf.utils.DbaseFieldDescriptor.DBFTYPE_NUMBER;

import static org.gvsig.fmap.dal.store.dbf.utils.DbaseFieldDescriptor.DBFTYPE_STRING;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.utils.bigfile.BigByteBuffer2;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import static org.gvsig.fmap.dal.store.dbf.utils.FieldFormatter.TIMESTAMP_SIZE;

import static org.gvsig.fmap.dal.store.dbf.utils.FieldFormatter.TIME_SIZE;

/**

 * Class to represent the header of a Dbase III file.

 */

@SuppressWarnings("UseSpecificCatch")

public class DbaseFileHeader {

  private static final Logger LOGGER = LoggerFactory.getLogger(DbaseFileHeader.class);

  // Constant for the size of a record

  private final int FILE_DESCRIPTOR_SIZE = 32;

  // type of the file, must be 03h

  private static final byte MAGIC = 0x03;

  private static final int MINIMUM_HEADER = 33;

  // type of the file, must be 03h

  private int myFileType = 0x03;

  // Date the file was last updated.

  private Date myUpdateDate = new Date();

  // Number of records in the datafile

  private int myNumRecords = 0;

  // Length of the header structure

  private int myHeaderLength;

  /**

   * Length of the records. Set to 1 as the default value as if there is not any

   * defined column, at least the deleted status initial byte is taken into

   * account.

   */

  private int myRecordLength = 1;

  // Number of fields in the record.

  private int myNumFields;

  // collection of header records.

  private DbaseFieldDescriptor[] myFieldDescriptions;

  private int myLanguageID = 0x00;

  /**

   * Only considered when myLanguageID = 0x00;

   */

  private String charset = null;

  private List<String> encodingSupportedByString = null;

  private int origLanguageID = 0x00;

  /**

   * Headers must always be encoded using ASCII/ISO-8859-1, regardless the

   * encoding of the records

   */

  private static final Charset HEADER_CHARSET = Charset.forName("ISO-8859-1");

  /**

   * DbaseFileHreader constructor comment.

   */

  public DbaseFileHeader() {

    super();

    encodingSupportedByString = new ArrayList<>();

    SortedMap<String, Charset> m = Charset.availableCharsets();

    Set<String> k = m.keySet();

    Iterator<String> it = k.iterator();

    while (it.hasNext()) {

      encodingSupportedByString.add(it.next());

    }

  }

  /**

   * Add a column to this DbaseFileHeader.The type is one of (C N L or D)

 character, number, logical(true/false), or date. The Field length is the

 total length in bytes reserved for this column. The decimal count only

 applies to numbers(N), and floating point values (F), and refers to the

 number of characters to reserve after the decimal point.

   */

  public void addColumn(String fieldName, char fieldType,

          int fieldSize, int fieldPrecision, int fieldScale)

          throws AttributeFeatureTypeNotSuportedException {

//    if (fieldSize <= 0) {

//      fieldSize = 1;

//    }

    if (myFieldDescriptions == null) {

      myFieldDescriptions = new DbaseFieldDescriptor[0];

    }

    int tempLength = 1; // the length is used for the offset, and there is a * for deleted as the first byte

    DbaseFieldDescriptor[] tempFieldDescriptors = new DbaseFieldDescriptor[myFieldDescriptions.length

            + 1];

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

      myFieldDescriptions[i].setOffsetInRecord(tempLength);

      tempLength = tempLength + myFieldDescriptions[i].getSize();

      tempFieldDescriptors[i] = myFieldDescriptions[i];

    }

    tempFieldDescriptors[myFieldDescriptions.length] = new DbaseFieldDescriptor();

    tempFieldDescriptors[myFieldDescriptions.length].setType(fieldType);

    tempFieldDescriptors[myFieldDescriptions.length].setSize(fieldSize);

    tempFieldDescriptors[myFieldDescriptions.length].setScale(fieldScale);

    tempFieldDescriptors[myFieldDescriptions.length].setOffsetInRecord(tempLength);

    // set the field name

    String tempFieldName = fieldName;

    if (tempFieldName == null) {

      tempFieldName = "NoName";

    }

    if (tempFieldName.length() > DbaseFile.MAX_FIELD_NAME_LENGTH) {

      tempFieldName = tempFieldName.substring(0, DbaseFile.MAX_FIELD_NAME_LENGTH);

      warn("FieldName " + fieldName

              + " is longer than " + DbaseFile.MAX_FIELD_NAME_LENGTH + " characters, truncating to "

              + tempFieldName);

    }

    tempFieldDescriptors[myFieldDescriptions.length].setName(tempFieldName);

//    tempFieldDescriptors[myFieldDescriptions.length].setName_trim(tempFieldName.trim());

    tempFieldDescriptors[myFieldDescriptions.length].setName_trim(StringUtils.stripEnd(tempFieldName, null));

    // the length of a record

    tempLength += tempFieldDescriptors[myFieldDescriptions.length].getSize();

    // set the new fields.

    myFieldDescriptions = tempFieldDescriptors;

    myHeaderLength = 33 + (32 * myFieldDescriptions.length);

    myNumFields = myFieldDescriptions.length;

    myRecordLength = tempLength;

  }

  /**

   * Remove a column from this DbaseFileHeader.

   *

   * @return index of the removed column, -1 if no found

   */

  public int removeColumn(String inFieldName) {

    int retCol = -1;

    int tempLength = 1;

    DbaseFieldDescriptor[] tempFieldDescriptors = new DbaseFieldDescriptor[myFieldDescriptions.length

            - 1];

    for (int i = 0, j = 0; i < myFieldDescriptions.length; i++) {

      if (!inFieldName.equalsIgnoreCase(

              myFieldDescriptions[i].getName().trim())) {

        // if this is the last field and we still haven't found the

        // named field

        if ((i == j) && (i == (myFieldDescriptions.length - 1))) {

//                    System.err.println("Could not find a field named '" +

//                        inFieldName + "' for removal");

          return retCol;

        }

        tempFieldDescriptors[j] = myFieldDescriptions[i];

        tempFieldDescriptors[j].setOffsetInRecord(tempLength);

        tempLength += tempFieldDescriptors[j].getSize();

        // only increment j on non-matching fields

        j++;

      } else {

        retCol = i;

      }

    }

    // set the new fields.

    myFieldDescriptions = tempFieldDescriptors;

    myHeaderLength = 33 + (32 * myFieldDescriptions.length);

    myNumFields = myFieldDescriptions.length;

    myRecordLength = tempLength;

    return retCol;

  }

  private void warn(String inWarn) {

    LOGGER.warn(inWarn);

  }

  /**

   * Return the Field Descriptor for the given field.

   *

   * @param index, the index of the requeted field description

   * @return the dbase field descriptor.

   */

  public DbaseFieldDescriptor getFieldDescription(int index) {

    return myFieldDescriptions[index];

  }

  public DbaseFieldDescriptor getFieldDescription(String name) {

    int index = this.getFieldIndex(name);

    return myFieldDescriptions[index];

  }

  public int getFieldIndex(String name) {

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

      if (myFieldDescriptions[i].getName_trim()

              .equalsIgnoreCase(StringUtils.stripEnd(name, null))) {

        return i;

      }

    }

    return -1;

  }

  /**

   * Return the date this file was last updated.

   */

  public Date getLastUpdateDate() {

    return myUpdateDate;

  }

  /**

   * Return the number of fields in the records.

   */

  public int getNumFields() {

    return myNumFields;

  }

  /**

   * Return the number of records in the file

   */

  public int getNumRecords() {

    return myNumRecords;

  }

  /**

   * Return the length of the records in bytes.

   */

  public int getRecordLength() {

    return myRecordLength;

  }

  /**

   * Return the length of the header

   */

  public int getHeaderLength() {

    return myHeaderLength;

  }

  /**

   * Read the header data from the DBF file.

   */

  public void read(BigByteBuffer2 in, String charsName, boolean allowDuplicatedFieldNames)

          throws UnsupportedVersionException, 

            AttributeFeatureTypeNotSuportedException {

    // type of file.

    myFileType = in.get();

    if (myFileType != 0x03) {

      throw new UnsupportedVersionException("DBF", Integer.toHexString(myFileType));

    }

    // parse the update date information.

    int tempUpdateYear = in.get();

    int tempUpdateMonth = in.get();

    int tempUpdateDay = in.get();

    tempUpdateYear = tempUpdateYear + 1900;

    Calendar c = Calendar.getInstance();

    c.set(Calendar.YEAR, tempUpdateYear);

    c.set(Calendar.MONTH, tempUpdateMonth - 1);

    c.set(Calendar.DATE, tempUpdateDay);

    myUpdateDate = c.getTime();

    // read the number of records.

    in.order(ByteOrder.LITTLE_ENDIAN);

    myNumRecords = in.getInt();

    // read the length of the header structure.

    myHeaderLength = in.getShort();

    // read the length of a record

    myRecordLength = in.getShort(); //posicon 0h

    in.order(ByteOrder.BIG_ENDIAN);

    // read the language bit (LDID) 

    in.position(29);

    origLanguageID = byteAsUnsigned(in.get());

    if (charsName != null) {

      // ignore the language bit, use the provided charset name

      myLanguageID = DbaseCodepage.getLdid(charsName);

      this.charset = charsName;

    } else {

      // use the read the language bit

      myLanguageID = origLanguageID;

      charsName = getCharsetName();

    }

    // Posicionamos para empezar a leer los campos.

    in.position(32);

    // calculate the number of Fields in the header

    myNumFields = (myHeaderLength - FILE_DESCRIPTOR_SIZE - 1) / FILE_DESCRIPTOR_SIZE;

    // read all of the header records

    myFieldDescriptions = new DbaseFieldDescriptor[myNumFields];

    int fieldOffset = 0;

    List fieldNames = new ArrayList<>();

    // FIXME: should field names be always read using ISO8859-1??

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

      myFieldDescriptions[i] = new DbaseFieldDescriptor();

      // read the field name

      byte[] buffer = new byte[11];

      in.get(buffer);

      String fieldName;

      fieldName = new String(buffer, HEADER_CHARSET);

      if (allowDuplicatedFieldNames) {

        fieldName = getUniqueFieldName(fieldName, fieldNames);

      }

      fieldNames.add(fieldName);

      myFieldDescriptions[i].setName(fieldName);

      myFieldDescriptions[i].setName_trim(myFieldDescriptions[i].getName().trim());

      // read the field type

      myFieldDescriptions[i].setType((char) in.get());

      // read the field data address, offset from the start of the record.

      myFieldDescriptions[i].setOffsetInRecord(in.getInt());

      // read the field length in bytes

      int tempLength = in.get();

      if (tempLength < 0) {

        tempLength = tempLength + 256;

      }

      myFieldDescriptions[i].setSize(tempLength);

      // read the field decimal count in bytes

      myFieldDescriptions[i].setScale(in.get());

      myFieldDescriptions[i].setOffsetInRecord(fieldOffset);

      fieldOffset += tempLength;

      // read the reserved bytes.

      in.position(in.position() + 14);

    }

    // Last byte is a marker for the end of the field definitions.

    in.get();

  }

  /**

   * Set the number of records in the file

   */

  public void setNumRecords(int inNumRecords) {

    myNumRecords = inNumRecords;

  }

  /**

   * Returns the value of the unsigned byte as a short Bytes are always signed

   * in Java, so if we are reading a C unsigned byte with value > 128, it will

   * appear as a negative value.

   *

   * In this case, we need to get the original unsigned value and return it as

   * short or int, as byte will never correctly store the value in Java.

   */

  private int byteAsUnsigned(byte b) {

    int i;

    if (b < 0) {

      i = b & 0xFF;

    } else {

      i = b;

    }

    return i;

  }

  /**

   * Gets the Language driver IDs (code page) defined on the file header (or

   * guessed from the provided charset)

   *

   * Some examples: 01h        DOS USA        code page 437 02h        DOS Multilingual code page 850

   * 03h        Windows ANSI code page 1252 04h        Standard Macintosh 64h        EE MS-DOS code

   * page 852 65h        Nordic MS-DOS code page 865 66h        Russian MS-DOS code page 866

   * 67h        Icelandic MS-DOS 68h        Kamenicky (Czech) MS-DOS 69h        Mazovia (Polish)

   * MS-DOS 6Ah        Greek MS-DOS (437G) 6Bh        Turkish MS-DOS 96h        Russian Macintosh 97h

   * Eastern European Macintosh 98h        Greek Macintosh C8h        Windows EE        code page

   * 1250 C9h        Russian Windows CAh        Turkish Windows CBh        Greek Windows

   *

   * See the java equivalences in

   * {@link DbaseCodepage#dbfLdid} and {@link DbaseCodepage#ldidJava} objects.

   *

   * See some others here:

   * https://github.com/infused/dbf/blob/master/docs/supported_encodings.csv

   */

  public int getLanguageID() {

    return myLanguageID;

  }

  /**

   * Write the header data to the DBF file.

   *

   * @param out A channel to write to. If you have an OutputStream you can

   * obtain the correct channel by using

   * java.nio.Channels.newChannel(OutputStream out).

   */

  public void write(FileChannel out) throws IOException {

    // take care of the annoying case where no records have been added...

    if (myHeaderLength <= 0) {

      myHeaderLength = MINIMUM_HEADER;

    }

    ByteBuffer buffer = ByteBuffer.allocateDirect(myHeaderLength);

    buffer.order(ByteOrder.LITTLE_ENDIAN);

    // write the output file type.

    buffer.put(MAGIC);

    // write the date stuff

    Calendar c = Calendar.getInstance();

    c.setTime(new Date());

    buffer.put((byte) (c.get(Calendar.YEAR) % 100));

    buffer.put((byte) (c.get(Calendar.MONTH) + 1));

    buffer.put((byte) (c.get(Calendar.DAY_OF_MONTH)));

    // write the number of records in the datafile.

    buffer.putInt(myNumRecords);

    // write the length of the header structure.

    buffer.putShort((short) myHeaderLength);

    // write the length of a record

    buffer.putShort((short) myRecordLength);

    // write the reserved bytes in the header

    ((Buffer) buffer).position(((Buffer) buffer).position() + 17);

    // write the language id

    buffer.put((byte) getLanguageID());

    // write the reserved bytes in the header                

    ((Buffer) buffer).position(((Buffer) buffer).position() + 2);

    // write all of the header records

    int tempOffset = 0;

    if (myFieldDescriptions != null) {

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

        // write the field name

        for (int j = 0; j < DbaseFile.MAX_FIELD_NAME_LENGTH + 1; j++) {

          if (myFieldDescriptions[i].getName().length() > j) {

            buffer.put((byte) myFieldDescriptions[i].getName().charAt(j));

          } else {

            buffer.put((byte) 0);

          }

        }

        // write the field type

        buffer.put((byte) myFieldDescriptions[i].getType());

        // // write the field data address, offset from the start of the

        // record.

        buffer.putInt(tempOffset);

        tempOffset += myFieldDescriptions[i].getSize();

        // write the length of the field.

        buffer.put((byte) myFieldDescriptions[i].getSize());

        // write the decimal count.

        buffer.put((byte) myFieldDescriptions[i].getScale());

        // write the reserved bytes.

        // for (in j=0; jj<14; j++) out.writeByteLE(0);

        ((Buffer) buffer).position(((Buffer) buffer).position() + 14);

      }

    }

    // write the end of the field definitions marker

    buffer.put((byte) 0x0D);

    ((Buffer) buffer).position(0);

    int r = buffer.remaining();

    // Desde el principio

    out.position(0);

    while ((r -= out.write(buffer)) > 0) {

      // do nothing

    }

  }

  public String getCharsetName() {

    return getCharsetName(getLanguageID());

  }

  public String getCharsetName(int ldid) {

    if (ldid != 0) {

      charset = DbaseCodepage.getCharsetName(ldid);

    }

    if (charset != null) {

      // use charset otherwise

      return charset;

    }

    // default

    return "ISO-8859-1";

  }

  public String getOriginalCharset() {

    return getCharsetName(this.origLanguageID);

  }

  public String mappingEncoding(String dbfEnconding) {

    if (encodingSupportedByString.contains(dbfEnconding)) {

      return dbfEnconding;

    } else {

      return "UTF-8";

    }

  }

  private String getUniqueFieldName(String fieldName, List fieldNames) {

    int index = 0;

    String tempFieldName = fieldName;

    while (fieldNames.contains(tempFieldName) && index < 1000) {

      index++;

      String sufix = String.valueOf(index);

      tempFieldName = tempFieldName.substring(0, DbaseFile.MAX_FIELD_NAME_LENGTH - sufix.length()) + sufix;

    }

    if (index >= 1000) {

      throw new RuntimeException("Can't fix duplicated name for field '" + fieldName + "'.");

    }

    return tempFieldName;

  }

  public EditableFeatureType toFeatureType(EditableFeatureType featureType, boolean handleDatesAsStrings) throws DataException {

    featureType.setHasOID(true);

    for (DbaseFieldDescriptor dbfattr : this.myFieldDescriptions) {

      if (featureType.get(dbfattr.getName()) != null) {

        throw new DuplicatedFieldNameException(dbfattr.getName());

      }

      EditableFeatureAttributeDescriptor attr;

      switch (dbfattr.getType()) {

        case DBFTYPE_BOOLEAN:

          attr = featureType.add(dbfattr.getName(), DataTypes.BOOLEAN);

          attr.setSize(0);

          attr.setDefaultValue(null);

          attr.setAllowNull(true);

          break;

        case DBFTYPE_FLOAT:

          if (dbfattr.getScale()==-1 || dbfattr.getScale() > 0) {

            if (dbfattr.getSize() > DataType.DOUBLE_MAX_PRECISION+3) {

              attr = featureType.add(dbfattr.getName(),

                      DataTypes.DECIMAL);

              attr.setDisplaySize(dbfattr.getSize());

              attr.setScale(DataType.SCALE_NONE);

              attr.setPrecision(dbfattr.getPrecision());

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            } else if (dbfattr.getSize() > DataType.FLOAT_MAX_PRECISION+3) {

              attr = featureType.add(dbfattr.getName(),

                      DataTypes.DOUBLE);

              attr.setDisplaySize(dbfattr.getSize());

              attr.setScale(dbfattr.getScale());

              attr.setPrecision(dbfattr.getPrecision());

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            } else {

              attr = featureType.add(dbfattr.getName(),

                      DataTypes.FLOAT);

              attr.setDisplaySize(dbfattr.getSize());

              attr.setScale(dbfattr.getScale());

              attr.setPrecision(dbfattr.getPrecision());

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            }

          } else {

            if (dbfattr.getPrecision() > DataType.LONG_MAX_PRECISION) {

              attr = featureType.add(dbfattr.getName(), DataTypes.DECIMAL);

              attr.setDisplaySize(dbfattr.getSize());

              attr.setPrecision(dbfattr.getPrecision());

              attr.setScale(DataType.SCALE_NONE);

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            } else if (dbfattr.getPrecision() > DataType.INT_MAX_PRECISION) {

              attr = featureType.add(

                      dbfattr.getName(),

                      DataTypes.LONG

              );

              attr.setDisplaySize(dbfattr.getSize());

              attr.setPrecision(dbfattr.getPrecision());

              attr.setScale(0);

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            } else if (dbfattr.getPrecision() > DataType.BYTE_MAX_PRECISION) {

              attr = featureType.add(

                      dbfattr.getName(),

                      DataTypes.INT

              );

              attr.setDisplaySize(dbfattr.getSize());

              attr.setPrecision(dbfattr.getPrecision());

              attr.setScale(0);

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            } else {

              attr = featureType.add(

                      dbfattr.getName(),

                      DataTypes.DECIMAL

              );

              attr.setDisplaySize(dbfattr.getSize());

              attr.setPrecision(dbfattr.getPrecision());

              attr.setScale(0);

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            }

          }

          break;

        case DBFTYPE_NUMBER:

          if (dbfattr.getScale()==-1 || dbfattr.getScale() > 0) {

            attr = featureType.add(dbfattr.getName(),

                    DataTypes.DECIMAL);

            attr.setDisplaySize(dbfattr.getSize());

            attr.setPrecision(dbfattr.getPrecision());

            attr.setScale(DataType.SCALE_NONE);

            attr.setDefaultValue(null);

            attr.setAllowNull(true);

          } else {

            if (dbfattr.getPrecision() > DataType.LONG_MAX_PRECISION) {

              attr = featureType.add(dbfattr.getName(),

                      DataTypes.DECIMAL);

              attr.setDisplaySize(dbfattr.getSize());

              attr.setPrecision(dbfattr.getPrecision());

              attr.setScale(DataType.SCALE_NONE);

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            } else if (dbfattr.getPrecision() > DataType.INT_MAX_PRECISION) {

              attr = featureType.add(

                      dbfattr.getName(),

                      DataTypes.LONG

              );

              attr.setDisplaySize(dbfattr.getSize());

              attr.setPrecision(dbfattr.getPrecision());

              attr.setScale(0);

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            } else if (dbfattr.getPrecision() > DataType.BYTE_MAX_PRECISION) {

              attr = featureType.add(

                      dbfattr.getName(),

                      DataTypes.INT

              );

              attr.setDisplaySize(dbfattr.getSize());

              attr.setPrecision(dbfattr.getPrecision());

              attr.setScale(0);

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            } else {

              attr = featureType.add(

                      dbfattr.getName(),

                      DataTypes.DECIMAL

              );

              attr.setDisplaySize(dbfattr.getSize());

              attr.setPrecision(dbfattr.getPrecision());

              attr.setScale(0);

              attr.setDefaultValue(null);

              attr.setAllowNull(true);

            }

          }

          break;

        case DBFTYPE_STRING:

          attr = featureType.add(dbfattr.getName(),

                  DataTypes.STRING, dbfattr.getSize());

          attr.setDefaultValue(null);

          attr.setAllowNull(true);

          if (dbfattr.getSize() == TIMESTAMP_SIZE) {

            try {

              DataType dataType = ToolsLocator.getDataTypesManager().get(DataTypes.STRING).clone();

              dataType.addCoercion(new CoerceDateToDbfTimestampAsString());

              attr.setDataType(dataType);

            } catch (Exception ex) {

              // Do nothing

            }

          } else if (dbfattr.getSize() == TIME_SIZE) {

            try {

              DataType dataType = ToolsLocator.getDataTypesManager().get(DataTypes.STRING).clone();

              dataType.addCoercion(new CoerceDateToDbfTimeAsString());

              attr.setDataType(dataType);

            } catch (Exception ex) {

              // Do nothing

            }

          }

          break;

        case DBFTYPE_DATE:

          if (handleDatesAsStrings) {

            attr = featureType.add(dbfattr.getName(),

                    DataTypes.STRING, dbfattr.getSize());

            attr.setDefaultValue(null);

            attr.setAllowNull(true);

          } else {

            attr = featureType.add(dbfattr.getName(),

                    DataTypes.DATE

            );

            attr.setDefaultValue(null);

            attr.setAllowNull(true);

          }

          break;

        default:

          throw new UnknownDataTypeException(

                  dbfattr.getName(), String.valueOf(dbfattr.getType()),

                  DBFStoreProvider.NAME

          );

      }

      attr.setDisplaySize(dbfattr.getSize());

    }

    return featureType;

  }

  public static DbaseFileHeader fromFeatureType(FeatureType featureType)

          throws DataException {

    return fromFeatureType(featureType, null);

  }

  public static DbaseFileHeader fromFeatureType(FeatureType featureType, String charsetName)

          throws DataException {

    DbaseFileHeader header = new DbaseFileHeader();

    Iterator iterator = featureType.iterator();

    header.myLanguageID = DbaseCodepage.getLdid(charsetName);

    header.charset = charsetName;

    while (iterator.hasNext()) {

      FeatureAttributeDescriptor descriptor = (FeatureAttributeDescriptor) iterator.next();

      if (descriptor.isComputed()) {

        continue;

      }

      int type = descriptor.getType();

      String colName = descriptor.getName();

      if (colName.length() > DbaseFile.MAX_FIELD_NAME_LENGTH) {      

        throw new FieldNameTooLongException("DBF file", colName);        

      }

      int size = descriptor.getSize();

      int scale = descriptor.getScale();

      int precision = descriptor.getPrecision();

      int displaySize = descriptor.getDisplaySize();

      switch (type) {

        case DataTypes.DECIMAL:

          if( precision < 0) {

            if( displaySize < 1){

                displaySize = DbaseFieldDescriptor.MAX_NUMBER_SIZE;

            }

          } else {

            displaySize = Math.max(displaySize, precision + 3);

          }

          header.addColumn(colName, DBFTYPE_NUMBER, displaySize, precision, scale);

          break;

        case DataTypes.DOUBLE:

          if( displaySize < 1 ) {

            displaySize = DataType.DOUBLE_MAX_PRECISION+3;

          }

          if( displaySize>DbaseFieldDescriptor.MAX_NUMBER_SIZE ) {

            displaySize = DbaseFieldDescriptor.MAX_NUMBER_SIZE;

          }

          header.addColumn(colName, DBFTYPE_FLOAT, displaySize, precision, scale);

          break;

        case DataTypes.FLOAT:

          if( displaySize < 1 ) {

            displaySize = DataType.FLOAT_MAX_PRECISION+3;

          }

          if( displaySize>DbaseFieldDescriptor.MAX_NUMBER_SIZE ) {

            displaySize = DbaseFieldDescriptor.MAX_NUMBER_SIZE;

          }

          header.addColumn(colName, DBFTYPE_FLOAT, displaySize, precision, scale);

          break;

        case DataTypes.INT:

          displaySize = Math.max(displaySize, precision + 1);

          if( displaySize >= DataType.INT_MAX_PRECISION ) {

            displaySize = DataType.INT_MAX_PRECISION;

          }

          if( displaySize>DbaseFieldDescriptor.MAX_NUMBER_SIZE ) {

            displaySize = DbaseFieldDescriptor.MAX_NUMBER_SIZE;

          }

          header.addColumn(colName, DBFTYPE_NUMBER, displaySize, precision, scale);

          break;

        case DataTypes.LONG:

          displaySize = Math.max(displaySize, precision + 1);

          if( displaySize >= DataType.LONG_MAX_PRECISION ) {

            displaySize = DataType.LONG_MAX_PRECISION;

          }

          if( displaySize>DbaseFieldDescriptor.MAX_NUMBER_SIZE ) {

            displaySize = DbaseFieldDescriptor.MAX_NUMBER_SIZE;

          }

          header.addColumn(colName, DBFTYPE_NUMBER, displaySize, precision, scale);

          break;

        case DataTypes.DATE:

          header.addColumn(colName, DBFTYPE_DATE, FieldFormatter.DATE_SIZE, 0, 0);

          break;

        case DataTypes.TIME:

          header.addColumn(colName, DBFTYPE_STRING, FieldFormatter.TIME_SIZE, 0, 0);

          break;

        case DataTypes.TIMESTAMP:

          header.addColumn(colName, DBFTYPE_STRING, FieldFormatter.TIMESTAMP_SIZE, 0, 0);

          break;

        case DataTypes.BOOLEAN:

          header.addColumn(colName, DBFTYPE_BOOLEAN, 1, 0, 0);

          break;

        case DataTypes.STRING:

          displaySize = Math.max(displaySize, size);

          if( displaySize>DbaseFieldDescriptor.MAX_SIZE ) {

            displaySize = DbaseFieldDescriptor.MAX_SIZE;

          }

          header.addColumn(colName, DBFTYPE_STRING, displaySize, 0, 0);

          break;

        case DataTypes.BYTE:

          displaySize = Math.max(displaySize, precision + 1);

          if( displaySize >= DataType.BYTE_MAX_PRECISION ) {

            displaySize = DataType.BYTE_MAX_PRECISION;

          }

          if( displaySize>DbaseFieldDescriptor.MAX_NUMBER_SIZE ) {

            displaySize = DbaseFieldDescriptor.MAX_NUMBER_SIZE;

          }

          header.addColumn(colName, DBFTYPE_NUMBER,displaySize, precision, scale);

          break;

        default:

          // Si no sabemos lo que es intentaremos guardarlo como un string

          displaySize = Math.max(displaySize, Math.max(size, 20));

          if( displaySize>DbaseFieldDescriptor.MAX_SIZE ) {

            displaySize = DbaseFieldDescriptor.MAX_SIZE;

          }

          header.addColumn(colName, DBFTYPE_STRING, displaySize, 0, 0);

          break;

      }

    }

    return header;

  }

}