Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2020 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.math.BigDecimal;

import java.math.MathContext;

import java.nio.BufferOverflowException;

import java.sql.Timestamp;

import java.text.FieldPosition;

import java.text.NumberFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Locale;

import org.apache.commons.lang3.StringUtils;

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

import org.gvsig.tools.logger.FilteredLogger;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class FieldFormatter {

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

  public static final int TIME_SIZE = 6;

  public static final int TIMESTAMP_SIZE = 14;

  public static final int DATE_SIZE = 8;

  public static final int BOOLEAN_SIZE = 1;

  private static final SimpleDateFormat YYYYMMDD_DATE_FORMAT = new SimpleDateFormat("yyyyMMdd");

  private static final SimpleDateFormat HHMMSS_DATE_FORMAT = new SimpleDateFormat("HHmmss");

  private static final SimpleDateFormat YYYYMMDDHHMMSS_DATE_FORMAT = new SimpleDateFormat("yyyyMMddHHmmss");

  private static final FieldPosition FIELDPOSITION = new FieldPosition(NumberFormat.INTEGER_FIELD);

  private static final int MAXCHARS = 255;

  private StringBuffer buffer;

  private NumberFormat numberFormatter;

  private FilteredLogger logger;

  public FieldFormatter() {

  }

  private StringBuffer getBuffer() {

    if (this.buffer == null) {

      this.buffer = new StringBuffer(MAXCHARS);

    }

    return this.buffer;

  }

  private NumberFormat getNumberFormatter() {

    if (this.numberFormatter == null) {

      this.numberFormatter = NumberFormat.getNumberInstance(Locale.US);

      // Avoid grouping on number format

      this.numberFormatter.setGroupingUsed(false);

    }

    return this.numberFormatter;

  }

  private FilteredLogger getLogger() {

    if (this.logger == null) {

      this.logger = new FilteredLogger(LOGGER, "DBFFiledFormatter", -1);

      this.logger.setInterval(2000);

    }

    return this.logger;

  }

  public String format(String s, int size) {

    if (s.length() > size) {

      return s.substring(0, size);

    } else {

      return s;

    }

  }

  public String format(boolean b) {

    return b ? "T" : "F";

  }

  public String formatDate(Date date) {

    if (date == null) {

      //      yyyyMMdd

      return "        ";

    }

    StringBuffer buf = this.getBuffer();

    buf.setLength(0); // Fast clear of buffer

    YYYYMMDD_DATE_FORMAT.format(date, buf, FIELDPOSITION);

    return buf.toString();

  }

  public String formatTime(Date date) {

    if (date == null) {

      //      HHMMSS

      return "      ";

    }

    StringBuffer buf = this.getBuffer();

    buf.setLength(0); // Fast clear of buffer

    HHMMSS_DATE_FORMAT.format(date, buf, FIELDPOSITION);

    return buf.toString();

  }

  public String formatTimestamp(Date date) {

    if (date == null) {

      //      YYYYMMDDHHMMSS

      return "              ";

    }

    StringBuffer buf = this.getBuffer();

    buf.setLength(0); // Fast clear of buffer

    YYYYMMDDHHMMSS_DATE_FORMAT.format(date, buf, FIELDPOSITION);

    return buf.toString();

  }

  public String formatTimestamp(Timestamp timestamp) {

    if (timestamp == null) {

      //      YYYYMMDDHHMMSS

      return "              ";

    }

    StringBuffer buf = this.getBuffer();

    buf.setLength(0); // Fast clear of buffer

    YYYYMMDDHHMMSS_DATE_FORMAT.format(timestamp, buf, FIELDPOSITION);

    return buf.toString();

  }

  public String format(byte n) {

    StringBuffer buf = this.getBuffer();

    NumberFormat nf = this.getNumberFormatter();

    buf.setLength(0); // Fast clear of buffer

    nf.setMaximumFractionDigits(0);

    nf.setMinimumFractionDigits(0);

    nf.format(n, buf, FIELDPOSITION);

    String s = buf.toString();

    if (s.length() > 2) {

      throw new BufferOverflowException();

    }

    return s;

  }

  public String format(int n, int size) {

    StringBuffer buf = this.getBuffer();

    NumberFormat nf = this.getNumberFormatter();

    buf.setLength(0); // Fast clear of buffer

    nf.setMaximumFractionDigits(0);

    nf.setMinimumFractionDigits(0);

    nf.format(n, buf, FIELDPOSITION);

    String s = buf.toString();

    if (s.length() > size) {

      throw new BufferOverflowException();

    }

    return s;

  }

  public String format(long n, int size) {

    StringBuffer buf = this.getBuffer();

    NumberFormat nf = this.getNumberFormatter();

    buf.setLength(0); // Fast clear of buffer

    nf.setMaximumFractionDigits(0);

    nf.setMinimumFractionDigits(0);

    nf.format(n, buf, FIELDPOSITION);

    String s = buf.toString();

    if (s.length() > size) {

      throw new BufferOverflowException();

    }

    return s;

  }

  public String format(BigDecimal n, int size) {

    String s = n.toPlainString();

    if (s.length() > size) {

        int index = s.indexOf('.');

        if(index < 0 || index >= size ) {

          throw new BufferOverflowException();

        }

      s = s.substring(0, size);

    }

    return s;

  }

  public String format(double n, int size, int scale) {

    String s = Double.toString(n);

    if (s.length() > size) {

        if(s.indexOf('E') >= 0){

          //FIXME: 

          throw new BufferOverflowException();

        }

        int index = s.indexOf('.');

        if(index < 0 || index >= size ) {

          throw new BufferOverflowException();

        }

        s = s.substring(0, size);

    }

    return s;

  }

  public String format(float n, int size, int scale) {

    String s = Float.toString(n);

    if (s.length() > size) {

        if(s.indexOf('E') >= 0){

          //FIXME: 

          throw new BufferOverflowException();

        }

        int index = s.indexOf('.');

        if(index < 0 || index >= size ) {

          throw new BufferOverflowException();

        }

        s = s.substring(0, size);

    }

    return s;

  }

  public String parseString(String value, String defaultValue) {

    if (value == null || value.length() == 0) {

      return defaultValue;

    }

    return value;

  }

  public BigDecimal parseDecimal(String value, MathContext context, int scale, BigDecimal defaultValue) {

    if (StringUtils.isBlank(value)) {

      return defaultValue;

    }

    try {

      BigDecimal x = new BigDecimal(value, context);

      if( scale>=0) {

        x = x.setScale(scale, context.getRoundingMode());

      }

      return x;

    } catch (Exception ex) {

      if (!StringUtils.containsOnly(value, "*")) {

        this.getLogger().warn("Can't parse value '" + value + "' as BigDecimal.", ex);

      }

      return defaultValue;

    }

  }

  public Double parseDouble(String value, Double defaultValue) {

    if (StringUtils.isBlank(value)) {

      return defaultValue;

    }

    try {

      Double x = Double.parseDouble(value);

      return x;

    } catch (Exception ex) {

      this.getLogger().warn("Can't parse value '" + value + "' as double.", ex);

      return defaultValue;

    }

  }

  public Float parseFloat(String value, Float defaultValue) {

    if (StringUtils.isBlank(value)) {

      return defaultValue;

    }

    try {

      Float x = Float.parseFloat(value);

      return x;

    } catch (Exception ex) {

      this.getLogger().warn("Can't parse value '" + value + "' as float.", ex);

      return defaultValue;

    }

  }

  public Integer parseInt(String value, Integer defaultValue) {

    if (StringUtils.isBlank(value)) {

      return defaultValue;

    }

    try {

      int x = Integer.parseInt(value);

      return x;

    } catch (Exception ex) {

      this.getLogger().warn("Can't parse value '" + value + "' as int.", ex);

      return defaultValue;

    }

  }

  public Long parseLong(String value, Long defaultValue) {

    if (StringUtils.isBlank(value)) {

      return defaultValue;

    }

    try {

      Long x = new Long(value);

      return x;

    } catch (Exception ex) {

      this.getLogger().warn("Can't parse value '" + value + "' as long.", ex);

      return defaultValue;

    }

  }

  public Byte parseByte(String value, Byte defaultValue) {

    if (StringUtils.isBlank(value)) {

      return defaultValue;

    }

    try {

      byte x = Byte.parseByte(value);

      return x;

    } catch (Exception ex) {

      this.getLogger().warn("Can't parse value '" + value + "' as byte.", ex);

      return defaultValue;

    }

  }

  public Boolean parseBoolean(String value, Boolean defaultValue) {

    if (StringUtils.isBlank(value)) {

      return defaultValue;

    }

    switch (value.trim().charAt(0)) {

      case 'T':

      case 't':

        return true;

      case 'F':

      case 'f':

        return false;

      case ' ':

        return null;

      default:

        return defaultValue;

    }

  }

  public Date parseTimestamp(String value, Date defaultValue) {

    if (StringUtils.isBlank(value)) {

      return defaultValue;

    }

    try {

      Date x = YYYYMMDDHHMMSS_DATE_FORMAT.parse(value);

      return new java.sql.Timestamp(x.getTime());

    } catch (ParseException ex) {

      this.getLogger().warn("Can't parse value '" + value + "' as timestamp.", ex);

      return defaultValue;

    }

  }

  public Date parseTime(String value, Date defaultValue) {

    if (StringUtils.isBlank(value)) {

      return defaultValue;

    }

    try {

      Date x = HHMMSS_DATE_FORMAT.parse(value);

      return new java.sql.Time(x.getTime());

    } catch (ParseException ex) {

      this.getLogger().warn("Can't parse value '" + value + "' as time.", ex);

      return defaultValue;

    }

  }

  public Date parseDate(String value, Date defaultValue) {

    if (StringUtils.isBlank(value)) {

      return defaultValue;

    }

    try {

      Date x = YYYYMMDD_DATE_FORMAT.parse(value);

      return new java.sql.Date(x.getTime());

    } catch (ParseException ex) {

      this.getLogger().warn("Can't parse value '" + value + "' as date.", ex);

      return defaultValue;

    }

  }

}