/ - Diff - Library: org.gvsig.tools - gvSIG

Revision 130

     				null,
     				null
     		);
     		definition.addDynFieldList("values").setMandatory(true).addElementsType().setType(DataTypes.STRING);
     		definition.addDynFieldList("values").setMandatory(true).setElementsType(DataTypes.STRING);
     		definition.addDynFieldList("persistentValues").setMandatory(true).setElementsType(definition2);
+    	}

     				null,
     				null
     		);
     		definition.addDynFieldSet("values").setMandatory(true).addElementsType().setType(DataTypes.STRING);
     		definition.addDynFieldSet("values").setMandatory(true).setElementsType(DataTypes.STRING);
     		definition.addDynFieldSet("persistentValues").setMandatory(true).setElementsType(definition2);
+    	}

     				null,
     				null
     		);
     		definition.addDynFieldMap("values").setMandatory(true).addElementsType().setType(DataTypes.STRING);
     		definition.addDynFieldMap("values").setMandatory(true).setElementsType(DataTypes.STRING);
     		definition.addDynFieldMap("persistentValues").setMandatory(true).setElementsType(definition2);
+    	}

     				null,
     				null
     		);
     		definition.addDynFieldArray("a").setMandatory(true).addElementsType().setType(DataTypes.INT);
     		definition.addDynFieldArray("b").setMandatory(true).addElementsType().setType(DataTypes.LONG);
     		definition.addDynFieldArray("c").setMandatory(true).addElementsType().setType(DataTypes.DOUBLE);
     		definition.addDynFieldArray("d").setMandatory(true).addElementsType().setType(DataTypes.FLOAT);
     		definition.addDynFieldArray("e").setMandatory(true).addElementsType().setType(DataTypes.BOOLEAN);
     		definition.addDynFieldArray("f").setMandatory(true).addElementsType().setType(DataTypes.STRING);
     		definition.addDynFieldArray("g").setMandatory(true).addElementsType().setType(DataTypes.DATE);
     		definition.addDynFieldArray("a").setMandatory(true).setElementsType(DataTypes.INT);
     		definition.addDynFieldArray("b").setMandatory(true).setElementsType(DataTypes.LONG);
     		definition.addDynFieldArray("c").setMandatory(true).setElementsType(DataTypes.DOUBLE);
     		definition.addDynFieldArray("d").setMandatory(true).setElementsType(DataTypes.FLOAT);
     		definition.addDynFieldArray("e").setMandatory(true).setElementsType(DataTypes.BOOLEAN);
     		definition.addDynFieldArray("f").setMandatory(true).setElementsType(DataTypes.STRING);
     		definition.addDynFieldArray("g").setMandatory(true).setElementsType(DataTypes.DATE);
