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

/**

 * 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 2

 * 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.tools.dataTypes.impl;

import java.text.MessageFormat;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dataTypes.Coercion;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.tools.dataTypes.CoercionContext;

public class DefaultDataType implements DataType {

  private static final Logger LOG = LoggerFactory.getLogger(DefaultDataTypesManager.class);

  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;

    }

  }

  public static final int NO_SUPPORT_SCALE = -1;

  public static final int NO_SUPPORT_PRECISION = -1;

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

  private Coercion coercion;

  private Class defaultClass;

  private String subtype;

  private int type;

  private String name;

  private String iconName;

  private int max_precision;

  private int default_precision;

  private int default_scale;

  private boolean fixedPrecision;

  DefaultDataType(int type, String subtype, String name, Class defaultClass, Coercion coercion) {

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

  }

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

    this(type, subtype, name, defaultClass, coercion, "datatype-any", false, NO_SUPPORT_PRECISION, NO_SUPPORT_PRECISION, NO_SUPPORT_SCALE);

  }

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

    this(type, subtype, name, defaultClass, coercion, "datatype-any", isFixedPrecision, max_precision, default_precision, NO_SUPPORT_SCALE);

  }

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

    if (name == null) {

      LOG.trace("Can't register null type name for type {}.", new Object[]{Integer.toHexString(type).toUpperCase()});

      throw new IllegalArgumentException();

    }

    this.type = type;

    this.subtype = subtype;

    this.name = name;

    this.defaultClass = defaultClass;

    this.coercion = coercion;

    this.iconName = iconName == null ? "datatype-any" : iconName;

    this.max_precision = max_precision;

    this.default_precision = default_precision;

    this.default_scale = default_scale;

    this.fixedPrecision = isFixedPrecision;

  }

  @Override

  public DataType clone() throws CloneNotSupportedException {

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

    if (other.coercion instanceof Coercions) {

      this.coercion = ((Coercions) this.coercion).clone();

    }

    return other;

  }

  @Override

  public String getLabel() {

    return this.getName();

  }

  @Override

  public DataType getValue() {

    return this;

  }

  @Override

  public Object coerce(Object value) throws CoercionException {

    // http://en.wikipedia.org/wiki/Type_conversion#Implicit_type_conversion

    if (this.coercion != null) {

      return this.coercion.coerce(value);

    }

    if (defaultClass == null) {

      return value; // ??

    }

    if (defaultClass.isInstance(value)) {

      return value;

    }

    throw new CoercionException();

  }

  @Override

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

    // http://en.wikipedia.org/wiki/Type_conversion#Implicit_type_conversion

    if (this.coercion != null) {

      return this.coercion.coerce(value, context);

    }

    if (defaultClass == null) {

      return value; // ??

    }

    if (defaultClass.isInstance(value)) {

      return value;

    }

    throw new CoercionException();

  }

  @Override

  public Coercion getCoercion() {

    return this.coercion;

  }

  @Override

  public Class getDefaultClass() {

    return this.defaultClass;

  }

  @Override

  public String getSubtype() {

    return this.subtype;

  }

  @Override

  public int getType() {

    return this.type;

  }

  @Override

  public String getName() {

    return this.name;

  }

  @Override

  public String getIconName() {

    return this.iconName;

  }

  @Override

  public boolean isContainer() {

    return (type & DataTypes.CONTAINER) == DataTypes.CONTAINER;

  }

  @Override

  public boolean isObject() {

    return (type & DataTypes.OBJECT) == DataTypes.OBJECT;

  }

  @Override

  public boolean isDynObject() {

    return type == DataTypes.DYNOBJECT;

  }

//  @Override

  public void setCoercion(Coercion coercion) {

    this.coercion = coercion;

    LOG.trace("Add coercion operation for data type {}.", new Object[]{name});

  }

  @Override

  public void addCoercion(Coercion coercion) {

    if (this.coercion == null) {

      this.setCoercion(coercion);

      return;

    }

    Coercions coercions;

    if (this.coercion instanceof Coercions) {

      coercions = (Coercions) this.coercion;

    } else {

      coercions = new Coercions();

      coercions.add(this.coercion);

      this.coercion = coercions;

    }

    coercions.add(coercion);

    LOG.trace("Add coercion operation for data type {}.", new Object[]{name});

  }

  @Override

  public String toString() {

    return MessageFormat.format(

            "type=0x{0};subtype={1};name={2};class={3};coercion={4}",

            new Object[]{

              Integer.toHexString(type).toUpperCase(),

              subtype,

              name,

              defaultClass == null ? null : defaultClass.getName(),

              coercion == null ? null : coercion.getClass().getName()

            }

    );

  }

  @Override

  public boolean isNumeric() {

    if (type == DataTypes.DOUBLE

            || type == DataTypes.FLOAT

            || type == DataTypes.BYTE

            || type == DataTypes.INT

            || type == DataTypes.LONG

            || type == DataTypes.DECIMAL) {

      return true;

    }

    return false;

  }

  @Override

  public boolean supportSize() {

    switch (this.type) {

      case DataTypes.STRING:

      case DataTypes.BYTEARRAY:

        return true;

      default:

        return false;

    }

  }

  @Override

  public boolean supportPrecision() {

    return this.max_precision!=NO_SUPPORT_PRECISION;

  }

  @Override

  public boolean supportScale() {

    return this.default_scale!=NO_SUPPORT_SCALE;

  }

  @Override

  public NumberPrecisionAndScale fixPrecisionAndScale(int precision, int scale) {

    if( this.max_precision==NO_SUPPORT_PRECISION ) {

       return EMPTY_PRECISION_AND_SCALE;

    }

    DefaultNumberPrecisionAndScale r = new DefaultNumberPrecisionAndScale(

            precision, 

            scale

    );

    if( this.fixedPrecision ) {

      r.precision = max_precision;

    }

    if( this.default_scale==NO_SUPPORT_SCALE ) {

      // Soporta precision y no escala (byte, int, long... enteros)

      r.scale = 0;

      if( r.precision > max_precision ) {

        r.precision = max_precision;

      }

    } else {

      // Soporta precision y escala.

      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;

  }

  @Override

  public int getMaxPrecision() {

    return this.max_precision;

  }

  @Override

  public int getDefaultPrecision() {

    return this.default_precision;

  }

  @Override

  public int getDefaultScale() {

    return this.default_scale;

  }

  public boolean isFixedPrecision() {

    return this.fixedPrecision;

  }

}