View Javadoc
   package com.codestreet.messageforge;
   
   import java.util.*;
   	
   	/// <summary> Class to represent a (Java) bean field. The bean implementation must override 
   	/// <code>Equals</code> in order to work correctly with  equality methods of the framework.
   	/// </summary>
   	/// <author> Jawaid Hakim.
   	/// </author>
  	public class RFldBean extends RFld
  	{
  		public RFldType getType()
  		{
  			return RFldType.BEAN;
  		}
  
  		public Object getValue()
  		{
  				return (valSet_)?dataObj_:null;
  		}
  
  		public Class getClassType()
  		{
  				return cls_;			
  		}
  		
  		public Object getValueAsObject()
  		{
  				return (valSet_)?dataObj_:null;			
  		}
  		
  		public String getValueAsString()
  		{
  				if (!valSet_)
  					return null;
  				
  				return dataObj_.toString();			
  		}
  		
  		public Hashtable getValueAsHashtable()
  		{			
  			return null;
  		}
  
  		public String getTag()
  		{
  				return XML_TAG;
  		}
  
  		/// <summary> Default constructor.
  		/// </summary>
  		public RFldBean()
  		{
  		}
  		
  		/// <summary> Constructor.
  		/// </summary>
  		/// <param name="name">Field name.</param>
  		/// <param name="fieldId">Field id. Field ids must be either <code>0</code>
  		/// to indicate that there is no id on the field, or greater. In addition,
  		/// field ids must be unique within a messages - no two fields are allowed
  		/// to have the same field id.
  		/// </param>
  		/// <param name="className">Fully qualified class name. For example, 
  		/// <code>CodeStreet.Beans.CoolBean</code>
  		/// </param>
  		public RFldBean(String name, int fieldId, String className)
  		{
  			super(name, fieldId);
  			try
  			{
  				this.cls_ = Class.forName(className);
  			}
  			catch (ClassNotFoundException ex)
  			{
  				this.cls_ = null;
  			}
  		}
  		
  		/// <summary> Constructor.
  		/// </summary>
  		/// <param name="name">Field name.
  		/// </param>
  		/// <param name="fieldId">Field id. Field ids must be either <code>0</code>
  		/// to indicate that there is no id on the field, or greater. In addition,
  		/// field ids must be unique within a messages - no two fields are allowed
  		/// to have the same field id.
  		/// </param>
  		/// <param name="desc">Field description.
  		/// </param>
  		/// <param name="className">Fully qualified class name. For example, 
  		/// <code>CodeStreet.Beans.CoolBean</code>
  		/// </param>
  		/// </param>
  		public RFldBean(String name, int fieldId, String desc, String className)
  		{
  			super(name, fieldId, desc);
  			try
  			{
 				this.cls_ = Class.forName(className);
 			}
 			catch (ClassNotFoundException ex)
 			{
 				this.cls_ = null;
 			}
 		}
 				
 		/// <summary> Check if another field is equal to this field. Equality is defined
 		/// as the fields having the same string representation.  A short cut
 		/// that needs to be fixed for cases where the string representation is
 		/// rounding off numbers etc.
 		/// </summary>
 		/// <param name="anObject">Another field.
 		/// </param>
 		/// <returns><code>true</code> if another field is equal to this field.
 		/// Otherwise, returns <code>false</code>.
 		/// </returns>
 		public boolean equals(Object anObject)
 		{
 			if (this == anObject)
 			{
 				return true;
 			}
 			else if (anObject == null || !(anObject instanceof RFldBean))
 			{
 				return false;
 			}
 			RFldBean another = (RFldBean) anObject;
 			if (valSet_ && another.isValSet())
 				return dataObj_.equals(another.getValue());
 			else
 				return false;
 		}
 		
 		/***
 		 * Return the hash code value for the field.
 		 * @return a hash code value for the field, equal to the integer value
 		 * represented by this field.
 		 */
 		public final int hashCode()
 		{
 			return (valSet_) ? dataObj_.hashCode() : 1231;
 		}
 
 		/// <summary> Returns the hash code value for the field.
 		/// </summary>
 		/// <returns>Hash code value for the field.
 		/// 
 		/// </returns>
 		public int GetHashCode()
 		{
 			return (valSet_)?dataObj_.hashCode():1231;
 		}
 		
 		/// <summary> Reset the field value.
 		/// </summary>
 		/// <seealso cref=" #isValSet()
 		/// 
 		/// "/>
 		public void reset() throws FieldValidationException
 		{
 			if (isLocked())
 				throw new FieldValidationException("Field " + getName() + " is locked");
 						
 			valSet_ = false;
 		}
 		
 		/// <summary> Set data.
 		/// </summary>
 		/// <param name="newData">New data.
 		/// 
 		/// </param>
 		public RFld set(Object newData) throws FieldValidationException
 		{
 			validate(newData);
 			
 			dataObj_ = newData;
 			valSet_ = true;
 			
 			return this;
 		}
 						
 		/// <summary> Set data.
 		/// </summary>
 		/// <param name="newData">New data.
 		/// 
 		/// </param>
 		public RFld set(Hashtable newData) throws FieldValidationException
 		{
 			if (isLocked())
 				throw new FieldValidationException("Cannot modify locked field: " + getName());
 			
 			throw new FieldValidationException("Unable to set field value from Hashtable");
 		}
 		
 		/***
 		 * Set the field value from a JDOM element.
 		 * @param elem Field value as a JDOM element.
 		 */
 		public final RFld set(org.jdom.Element elem) throws FieldValidationException
 		{
 			return set(elem.getAttributeValue(XML_ATTR_VALUE));
 		}
 
 		/// <summary> Validate against constraints. A field is valid if either it's value is set
 		/// and satisfies all constraints, or the the field is optional.
 		/// </summary>
 		public void validate() throws FieldValidationException
 		{
 			// Only need to check that non-optional fields have been set. If a
 			// field has been set then it must be valid since validation is done
 			// with each set.
 			if (!valSet_ && !optional_)
 				throw new FieldValidationException("Field not set: " + getName());
 		}
 		
 		/// <summary> Check if a new value will satifsy constraints.
 		/// </summary>
 		/// <param name="newData">New value.
 		/// </param>
 		public void validate(Object newData) throws FieldValidationException
 		{
 			if (this.cls_ != null && ! this.cls_.equals(newData.getClass()))
 				throw new FieldValidationException("New value is of wrong type: " + newData.getClass());
 
 			if (locked_)
 				throw new FieldValidationException("Cannot modify locked field: " + getName());
 			
 			if (newData == null)
 				throw new FieldValidationException("New value is NULL for field: " + getName());
 			
 			if (newData instanceof RValidatableBean)
 			{
 			    RValidatableBean vb = (RValidatableBean)newData;
 			    try
 			    {
 			        vb.validate();
 			    }
 			    catch (BeanValidationException ex)
 			    {
 			        throw new FieldValidationException(ex);
 			    }
 			}
 			else if (Converter.getBeanValidator() != null)
 			{
 			    try
 			    {
 			        Converter.getBeanValidator().validate(newData);
 			    }
 			    catch (BeanValidationException ex)
 			    {
 			        throw new FieldValidationException(ex);
 			    }
 			}
 		}		
 		
 		/// <summary> Get the XML tag for this field type.
 		/// </summary>
 		/// <returns>XML tag for this field type.
 		/// 
 		/// </returns>
 		
 		/// <summary> Set the XML tag for this field type.
 		/// </summary>
 		/// <param name="tag">New XML tag for this field type.
 		/// 
 		/// </param>
 		
 		/// <summary> XML tag for this element type.
 		/// </summary>
 		static final String XML_TAG = "bean";
 		
 		/// <summary> Data.
 		/// </summary>
 		protected Object dataObj_;
 		protected Class cls_;
 	}