Application: gvSIG desktop » Library: org.gvsig.tools

    public int addtype(int type, String subtype, String name,

        Class defaultClass, Coercion coercion, String iconName, 

        int max_precision, int default_precision, int default_scale);

  public static final int BYTE_MAX_PRECISION = 3; // max byte 255

  public static final int BYTE_DEFAULT_PRECISION = BYTE_MAX_PRECISION;

  public static final int INT_MAX_PRECISION = 10; // max int 2147483647.

  public static final int INT_DEFAULT_PRECISION = INT_MAX_PRECISION;

  public static final int LONG_MAX_PRECISION = 19; // max long 9223372036854775807.

  public static final int LONG_DEFAULT_PRECISION = LONG_MAX_PRECISION;

  // IEEE 754 Single-precision floating-point

  // https://en.m.wikipedia.org/wiki/Single-precision_floating-point_format

  public static final int FLOAT_MAX_PRECISION = 8; // 24bits

  public static final int FLOAT_DEFAULT_PRECISION = FLOAT_MAX_PRECISION;

  public static final int FLOAT_DEFAULT_SCALE = 3;

  // IEEE 754 Double-precision floating-point

  // https://en.m.wikipedia.org/wiki/Double-precision_floating-point_format

  public static final int DOUBLE_MAX_PRECISION = 16; // 54bits

  public static final int DOUBLE_DEFAULT_PRECISION = DOUBLE_MAX_PRECISION;

  public static final int DOUBLE_DEFAULT_SCALE = 8;

  // La precision de un BigDecimal es la de un BigInteger, que esta 

  // en 2^500000000, vamos a dejarla en que es algo mas de 2^5000000, siendo

  // consciente de que algunos proveedores no podran suportarla y la recortaran.

  public static final int DECIMAL_MAX_PRECISION = 2000000;

  public static final int DECIMAL_DEFAULT_PRECISION = 20;

  public static final int DECIMAL_DEFAULT_SCALE = 3;

  public interface NumberPrecisionAndScale {

    public int getPrecision();

    public int getScale();

  }

  public boolean supportSize();

  public boolean supportPrecision();

  public boolean supportScale();

  public NumberPrecisionAndScale fixPrecisionAndScale(int precision, int scale);

package org.gvsig.tools.dataTypes.impl;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionContext;

import org.gvsig.tools.dataTypes.CoercionException;

/**

 *

 * @author jjdelcerro

 */

class Coercions implements Coercion, org.gvsig.tools.lang.Cloneable {

  List<Coercion> coercions;

  public Coercions() {

    this.coercions = new ArrayList<>();

  }

  public void add(Coercion coercion) {

    this.coercions.add(coercion);

  }

  @Override

  public Coercions clone() throws CloneNotSupportedException {

    Coercions other = (Coercions) super.clone();

    other.coercions = new ArrayList<>();

    other.coercions.addAll(this.coercions);

    return other;

  }

  @Override

  public Object coerce(Object value) throws CoercionException {

    return coerce(value, null);

  }

  @Override

  @SuppressWarnings(value = "UnusedAssignment")

  public Object coerce(Object value, CoercionContext context) throws CoercionException {

    for (int i = this.coercions.size(); --i >= 0;) {

      Coercion coercion = this.coercions.get(i);

      try {

        return coercion.coerce(value, context);

      } catch (CoercionException e) {

        // Do nothing, go to next coercion

        coercion = null; // To allow set break point

      }

    }

    throw new CoercionException();

  }

}

import static org.gvsig.tools.dataTypes.DataType.DECIMAL_DEFAULT_PRECISION;

import static org.gvsig.tools.dataTypes.DataType.DECIMAL_DEFAULT_SCALE;

import static org.gvsig.tools.dataTypes.DataType.DECIMAL_MAX_PRECISION;

import static org.gvsig.tools.dataTypes.DataType.DOUBLE_DEFAULT_PRECISION;

import static org.gvsig.tools.dataTypes.DataType.DOUBLE_DEFAULT_SCALE;

import static org.gvsig.tools.dataTypes.DataType.DOUBLE_MAX_PRECISION;

import static org.gvsig.tools.dataTypes.DataType.FLOAT_DEFAULT_PRECISION;

import static org.gvsig.tools.dataTypes.DataType.FLOAT_DEFAULT_SCALE;

