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

package org.gvsig.tools.dynobject.impl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynStruct;

public class ValueType implements org.gvsig.tools.lang.Cloneable {

    DataType type;

    Class theClass;

    DynStruct theDynClass;

    public ValueType(int type) {

        this.setType(type);

    }

    public void setType(int type) {

        if ( type == DataTypes.UNKNOWN ) {

            this.type = null;

        } else {

            DataType t = ToolsLocator.getDataTypesManager().get(type);

            setType(t);

        }

    }

    public void setType(DataType type) {

        if ( this.theDynClass != null ) {

            if ( type.getType() == DataTypes.DYNOBJECT ) {

                this.type = type;

            } else if ( type.getType() == DataTypes.UNKNOWN ) {

                this.type = ToolsLocator.getDataTypesManager().get(DataTypes.DYNOBJECT);

            } else {

                throw new IllegalArgumentException("Can't set type to non DYNOBJECT when have a dynclass assigned.");

            }

        } else {

            this.type = type;

            if( this.theClass==null ) {

                this.theClass = this.type.getDefaultClass();

            }

        }

    }

    public String getSubtype() {

        if ( this.type == null ) {

            return null;

        }

        return this.type.getSubtype();

    }

    public int getType() {

        if( this.type == null ) {

            return DataTypes.UNKNOWN;

        }

        return type.getType();

    }

    public DataType getDataType() {

        return type;

    }

    public void setClassOfValue(Class theClass) {

        if( theClass == null ) {

            this.theClass = null;

            return;

        }

        if ( this.type == null || type.getType() == DataTypes.UNKNOWN ) {

            this.type = ToolsLocator.getDataTypesManager().get(DataTypes.OBJECT);

        }

        if ( type.getType() == DataTypes.DYNOBJECT && theClass!=null) {

            if( !DynObject.class.isAssignableFrom(theClass) ) {                

                throw new IllegalArgumentException("Can't assign a Class '"+theClass.getName()+"' when type is '"+type.getName()+"'.");

            }

        }

        this.theClass = theClass;

    }

    public void setClassOfValue(DynStruct dynStrct) {

        if( dynStrct == null ) {

            this.theDynClass = null;

            return;

        }

        if ( this.type == null || type.getType() == DataTypes.UNKNOWN ) {

            this.type = ToolsLocator.getDataTypesManager().get(DataTypes.DYNOBJECT);

        }

        if ( type.getType() != DataTypes.DYNOBJECT && dynStrct!=null) {

            throw new IllegalArgumentException("Can't assign a DynClass '"+dynStrct.getFullName()+"' when type is '"+type.getName()+"'.");

        }

        this.theDynClass = dynStrct;

    }

    public void setClassOfValue(String theClassNameOfValue) {

        if( theClassNameOfValue == null ) {

            this.theDynClass = null;

            this.theClass = null;

            return;

        }

        if ( this.type == null ) {

            throw new IllegalStateException("Need to set type before assign classOfValue by name");

        }

        if ( type.getType() == DataTypes.DYNOBJECT ) {

            // Probablemente habria que posponer la busqueda de la clase hasta que se

            // invoque al metodo getDynClassOfValue, ya que si se esta cargando la 

            // DynClass desde un fichero xml puede que aun no esten disponibles las

            // clases del fichero xml para ser usadas en este momento.

            //             

            this.theDynClass = ToolsLocator.getDynObjectManager().get(theClassNameOfValue);

            if ( this.theDynClass == null ) {

                throw new IllegalArgumentException("DynClass of type '" + theClassNameOfValue + "' not found.");

            }

        } else {

            try {

                Class theClass = Class.forName(theClassNameOfValue);

                this.theClass = theClass;

            } catch (ClassNotFoundException ex) {

                throw new IllegalArgumentException("The class '" + theClassNameOfValue + "' not exists.");

            }

        }

    }

    public String getClassNameOfValue() {

        if ( type == null ) {

            return null;

        }

        if ( type.getType() == DataTypes.DYNOBJECT ) {

            if ( this.theDynClass == null ) {

                return null;

            }

            return this.theDynClass.getFullName();

        }

        if ( this.theClass == null ) {

            return null;

        }

        return this.theClass.getName();

    }

    public DynStruct getDynClassOfValue() {

        return this.theDynClass;

    }

    public Class getClassOfValue() {

        return this.theClass;

    }

    public String toString() {

        if ( this.type == null ) {

            return "(null)";

        }

        return this.type.toString();

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

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

        return other;

    }    

}