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

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

        this.addtype(INT, null, "Integer", Integer.class, new CoerceToInt(), "datatype-integer");

        this.addtype(LONG, null, "Long", Long.class, new CoerceToLong(),"datatype-long");

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

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

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

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

    }

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

        Class defaultClass, Coercion coercion, String iconName) {

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

        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 (int i = 0; i < types.length; i++) {

            if (types[i] != null) {

                Class typeClass = types[i].getDefaultClass();

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

                    return types[i];

                }

            }

        }

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

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

            if (types[i] != null) {

                Class typeClass = types[i].getDefaultClass();

                if (typeClass != null

                    && typeClass.isAssignableFrom(defaultClass)) {

                    return types[i];

                }

            }

        }

        throw new IllegalArgumentException(

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

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

    }

}