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.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.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 org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dataTypes.DataTypesManager;

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

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

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

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

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

  }

}