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.io.File;

import java.math.BigDecimal;

import java.net.URI;

import java.net.URL;

import java.util.ArrayList;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Set;

import org.gvsig.installer.lib.api.Version;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

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

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

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

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

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

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

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;

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.DataType.PRECISION_NONE;

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

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToDecimal;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToBoolean;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToByte;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToBytearray;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToDate;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToDouble;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToFile;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToFloat;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToInt;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToLocale;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToLong;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToObject;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToString;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToTime;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToTimestamp;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToURI;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToURL;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToVersion;

import org.gvsig.tools.dynobject.DynObject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultDataTypesManager implements DataTypesManager, DataTypes {

  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",

            FLAG_NUMBER|FLAG_SUPPORT_PRECISION|FLAG_PREDEFINED_PRECISION,

            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",

            FLAG_NUMBER|FLAG_SUPPORT_PRECISION|FLAG_PREDEFINED_PRECISION,

            INT_MAX_PRECISION, INT_DEFAULT_PRECISION

    );

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

            "datatype-long",

            FLAG_NUMBER|FLAG_SUPPORT_PRECISION|FLAG_PREDEFINED_PRECISION,

            LONG_MAX_PRECISION, LONG_DEFAULT_PRECISION

    );

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

            "datatype-float",

            FLAG_FLOATING_POINT|FLAG_SUPPORT_PRECISION|FLAG_PREDEFINED_PRECISION|FLAG_SUPPORT_SCALE,

            FLOAT_MAX_PRECISION, FLOAT_DEFAULT_PRECISION, FLOAT_DEFAULT_SCALE

    );

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

            "datatype-double",

            FLAG_FLOATING_POINT|FLAG_SUPPORT_PRECISION|FLAG_PREDEFINED_PRECISION|FLAG_SUPPORT_SCALE,

            DOUBLE_MAX_PRECISION, DOUBLE_DEFAULT_PRECISION, DOUBLE_DEFAULT_SCALE

    );

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

            "datatype-decimal",

            FLAG_NUMBER|FLAG_SUPPORT_PRECISION|FLAG_SUPPORT_SCALE,

            DECIMAL_MAX_PRECISION, DECIMAL_DEFAULT_PRECISION, DECIMAL_DEFAULT_SCALE

    );

    this.addtype(STRING, null, "String", String.class, new CoerceToString(),

            "datatype-string",

            FLAG_SUPPORT_SIZE

    );

    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, SUBTYPE_DATE, "Timestamp", Date.class, new CoerceToTimestamp(), "datatype-timestamp");

    this.addtype(LOCALE, null, "Locale", Locale.class, new CoerceToLocale(),

            "datatype-locale"

    );

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

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

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

            new CoerceToBytearray(),

            "datatype-bytearray",

            FLAG_SUPPORT_SIZE

    );

    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, 0, PRECISION_NONE, PRECISION_NONE, SCALE_NONE);

  }

  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, 0, PRECISION_NONE, PRECISION_NONE, SCALE_NONE);

  }

  @Override

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

          Class defaultClass, Coercion coercion, String iconName, int flags) {

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

            flags, PRECISION_NONE, PRECISION_NONE, SCALE_NONE

    );

  }

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

          Class defaultClass, Coercion coercion, String iconName,

          int flags, int max_precision, int default_precision) {

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

            flags, max_precision, default_precision, SCALE_NONE

    );

  }

  @Override

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

          Class defaultClass, Coercion coercion, String iconName,

          int flags, 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,

            flags, 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 setCoercion(int type, Coercion coercion) {

//        DataType dataType = get(type);

//        dataType.setCoercion(coercion);

//    }

  @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(

            "There is not any registered data type with the class or a "

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

  }

}