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

        boolean fixedPrecision, int max_precision, 

        int default_precision, int default_scale);

  public int getMaxPrecision();

  public int getDefaultPrecision();

  public int getDefaultScale();

  public boolean isFixedPrecision();

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

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

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

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

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

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

import static org.gvsig.tools.dataTypes.impl.DefaultDataType.NO_SUPPORT_SCALE;

  private static final Logger LOG = LoggerFactory

          .getLogger(DefaultDataTypesManager.class);

  private static final int NEWINDEXES_AT = OBJECT + 1;

  private final DataType[] types = new DefaultDataType[MAX_TYPE_VALUE];

  public DefaultDataTypesManager() {

    this.addtype(BOOLEAN, null, "Boolean", Boolean.class, new CoerceToBoolean(), 

            "datatype-boolean"

    );

    this.addtype(BYTE, null, "Byte", Byte.class, new CoerceToByte(),

            "datatype-byte",

            true, BYTE_MAX_PRECISION, BYTE_DEFAULT_PRECISION

    );

    this.addtype(CHAR, null, "Char", Character.class, new CoerceToString());

    this.addtype(INT, null, "Integer", Integer.class, new CoerceToInt(), 

            "datatype-integer", 

            true, INT_MAX_PRECISION, INT_DEFAULT_PRECISION

    );

    this.addtype(LONG, null, "Long", Long.class, new CoerceToLong(), 

            "datatype-long", 

            true, LONG_MAX_PRECISION, LONG_DEFAULT_PRECISION

    );

    this.addtype(FLOAT, null, "Float", Float.class, new CoerceToFloat(), 

            "datatype-float", 

            false, FLOAT_MAX_PRECISION, FLOAT_DEFAULT_PRECISION, FLOAT_DEFAULT_SCALE

    );

    this.addtype(DOUBLE, null, "Double", Double.class, new CoerceToDouble(), 

            "datatype-double", 

            false, DOUBLE_MAX_PRECISION, DOUBLE_DEFAULT_PRECISION, DOUBLE_DEFAULT_SCALE

    );

    this.addtype(DECIMAL, null, "Decimal", BigDecimal.class, new CoerceToDecimal(), 

            "datatype-decimal", 

            false, DECIMAL_MAX_PRECISION, DECIMAL_DEFAULT_PRECISION, DECIMAL_DEFAULT_SCALE

    );

    this.addtype(STRING, null, "String", String.class, new CoerceToString(), "datatype-string");

    this.addtype(DATE, SUBTYPE_DATE, "Date", Date.class, new CoerceToDate(), "datatype-date");

    this.addtype(TIME, SUBTYPE_DATE, "Time", Date.class, new CoerceToTime(), "datatype-time");

    this.addtype(TIMESTAMP, null, "Timestamp", Date.class, new CoerceToDateTime(), "datatype-timestamp");

    this.addtype(VERSION, null, "Version", Version.class, new CoerceToVersion());

    this.addtype(BYTEARRAY, null, "ByteArray",

            (new byte[1]).getClass(),

            new CoerceToBytearray(),

            "datatype-bytearray"

    );

    this.addtype(FILE, SUBTYPE_FILE, "File", File.class, new CoerceToFile());

    this.addtype(FOLDER, SUBTYPE_FOLDER, "Folder", File.class, new CoerceToFile());

    this.addtype(DYNOBJECT, null, "DynObject", DynObject.class, null);

    this.addtype(URL, null, "URL", URL.class, new CoerceToURL());

    this.addtype(URI, null, "URI", URI.class, new CoerceToURI());

    this.addtype(ARRAY, null, "Array", (new Object[1]).getClass(), null);

    this.addtype(LIST, null, "List", List.class, null);

    this.addtype(SET, null, "Set", Set.class, null);

    this.addtype(MAP, null, "Map", Map.class, null);

    this.addtype(OBJECT, null, "Object", Object.class, new CoerceToObject(), "datatype-object");

  }

  @Override

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

          Class defaultClass, Coercion coercion) {

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

  }

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

          Class defaultClass, Coercion coercion, String iconName) {

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

  }

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

          Class defaultClass, Coercion coercion, String iconName,

          boolean fixedPrecision, int max_precision, int default_precision) {

    return addtype(type, subtype, name, defaultClass, coercion, iconName,

            fixedPrecision, max_precision, default_precision, NO_SUPPORT_SCALE

    );

  }

  @Override

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

          Class defaultClass, Coercion coercion, String iconName,

          boolean fixedPrecision, int max_precision, int default_precision, int default_scale) {

    if (type == INVALID) {

      type = getNewObjectIndexType();

    if (type < 1 || type > MAX_TYPE_VALUE) {

      throw new IllegalArgumentException("Wrong type "

              + Integer.toHexString(type).toUpperCase() + ".");

    }

    try {

      // Check if the type has been already registereds

      get(type);

      throw new IllegalArgumentException("type "

              + Integer.toHexString(type).toUpperCase() + ", name " + name

              + ", already registered as " + getTypeName(type) + ".");

    } catch (IllegalArgumentException e) {

      // OK, the type is still not registered.

    DataType dataType = new DefaultDataType(

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

            fixedPrecision, max_precision, default_precision, default_scale

    );

    types[type] = dataType;

    LOG.info("Registered data type {}.", dataType.toString());

    return type;

  }

  private int getNewObjectIndexType() {

    for (int i = NEWINDEXES_AT; i <= MAX_TYPE_VALUE; i++) {

      if (types[i] == null) {

        return i;

      }

    return DataTypes.INVALID;

  }

  @Override

  public DataType get(int type) {

    DataType dataType = null;

    if (type > 0 && type <= MAX_TYPE_VALUE) {

      dataType = types[type];

    if (dataType == null) {

      throw new IllegalArgumentException("DataType " + type

              + " not registered");

    return dataType;

  }

  @Override

  public boolean isValidType(int type) {

    return type > 0 && type <= MAX_TYPE_VALUE && this.types[type] != null;

  }

  @Override

  public boolean isObject(int type) {

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

  }

  @Override

  public boolean isContainer(int type) {

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

  }

  @Override

  public int getType(String name) {

    if (name != null) {

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

        if (types[i] != null

                && name.equalsIgnoreCase(types[i].getName())) {

          return i;

      }

    return DataTypes.INVALID;

  }

  @Override

  public String getTypeName(int type) {

    DataType dataType = get(type);

    String name = dataType.getName();

    if (name == null) {

      return "unknow";

    return name;

  }

  @Override

  public Class getDefaultClass(int type) {

    DataType dataType = get(type);

    return dataType.getDefaultClass();

  }

  @Override

  public String getSubtype(int type) {

    DataType dataType = get(type);

    return dataType.getSubtype();

  }

  @Override

  public Coercion getCoercion(int type) {

    DataType dataType = get(type);

    return dataType.getCoercion();

  }

  @Override

  public void addCoercion(int type, Coercion coercion) {

    DataType dataType = get(type);

    dataType.addCoercion(coercion);

  }

  @Override

  public Object coerce(int type, Object value) throws CoercionException {

    DataType dataType = get(type);

    return dataType.coerce(value);

  }

  @Override

  public Iterator iterator() {

    List list = new ArrayList();

    DataType type;

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

      type = this.types[i];

      if (type != null) {

        list.add(this.types[i]);

      }

    return list.iterator();

  }

  @Override

  public DataType getDataType(Class defaultClass) {

    // First look for a class with exact match

    for (DataType type : types) {

      if (type != null) {

        Class typeClass = type.getDefaultClass();

        if (typeClass != null && typeClass.equals(defaultClass)) {

          return type;

      }

    // Then look for a class which is an interface or parent

    for (DataType type : types) {

      if (type != null) {

        Class typeClass = type.getDefaultClass();

        if (typeClass != null

                && typeClass.isAssignableFrom(defaultClass)) {

          return type;

      }

    }

    throw new IllegalArgumentException(

            + "parent of the class: " + defaultClass);

  }

  public static final int NO_SUPPORT_SCALE = -1;

  public static final int NO_SUPPORT_PRECISION = -1;

  private boolean fixedPrecision;

    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) {

    this.fixedPrecision = isFixedPrecision;

    return this.max_precision!=NO_SUPPORT_PRECISION;

    return this.default_scale!=NO_SUPPORT_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.

    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;

  }

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