import static org.gvsig.tools.dataTypes.DataType.FLOAT_MAX_PRECISION;

        this.addtype(FLOAT, null, "Float", Float.class, new CoerceToFloat(),"datatype-float", FLOAT_MAX_PRECISION, FLOAT_DEFAULT_PRECISION, FLOAT_DEFAULT_SCALE);

        this.addtype(DOUBLE, null, "Double", Double.class, new CoerceToDouble(),"datatype-double", DOUBLE_MAX_PRECISION, DOUBLE_DEFAULT_PRECISION, DOUBLE_DEFAULT_SCALE);

        this.addtype(DECIMAL, null, "Decimal", BigDecimal.class, new CoerceToDecimal(),"datatype-decimal",DECIMAL_MAX_PRECISION, DECIMAL_DEFAULT_PRECISION, DECIMAL_DEFAULT_SCALE);

        return addtype(type, subtype, name, defaultClass, coercion, null, 0, 0, 0);

        return addtype(type, subtype, name, defaultClass, coercion, iconName, 0, 0, 0);

    }

    @Override

    public final synchronized int addtype(int type, String subtype, String name,

        Class defaultClass, Coercion coercion, String iconName, 

        int max_precision, int default_precision, int default_scale) {

        DataType dataType = new DefaultDataType(

                type, subtype, name, defaultClass, coercion, iconName,

                max_precision, default_precision, default_scale

        );

  private static class DefaultNumberPrecisionAndScale implements NumberPrecisionAndScale {

    private int precision;

    private int scale;

    public DefaultNumberPrecisionAndScale(int precision, int scale) {

      this.precision = precision;

      this.scale = scale;

    }

    @Override

    public int getPrecision() {

      return this.precision;

    }

    @Override

    public int getScale() {

      return this.scale;

    }

    public void setPrecision(int precision) {

      this.precision = precision;

    }

    public void setScale(int scale) {

      this.scale = scale;

    }

  }

  private static final NumberPrecisionAndScale BYTE_PRECISION_AND_SCALE = new DefaultNumberPrecisionAndScale(BYTE_MAX_PRECISION, 0);

  private static final NumberPrecisionAndScale INT_PRECISION_AND_SCALE = new DefaultNumberPrecisionAndScale(INT_MAX_PRECISION, 0);

  private static final NumberPrecisionAndScale LONG_PRECISION_AND_SCALE = new DefaultNumberPrecisionAndScale(LONG_MAX_PRECISION, 0);

  private static final NumberPrecisionAndScale EMPTY_PRECISION_AND_SCALE = new DefaultNumberPrecisionAndScale(0, 0);

  private int max_precision;

  private int default_precision;

  private int default_scale;

    this(type, subtype, name, defaultClass, coercion, "datatype-any", 0, 0, 0);

  }

  DefaultDataType(int type, String subtype, String name, Class defaultClass, Coercion coercion, String iconName, int max_precision, int default_precision, int default_scale) {

    this.max_precision = max_precision;

    this.default_precision = default_precision;

    this.default_scale = default_scale;

            || type == DataTypes.BYTE

  @Override

  public boolean supportSize() {

    switch (this.type) {

      case DataTypes.STRING:

      case DataTypes.BYTEARRAY:

        return true;

      default:

        return false;

  }

  @Override

  public boolean supportPrecision() {

    if( this.max_precision<=0 ) {

      return false;

    return true;

  }

  @Override

  public boolean supportScale() {

    if( this.max_precision<=0 ) {

      return false;

    switch (this.type) {

      case DataTypes.FLOAT:

      case DataTypes.DOUBLE:

      case DataTypes.DECIMAL:

        return true;

      default:

        return false;

  }

  @Override

  public NumberPrecisionAndScale fixPrecisionAndScale(int precision, int scale) {

    if( this.max_precision > 0 ) {

      // Si el tipo tiene asignada una precision maxima asumimos que debemos

      // controlar la precision y la escala.

      DefaultNumberPrecisionAndScale r = new DefaultNumberPrecisionAndScale(

              precision, 

              scale

      );

      if (r.precision < 1) {

        // Sin precision

        if (r.scale < 1) {

          // Sin precision y sin escala 

          // Asinamos los valores por defecto.

          r.precision = default_precision;

          r.scale = default_scale;

        } else {

          // Sin precision y con escala.

          if (r.scale <= max_precision) {

            // Sin precision y con escala < maxima precision.

            // Asignamos la precision a la maxima.

            r.precision = max_precision;

          } else {

            // Sin precision y con escala > maxima precision.

            // Esto es un error.

            // Asignamos la precision a la maxima y reducimos la escala

            // a la maxima precision.

            r.precision = max_precision;

            r.scale = max_precision;

          }

      } else {

        // Con precicion

        if (r.scale < 1) {

          // Con precision y sin escala.

          // Esto no es del todo correto. 

          // Probablemente algunos proveedores lo convertirian a int. 

          // Vamos a forzar que siempre tenga 1 decimal.

          if (r.precision < max_precision) {

            // Con precision < maxima precision y sin escala.

            // Aumentamos la precision en 1 para a?adirle un decimal.

            r.precision += 1;

            r.scale = 1;

          } else {

            // Con precision >= maxima precision y sin escala.

            // No podemos aumentar la precision para a?adirle un decimal. 

            // Le a?adiremos 1 decimal, y dejaremos la precision a la maxima.

            // Perdemos precision.

            r.precision = max_precision;

            r.scale = 1;

          }

        } else {

          // Con precision y escala.     

          if (r.precision > max_precision) {

            // Con precision mayor que la maxima y con escala.

            // Reducimos la precision a la maxima.

            r.precision = max_precision;

          }

          if (r.precision >= r.scale) {

            // Con precision y escala menor que la precision.     

            // Es correcto, no hacemos nada.

          } else {

            // Con precision y escala mayor que la precision.

            if (r.scale <= max_precision) {

              // Con precision y escala mayor que la precision y menor que la maxima precision.

              // Aumentamos la precision para soportar la escala indicada.

              r.precision = r.scale;

            } else {

              // Con precision y escala mayor que la precision y mayor que la maxima precision.

              // Ponemos la maxima precision y reducimos la escala a esta.

              // Perdemos precision.

              r.precision = max_precision;

              r.scale = max_precision;

            }

          }

        }

      return r;

    // Para los tipos enteros basicos, ya tienen una precision y escala fijas.

    switch(this.type) {

      case DataTypes.BYTE:

        return BYTE_PRECISION_AND_SCALE;

      case DataTypes.INT:

        return INT_PRECISION_AND_SCALE;

      case DataTypes.LONG:

        return LONG_PRECISION_AND_SCALE;

      default:

        return EMPTY_PRECISION_AND_SCALE;

    }

            new String[] { "DataTypes", "datatype-decimal" },