+    	}
     	protected void unregister() throws PersistenceClassNotRegistered {

     	public void remove(DynStruct dynClass);
     	/**
     	 * Obtiene  la clase asociado al nombre indicado del namespace
     	 * por defecto..
     	 * Obtiene  la clase asociado al nombre indicado.
+    	 *
     	 * Si se indica un nombre con namespace la buscara en
     	 * ese namespace. if not se usara el namespace por
     	 * defecto.
+    	 *
     	 * @param name
     	 *            , nombre de la clase que queremos obtener.

     import java.util.List;
     import org.gvsig.tools.dataTypes.CoercionException;
     import org.gvsig.tools.dataTypes.DataTypes;
     import org.gvsig.tools.dynobject.exception.DynFieldIsNotAContainerException;
     import org.gvsig.tools.dynobject.exception.DynFieldValidateException;
-...
     	DynField setType(int type);
     	/**
     	 * Cuando el tipo sea  #{@link DataTypes#DYNOBJECT}, el
     	 * subtype sera el fullname de la DynStruct.
+    	 *
     	 * @param subtype
     	 * @return
     	 */
     	DynField setSubtype(String subtype);
     	DynField setDefaultDynValue(Object defaultValue);
-...
+    	 *
     	 * Return null if the type not is a container.
+    	 *
     	 * @return DynClass that define the type of elements.
     	 * @return DynField that define the type of elements.
     	 */
     	public DynStruct getElementsType();
     	public DynField getElementsType();
     	/**
      	 * Set the type of items when the field is a container.
      	 * When the type is DYNOBJECT is the DynClass associated
      	 * to this.
+     	 *
     	 * @param definition
      	 * El  tipo de los elementos de un container esta definido
      	 * mediante un DynField, que crea con el tipo pasado por
      	 * parametro y lo devuelve este metodo.
+     	 *
     	 * @param tipo de los elementos
     	 * @return this same {@link DynField} object
     	 * @throws DynFieldIsNotAContainerException
     	 */
     	public DynField setElementsType(DynStruct definition) throws DynFieldIsNotAContainerException ;
     	public DynField setElementsType(int type) throws DynFieldIsNotAContainerException ;
     	/**
     	 * Create a DynClass and asociate to the elements of this
     	 * container field and return the unique field defined in this
     	 * DynClass.
+    	 *
     	 *  This method is a utility method for define the type
     	 *  of elements of a container when this elements are
     	 *  basic types and not compound objects.
+    	 *
     	 *  The name of the DynField and DynClass created are
     	 *  the same as this field.
+    	 *
     	 * @return DynField that define the type of elements.
      	 * Set the type of items when the field is a container.
+     	 *
      	 * Metodo de utilidad que establece el typo de DYNOBJECT y
      	 * methe como subtipo el DynStruct pasado como parametro.
+     	 *
     	 * @param tipo de los elementos
     	 * @return this same {@link DynField} object
     	 * @throws DynFieldIsNotAContainerException
     	 */
     	public DynField addElementsType() throws DynFieldIsNotAContainerException ;
     	public DynField setElementsType(DynStruct type) throws DynFieldIsNotAContainerException ;
+    }

org.gvsig.tools/library/trunk/org.gvsig.tools/org.gvsig.tools.lib/src/main/java/org/gvsig/tools/dynobject/impl/DynClassImportHelper.java
52	52	private static final String FIELD_AVALILABLEVALUES_TAG = "availableValues";
53	53	private static final String FIELD_GROUP_TAG = "group";
54	54	private static final String FIELD_ORDER_TAG = "order";
	55	private static final String FIELD_HIDDEN_TAG = "hidden";
55	56
56	57	private static final String VALUEITEM_TAG = "valueItem";
57	58	private static final String VALUEITEM_LABEL_TAG = "label";

     	public void remove(DynStruct dynClass)  {
     		this.classes.remove(dynClass);
+    	}
     	public static String  getFullName(String namespace, String name) {
         	if( namespace == null ) {
         		return name;
+        	}
         	return namespace + ":" + name;
+        }
     	public static String[] splitFullName(String fullname) {
     		String[] name = new String[] { null, fullname };
     		int x=fullname.indexOf(':');
     		if( x>-1 ) {
     			name[0] = fullname.substring(0, x);
     			name[1] = fullname.substring(x+1);
+    		}
     		return name;
+    	}
     	public DynClass get(String name) {
     		return this.get(name,null);
     	public DynClass get(String theName) {
     		String[] name = splitFullName(theName);
     		return this.get(name[0],name[1]);
+    	}
     	public DynClass get(String namespace, String name ) {
-...
     		return this.classes.iterator();
+    	}
     	public DynObject createDynObject(String dynClassName) {
     		return this.createDynObject(dynClassName, null);
     		String[] name = splitFullName(dynClassName);
     		return this.createDynObject(name[1], name[0]);
+    	}
     	public DynObject createDynObject(String dynClassName, String namespace) {
-...
     		return new DynClassImportHelper().importDefinitions(resource, loader, defaultNamespace);
+    	}
     	public static String  getFullName(String namespace, String name) {
         	if( namespace == null ) {
         		return name;
+        	}
         	return namespace + ":" + name;
+        }
+    }

     import org.gvsig.tools.dataTypes.DataTypesManager;
     import org.gvsig.tools.dynobject.DynClass;
     import org.gvsig.tools.dynobject.DynField;
     import org.gvsig.tools.dynobject.DynMethod;
     import org.gvsig.tools.dynobject.DynObject;
     import org.gvsig.tools.dynobject.DynObjectValueItem;
     import org.gvsig.tools.dynobject.DynStruct;
     import org.gvsig.tools.dynobject.exception.DynFieldIsNotAContainerException;
     import org.gvsig.tools.dynobject.exception.DynFieldValidateException;
     import org.gvsig.tools.dynobject.exception.DynMethodException;
     import org.gvsig.tools.dynobject.exception.DynObjectValidateException;
     public class DefaultDynField implements DynField {
-...
     	private int dataType;
     	private String subtype;
     	private Object defaultValue;
     	private int order;
     	private boolean hidden;
     	private String groupName;
     	private String groupName;
     	private DynObjectValueItem[] availableValues;
     	private Object minValue;
     	private Object maxValue;
     	private boolean mandatory;
     	private boolean persistent;
     	private Class theClass;
     	private DynStruct elementsType;
     	private boolean validateElements;
     	private DynField elementsType;
     	private boolean validateElements;
     	public DefaultDynField(String name) {
     		this(name, // field name
     				DataTypes.UNKNOWN, // data type
     				DataTypes.STRING, // data type
     				null, // default value
     				true, // persistent
     				false // mandatory
     		);
+    	}
     	public DefaultDynField(String name, int dataType, Object defaultValue,
     			boolean persistent, boolean mandatory) {
     		this.name = name;
-...
     		this.hidden = false;
+    	}
     	public String toString() {
     		StringBuffer buffer = new StringBuffer();
         public String toString() {
         	StringBuffer buffer = new StringBuffer();
         	buffer.append("DynField").append("[").append(this.hashCode()).append("]").append("( ")
         		.append("name='").append(this.name).append("', ")
         		.append("description='").append(this.description).append("', ")
         		.append("dataType='").append(this.dataType).append(", ")
         		.append("minValue='").append(this.minValue).append(", ")
         		.append("maxValue='").append(this.maxValue).append(", ")
         		.append("mandatory='").append(this.isMandatory()).append(", ")
         		.append("persistent='").append(this.isPersistent()).append(", ")
         		.append("defaultValue='").append(this.getDefaultValue())
         		.append(" )");
         	return buffer.toString();
+        }
     		buffer.append("DynField").append("[").append(this.hashCode()).append(
     				"]").append("( ").append("name='").append(this.name).append(
     				"', ").append("description='").append(this.description).append(
     				"', ").append("dataType='").append(this.dataType).append(", ")
     				.append("minValue='").append(this.minValue).append(", ")
     				.append("maxValue='").append(this.maxValue).append(", ")
     				.append("mandatory='").append(this.isMandatory()).append(", ")
     				.append("persistent='").append(this.isPersistent())
     				.append(", ").append("defaultValue='").append(
     						this.getDefaultValue()).append(" )");
     		return buffer.toString();
+    	}
     	public String getName() {
     		return name;
+    	}
-...
     	public DynField setSubtype(String subtype) {
     		this.subtype = subtype;
     		if( subtype!=null && this.dataType == DataTypes.DYNOBJECT ) {
     			if( ToolsLocator.getDynObjectManager().get(subtype) == null ) {
     				throw new IllegalArgumentException("DynClass '"+subtype+"' does not exist.");
+    			}
+    		}
     		return this;
+    	}
-...
+    	}
     	public DynField setAvailableValues(List availableValues) {
     		this.availableValues = (DynObjectValueItem[]) availableValues.toArray(new DynObjectValueItem[availableValues.size()]) ;
     		this.availableValues = (DynObjectValueItem[]) availableValues
     				.toArray(new DynObjectValueItem[availableValues.size()]);
     		return this;
+    	}
-...
+    	}
     	public DynField setTheTypeOfAvailableValues(int type) {
     		return this;  // FIXME: this method is @deprecated
     		return this; // FIXME: this method is @deprecated
+    	}
     	public int getTheTypeOfAvailableValues() {
     		return 1; // FIXME: this method is @deprecated
+    	}
     	public boolean equals(Object obj) {
     		if (this == obj) {
     			return true;
+    		}
     		if (obj instanceof DynField) {
     			// FIXME: No esta claro que esto sea correcto.
     			return name.equals(((DynField) obj).getName());
+    		}
     		return false;
+    	}
         public boolean equals(Object obj) {
             if (this == obj) {
                 return true;
+            }
             if (obj instanceof DynField) {
             	// FIXME: No esta claro que esto sea correcto.
                 return name.equals(((DynField) obj).getName());
+            }
             return false;
+        }
     	public Class getClassOfValue() {
     		return theClass;
+    	}
     	public DynField setValidateElements(boolean validate) {
     		switch(this.dataType) {
     		switch (this.dataType) {
     		case DataTypes.ARRAY:
     		case DataTypes.LIST:
     		case DataTypes.MAP:
-...
     		this.validateElements = validate;
     		return this;
+    	}
     	public boolean getValidateElements() {
     		return this.validateElements;
+    	}
     	public DynField setClassOfValue(Class theClass) throws DynFieldIsNotAContainerException{
     		switch(this.dataType) {
     	public DynField setClassOfValue(Class theClass)
     			throws DynFieldIsNotAContainerException {
     		switch (this.dataType) {
     		case DataTypes.OBJECT:
     		case DataTypes.ARRAY:
     		case DataTypes.LIST:
-...
     		return this;
+    	}
     	public DynField setElementsType(DynStruct dynClass)  throws DynFieldIsNotAContainerException{
     		switch(this.dataType) {
     		case DataTypes.OBJECT:
     		case DataTypes.ARRAY:
     		case DataTypes.LIST:
     		case DataTypes.MAP:
     		case DataTypes.SET:
     			break;
     		default:
     	public DynField setElementsType(int type)
     			throws DynFieldIsNotAContainerException {
     		if (!ToolsLocator.getDataTypesManager().isContainer(this.dataType)) {
     			throw new DynFieldIsNotAContainerException(this.name);
+    		}
     		this.elementsType = dynClass;
     		this.elementsType = new DefaultDynField(this.name + "-"
     				+ ToolsLocator.getDataTypesManager().getTypeName(this.dataType)
     				+ "-item");
     		return this;
+    	}
     	public DynField addElementsType()  throws DynFieldIsNotAContainerException{
     		switch(this.dataType) {
     		case DataTypes.ARRAY:
     		case DataTypes.LIST:
     		case DataTypes.MAP:
     		case DataTypes.SET:
     			break;
     		default:
     			throw new DynFieldIsNotAContainerException(this.name);
+    		}
     		DynField dynField = new DefaultDynField(this.name+"-"+ToolsLocator.getDataTypesManager().getTypeName(this.dataType)+"-item");
     		this.elementsType = new ElementTypeWrapper(this.name, this.description, dynField);
     		return dynField;
     	public DynField setElementsType(DynStruct type)
     			throws DynFieldIsNotAContainerException {
     		this.setElementsType(DataTypes.DYNOBJECT).getElementsType().setSubtype(type.getFullName());
     		return this;
+    	}
     	public DynStruct getElementsType() {
     	public DynField getElementsType() {
     		return this.elementsType;
+    	}
     	public void validate(Object value) throws DynFieldValidateException {
     		Comparable v;
     		if( value == null ) {
     			if( this.mandatory ) {
     				throw new DynFieldValidateException(value,this);
     		if (value == null) {
     			if (this.mandatory) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			return;
+    		}
     		switch( this.dataType ) {
     		switch (this.dataType) {
     		case DataTypes.BOOLEAN:
     			if( ! (value instanceof Boolean) ) {
     				throw new DynFieldValidateException(value,this);
     			if (!(value instanceof Boolean)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			break;
     		case DataTypes.DOUBLE:
     			if( ! (value instanceof Double) ) {
     				throw new DynFieldValidateException(value,this);
     			if (!(value instanceof Double)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			break;
     		case DataTypes.FLOAT:
     			if( ! (value instanceof Float) ) {
     				throw new DynFieldValidateException(value,this);
     			if (!(value instanceof Float)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			break;
     		case DataTypes.INT:
     			if( ! (value instanceof Integer) ) {
     				throw new DynFieldValidateException(value,this);
     			if (!(value instanceof Integer)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			break;
     		case DataTypes.LONG:
     			if( ! (value instanceof Long) ) {
     				throw new DynFieldValidateException(value,this);
     			if (!(value instanceof Long)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			break;
     		case DataTypes.STRING:
     			if( ! (value instanceof String) ) {
     				throw new DynFieldValidateException(value,this);
     			if (!(value instanceof String)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			break;
     		case DataTypes.DATE:
     			if( ! (value instanceof Date) ) {
     				throw new DynFieldValidateException(value,this);
     			if (!(value instanceof Date)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			break;
     		case DataTypes.LIST:
     			if( ! (value instanceof List) ) {
     				throw new DynFieldValidateException(value,this);
     			if (!(value instanceof List)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			if ( this.validateElements && this.elementsType != null) {
     				if( this.elementsType instanceof ElementTypeWrapper) {
     					DynField field = ((ElementTypeWrapper)this.elementsType).getDynField();
     					Iterator it = ((List)value).iterator();
     					while( it.hasNext() ) {
     						field.validate( it.next() );
+    					}
     				} else {
     					DynStruct dynClass = this.elementsType;
     					Iterator it = ((List)value).iterator();
     					while( it.hasNext() ) {
     						try {
     							Object obj = it.next();
     							dynClass.validate((DynObject) obj);
     						} catch (DynObjectValidateException e) {
     							throw new DynFieldValidateException(value,this,e);
+    						}
+    					}
     			if (this.validateElements && this.elementsType != null) {
     				Iterator it = ((List) value).iterator();
     				while (it.hasNext()) {
     					this.elementsType.validate(it.next());
+    				}
+    			}
     			break;
     		case DataTypes.MAP:
     			if( ! (value instanceof Map) ) {
     				throw new DynFieldValidateException(value,this);
     			if (!(value instanceof Map)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			break;
     		case DataTypes.SET:
     			if( ! (value instanceof Set) ) {
     				throw new DynFieldValidateException(value,this);
     			if (!(value instanceof Set)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			break;
     		case DataTypes.OBJECT:
     			if( this.theClass != null ) {
     				if(! this.theClass.isInstance(value)) {
     					throw new DynFieldValidateException(value,this);
     			if (this.theClass != null) {
     				if (!this.theClass.isInstance(value)) {
     					throw new DynFieldValidateException(value, this);
+    				}
     			} else if( this.elementsType!= null ) {
     				if( ! (value instanceof DynObject) ) {
     					throw new DynFieldValidateException(value,this);
+    				}
     				if( !this.elementsType.getFullName().equals(((DynObject)value).getDynClass().getFullName()) )  {
     					throw new DynFieldValidateException(value,this);
+    				}
     				try {
     					((DynObject)value).getDynClass().validate((DynObject)value);
     				} catch (DynObjectValidateException e) {
     					throw new DynFieldValidateException(value,this, e);
+    				}
+    			}
     			break;
     		case DataTypes.DYNOBJECT:
     			if (!(value instanceof DynObject)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			DynClass dynClass = ToolsLocator.getDynObjectManager().get(
     					this.getSubtype());
     			if ( dynClass==null || !dynClass.isInstance((DynObject) value)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			try {
     				dynClass.validate((DynObject) value);
     			} catch (DynObjectValidateException e) {
     				throw new DynFieldValidateException(value, this, e);
+    			}
     			break;
     		case DataTypes.ARRAY:
     			// TODO: falta verificar que es un array del tipo que toca.
     			break;
     		default:
     			throw new DynFieldValidateException(value,this);
     			throw new DynFieldValidateException(value, this);
+    		}
     		if( this.mandatory && value==null ) {
     			throw new DynFieldValidateException(value,this);
     		if (this.mandatory && value == null) {
     			throw new DynFieldValidateException(value, this);
+    		}
     		if( this.getAvailableValues() != null ) {
     			if( !(value instanceof Comparable) ) {
     				throw new DynFieldValidateException(value,this);
     		if (this.getAvailableValues() != null) {
     			if (!(value instanceof Comparable)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			v = (Comparable)value;
     			v = (Comparable) value;
     			boolean ok = false;
     			for( int i=0; i<this.availableValues.length; i++ ) {
     				if( v.compareTo(this.availableValues[i].getValue())==0) {
     			for (int i = 0; i < this.availableValues.length; i++) {
     				if (v.compareTo(this.availableValues[i].getValue()) == 0) {
     					ok = true;
     					break;
+    				}
+    			}
     			if( !ok ) {
     				throw new DynFieldValidateException(value,this);
     			if (!ok) {
     				throw new DynFieldValidateException(value, this);
+    			}
     		} else if( this.getMaxValue()!=null && this.getMinValue()!=null ) {
     			if( !(value instanceof Comparable) ) {
     				throw new DynFieldValidateException(value,this);
     		} else if (this.getMaxValue() != null && this.getMinValue() != null) {
     			if (!(value instanceof Comparable)) {
     				throw new DynFieldValidateException(value, this);
+    			}
     			v = (Comparable)value;
     			if( v.compareTo(this.minValue)<0 || v.compareTo(this.maxValue)>0 ) {
     				throw new DynFieldValidateException(value,this);
     			v = (Comparable) value;
     			if (v.compareTo(this.minValue) < 0
     					|| v.compareTo(this.maxValue) > 0) {
     				throw new DynFieldValidateException(value, this);
+    			}
+    		}
+    	}
     	public Object coerce(Object value) throws CoercionException {
     		if( value == null ) {
     			return value; // O debe retorna this.defaultValue
+    		}
     		if (value == null) {
     			return value; // O debe retorna this.defaultValue
+    		}
     		DataTypesManager manager = ToolsLocator.getDataTypesManager();
     		return manager.coerce(this.dataType, value);
+    	}
     	class ElementTypeWrapper implements DynClass {
     	    private DynField[] declaredFields;
     		private String name;
     		private String description;
     		ElementTypeWrapper(String name, String description, DynField dynField) {
     			this.declaredFields =  new DynField[] { dynField };
     			this.name = name;
     			this.description = description;
+    		}
     		public DynField getDynField() {
     			return this.declaredFields[0];
+    		}
     		public DynField getDeclaredDynField(String name) {
     			if( this.name.equals(name) ) {
     				return this.declaredFields[0];
+    			}
     			return null;
+    		}
     		public DynField[] getDeclaredDynFields() {
     			return this.declaredFields;
+    		}
     		public String getDescription() {
     			return this.description;
+    		}
     		public DynField getDynField(String name) {
     			if( this.name.equals(name) ) {
     				return this.declaredFields[0];
+    			}
     			return null;
+    		}
     		public DynField[] getDynFields() {
     			return this.declaredFields;
+    		}
     		public String getFullName() {
     			return this.name;
+    		}
     		public String getName() {
     			return this.name;
+    		}
     		public String getNamespace() {
     			return null;
+    		}
     		public DynClass[] getSuperDynClasses() {
     			return null;
+    		}
     		public boolean isInstance(DynObject dynObject) {
     			return false;
+    		}
     		public DynObject newInstance() {
     			return null;
+    		}
     		public void addDynMethod(DynMethod dynMethod) {
     			throw new UnsupportedOperationException();
+    		}
     		public void extend(String dynClassName) {
     			throw new UnsupportedOperationException();
+    		}
     		public void extend(String namespace, String dynClassName) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynMethod getDeclaredDynMethod(String name)
     				throws DynMethodException {
     			throw new UnsupportedOperationException();
+    		}
     		public DynMethod[] getDeclaredDynMethods() throws DynMethodException {
     			throw new UnsupportedOperationException();
+    		}
     		public DynMethod getDynMethod(String name) throws DynMethodException {
     			throw new UnsupportedOperationException();
+    		}
     		public DynMethod getDynMethod(int code) throws DynMethodException {
     			throw new UnsupportedOperationException();
+    		}
     		public DynMethod[] getDynMethods() throws DynMethodException {
     			throw new UnsupportedOperationException();
+    		}
     		public void removeDynMethod(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynField(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldArray(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldBoolean(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldChoice(String name, int type,
     				Object defaultValue, DynObjectValueItem[] values,
     				boolean mandatory, boolean persistent) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldChoice(String name, int type,
     				Object defaultValue, DynObjectValueItem[] values) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldDouble(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldFloat(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldInt(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldList(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldLong(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldMap(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldObject(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldRange(String name, int type,
     				Object defaultValue, Object min, Object max, boolean mandatory,
     				boolean persistent) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldRange(String name, int type,
     				Object defaultValue, Object min, Object max) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldSet(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldSingle(String name, int type,
     				Object defaultValue, boolean mandatory, boolean persistent) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldSingle(String name, int type,
     				Object defaultValue) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldString(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public void removeDynField(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public void validate(DynObject object)
     				throws DynObjectValidateException {
     			throw new UnsupportedOperationException();
+    		}
     		public DynField addDynFieldDate(String name) {
     			throw new UnsupportedOperationException();
+    		}
     		public void extend(DynStruct struct) {
     			throw new UnsupportedOperationException();
+    		}
     		public DynStruct[] getSuperDynStructs() {
     			throw new UnsupportedOperationException();
+    		}
     		public void setDescription(String description) {
     			throw new UnsupportedOperationException();
+    		}
     		public void setNamespace(String namespace) {
     			throw new UnsupportedOperationException();
+    		}
+    	}
     	public String getGroup() {
     		return this.groupName;
+    	}
-...
     		this.hidden = hidden;
     		return this;
+    	}
+    }

      */
     public interface DataTypes {
     	public static final int INVALID = -1;
     	public static final int INVALID = 0x00;
     	public static final int UNKNOWN = 0x00;
     	public static final int BOOLEAN = 0x01;
-...
     	public static final int BYTEARRAY = 0x0C;
     	public static final int FILE = 0x0D;
     	public static final int FOLDER = 0x0E;
     	public static final int DYNOBJECT = 0x0F;
     	public static final int CONTAINER = 0x10;
     	public static final int ARRAY = 0x11;
     	public static final int LIST = 0x12;
     	public static final int SET = 0x13;
     	public static final int MAP = 0x14;
     	public static final int DYNOBJECT = 0x15;
     	public static final int OBJECT = 0x20;

org.gvsig.tools/library/trunk/org.gvsig.tools/org.gvsig.tools.lib/src/main/java/org/gvsig/tools/dataTypes/impl/DefaultDataTypesManager.java
48	48	}
49	49
50	50	public String getTypeName(int type) {
51		if( type<0 \|\| type>0x40 ) {
	51	if( type<1 \|\| type>0x40 ) {
52	52	return "unknow";
53	53	}
54	54	String name = TYPE_NAMES[type];
...	...
70	70	}
71	71
72	72	public Class getDefaultClass(int type) {
73		if( type<0 \|\| type>0x40 ) {
	73	if( type<1 \|\| type>0x40 ) {
74	74	return null;
75	75	}
76	76	return DEFAULT_CLASSES[type];
77	77	}
78	78
79	79	public String getSubtype(int type) {
80		if( type<0 \|\| type>0x40 ) {
	80	if( type<1 \|\| type>0x40 ) {
81	81	return null;
82	82	}
83	83	return SUBTYPES[type];

Also available in: Unified diff

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

Revision 130