View Javadoc
   /***
    * Copyright (c) 2002, CodeStreet LLC. All rights reserved.
    * <p>
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    * <p>
    * Redistributions of source code must retain the above copyright notice, this
    * list of conditions and the following disclaimer. Redistributions in binary
    * form must reproduce the above copyright notice, this list of conditions and
   * the following disclaimer in the documentation and/or other materials provided
   * with the distribution. Neither the name of CodeStreet LLC. nor the names of
   * its contributors may be used to endorse or promote products derived from this
   * software without specific prior written permission.
   * <p>
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT(INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   * <p>
   */
  
  package com.codestreet.messageforge;
  
  import java.util.ArrayList;
  import java.util.List;
  
  /***
   * Base class for all message classes. A message contains a collection of RFld
   * instances. Each message implements a fast-fail strategy for field validations -
   * i.e. a field is validated each time its value is set. To make sure that a
   * message is valid it is still important to call {@link #validate()}to make
   * sure that all non-optional fields have been set.
   * <p>
   * In the typical usage, a message object is defined via XML and the JAVA class
   * for the message generated by the code-generator. In some other applications,
   * it might be necessary to have the ability to create empty messages - messages
   * with no fields - and add fields to these messages on the fly. Fields can be
   * created explicitly or by using the <tt>RFldFactory</tt>.
   * 
   * @author Jawaid Hakim.
   */
  public class RMsg implements RMapMessage
  {
      static final long serialVersionUID = -6057031037833465192L;
  
      //Generated by jserial
  
      /***
       * Default constructor. Sets the empty message flag to <tt>true</tt>.
       * 
       * @see #setEmptyMsg(boolean)
       */
      public RMsg()
      {
          init(null, null);
          setEmptyMsg(true);
      }
  
      /***
       * Constructor.
       * 
       * @param name
       *            Message name.
       * @param desc
       *            Description of message.
       */
      public RMsg(String name, String desc)
      {
          init(name, desc);
      }
  
      /***
       * Create nested fields in message. All fields in the message are of type
       * <tt>MSGOBJ</tt> or <tt>BEAN</tt> are created if not already set.
       */
      public void createNested()
      {
          RFld[] flds = this.getFieldsAsArray();
          for (int i = 0; i < flds.length; ++i)
          {
              RFld fld = flds[i];
              if (fld.isValSet())
                  continue;
  
              if (fld.getType() == RFldType.MSGOBJ)
              {
                  RFldMsgObj msgObjFld = (RFldMsgObj) fld;
                  Class cls = msgObjFld.getClassObject();
                  if (cls != null)
                  {
                      try
                      {
                         RMsg newData = (RMsg) cls.newInstance();
                         newData.createNested();
                         msgObjFld.set(newData);
                     }
                     catch (FieldValidationException ex)
                     {
                         throw new RBaseRuntimeException(ex);
                     }
                     catch (InstantiationException ex)
                     {
                         throw new RBaseRuntimeException(ex);
                     }
                     catch (IllegalAccessException ex)
                     {
                         throw new RBaseRuntimeException(ex);
                     }
                 }
             }
             else if (fld.getType() == RFldType.BEAN)
             {
                 RFldBean beanFld = (RFldBean) fld;
                 Class cls = beanFld.getClassType();
                 if (cls != null)
                 {
                     try
                     {
                         Object newData = cls.newInstance();
                         beanFld.set(newData);
                     }
                     catch (FieldValidationException ex)
                     {
                         throw new RBaseRuntimeException(ex);
                     }
                     catch (InstantiationException ex)
                     {
                         throw new RBaseRuntimeException(ex);
                     }
                     catch (IllegalAccessException ex)
                     {
                         throw new RBaseRuntimeException(ex);
                     }
                 }
             }
         }
     }
 
     /***
      * Initialize.
      * 
      * @param desc
      *            Description of message.
      */
     private void init(String name, String desc)
     {
         flds_ = new java.util.HashMap();
         if (noCaseFldNames_)
             noCaseFlds_ = new java.util.HashMap();
         setDesc(desc);
         setName(name);
     }
 
     /***
      * Get all fields in the message.
      * 
      * @return Iterator of all RFld fields in the message.
      */
     public final java.util.Iterator getFields()
     {
         return flds_.values().iterator();
     }
 
     /***
      * Get all fields in the message.
      * 
      * @return Array of all <tt>RFld</tt> fields in the message.
      */
     public final RFld[] getFieldsAsArray()
     {
         if (fldsArray_ != null)
             return fldsArray_;
         return buildFieldsArray();
     }
 
     /***
      * This method allows subclasses to signal that all fields have been added
      * to the message. All subclasses should call this method after adding all
      * fields to the message.
      */
     protected final void doneAddingFields()
     {
         buildFieldsArray();
     }
 
     /***
      * Get all fields in the message.
      * 
      * @return Array of all <tt>RFld</tt> fields in the message.
      */
     private final RFld[] buildFieldsArray()
     {
         fldsArray_ = new RFld[flds_.size()];
         int i = 0;
         for (java.util.Iterator iter = getFields(); iter.hasNext();)
         {
             fldsArray_[i++] = (RFld) iter.next();
         }
 
         return fldsArray_;
     }
 
     /***
      * Get a <tt>java.util.List</tt> with the names of all fields that have
      * the specified search <tt>tag</tt> as one of their tags.
      * 
      * @param searchTag
      *            Search tag. If the search tag is <tt>null</tt> then the
      *            names of all fields that do not have any tags are returned.
      * @param ignoreCase
      *            Case insensitive tag compare is performed if this paramater is
      *            <tt>true</tt>. Otherwise, case sensitive tag compare is
      *            performed.
      * @return <tt>java.util.List</tt> with the names of all fields whose
      *         <tt>tag</tt> matches the specified search <tt>tag</tt>.
      * @see RFld#getTags()
      * @see RFld#setTags(String[])
      */
     public final java.util.List getTaggedFields(String searchTag,
             boolean ignoreCase)
     {
         java.util.List taggedFlds = new java.util.ArrayList();
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             RFld fld = fldsArray[i];
             String[] tags = fld.getTags();
             if (searchTag == null)
             {
                 if (tags == null)
                     taggedFlds.add(fld.getName());
             }
             else if (tags != null)
             {
                 for (int j = tags.length - 1; j >= 0; --j)
                 {
                     String tag = tags[j];
                     boolean equals = (ignoreCase) ? tag
                             .equalsIgnoreCase(searchTag) : tag
                             .equals(searchTag);
                     if (equals)
                     {
                         taggedFlds.add(fld.getName());
                         break;
                     }
                 }
             }
         }
         return taggedFlds;
     }
 
     /***
      * Reset all unlocked fields in the message.
      * 
      * @see RFld#isLocked()
      * @see RFld#reset()
      */
     public final void resetFields()
     {
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             RFld fld = fldsArray[i];
             if (!fld.isLocked())
             {
                 try
                 {
                     fld.reset();
                 }
                 catch (FieldValidationException ex)
                 {
                     // OK to eat up exception
                 }
             }
         }
     }
 
     /***
      * Set the field values of this message from another source message. A field
      * in the source object will be copied if there is a field in the this
      * object with the same name, and the source field has been set, and the
      * target field is not locked. An implicit assumption is that if the source
      * and the target have fields with the same name, then the types of the
      * fields are the same - if this assumption is violated then an exception is
      * thrown.
      * 
      * @param another
      *            Source message.
      * @see RFld#getType()
      * @see #setFieldsIgnoreConstrained(RMsg)
      */
     public final void setFields(RMsg another) throws FieldValidationException
     {
         setFields(another, false);
     }
 
     /***
      * Set the field values of this message from another source message. Fields
      * in this message that have constraints are ignored. A field in the source
      * object will be copied if there is a field in the this object with the
      * same name, and the source field has been set, and the target field is not
      * locked. An implicit assumption is that if the source and the target have
      * fields with the same name, then the types of the fields are the same - if
      * this assumption is violated then an exception is thrown.
      * 
      * @param another
      *            Source message.
      * @see RFld#getType()
      * @see #setFields(RMsg)
      */
     public final void setFieldsIgnoreConstrained(RMsg another)
             throws FieldValidationException
     {
         setFields(another, true);
     }
 
     /***
      * Set the field values of this message from another source message. A field
      * in the source object will be copied if there is a field in the this
      * object with the same name, and the source field has been set, and the
      * target field is not locked. An implicit assumption is that if the source
      * and the target have fields with the same name, then the types of the
      * fields are the same - if this assumption is violated then an exception is
      * thrown.
      * 
      * @param another
      *            Source message.
      * @param ignoreConstrained
      *            Flagh to indicate whether constrained fields should be
      *            ignored. If <tt>true</tt> then fields that have constraints
      *            are not set.
      * @see RFld#getType()
      */
     protected final void setFields(RMsg another, boolean ignoreConstrained)
             throws FieldValidationException
     {
         // Sanity check
         if (this == another)
             return;
 
         StringBuffer errors = null;
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             RFld fld = fldsArray[i];
             if (fld.isLocked() || (ignoreConstrained && fld.isConstrained()))
                 continue;
 
             String fldName = fld.getName();
             if (another.fieldExists(fldName))
             {
                 RFld anotherFld = another.getField(fldName);
                 if (anotherFld.isValSet())
                 {
                     try
                     {
                         fld.set(anotherFld.getValueAsObject());
                     }
                     catch (FieldValidationException ex)
                     {
                         if (errors == null)
                             errors = new StringBuffer(128);
 
                         errors.append(ex.toString()).append(": ").append(
                                 fldName).append('\n');
                     }
                 }
             }
         }
         if (errors != null)
             throw new FieldValidationException(errors.toString());
     }
 
     /***
      * Compare this message with another source message and return the names of
      * all fields in the other message that are either not in this message or
      * are in this message but have a different field type.
      * 
      * @param another
      *            Source message.
      * @return Array of field names.
      * @see RFld#getType()
      */
     public final Object[] diffFields(RMsg another)
             throws FieldValidationException
     {
         // Sanity check
         if (this == another)
             return new Object[0];
 
         java.util.List result = new java.util.ArrayList();
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             RFld anotherFld = fldsArray[i];
             String anotherFldName = anotherFld.getName();
             if (fieldExists(anotherFldName))
             {
                 RFld thisFld = getField(anotherFldName);
                 if (thisFld.getType() != anotherFld.getType())
                     result.add(anotherFldName);
             }
             else
                 result.add(anotherFldName);
         }
 
         // Create object array
         return result.toArray();
     }
 
     /***
      * Get message name.
      * 
      * @return Message name.
      */
     public final String getName()
     {
         return name_;
     }
 
     /***
      * Set message name.
      * 
      * @param name
      *            Message name.
      */
     protected final void setName(String name)
     {
         name_ = (name != null) ? name : RFldString.NA_VALUE;
     }
 
     /***
      * Get message description.
      * 
      * @return Message description.
      */
     public final String getDesc()
     {
         return desc_;
     }
 
     /***
      * Set message description.
      * 
      * @param desc
      *            Message description.
      */
     protected final void setDesc(String desc)
     {
         desc_ = (desc != null) ? desc : RFldString.NA_VALUE;
     }
 
     /***
      * Add a field to the message.
      * 
      * @param fld
      *            Field to add to message.
      * @see RFld
      */
     public final void addField(RFld fld) throws FieldValidationException
     {
         String fldName = fld.getName();
         if (fieldExists(fldName))
             throw new FieldValidationException("Field already exists: "
                     + fldName);
 
         flds_.put(fldName, fld);
         if (noCaseFlds_ != null)
             noCaseFlds_.put(fldName.toUpperCase(), fld);
 
         // Since a new field was added invalidate the fields array - the fields
         // array will be re-generated the next time someone asks for it.
         fldsArray_ = null;
     }
 
     /***
      * Add a required group to the message.
      * 
      * @param reqGrp
      *            Required group.
      * @throws IllegalArgumentException
      *             if required group is <tt>null</tt>.
      * @see RRequiredGrp
      */
     protected final void addRequiredGrp(RRequiredGrp reqGrp)
     {
         if (reqGrp == null)
             throw new java.lang.IllegalArgumentException("NULL required group");
 
         if (reqGrps_ == null)
             reqGrps_ = new java.util.ArrayList();
 
         reqGrps_.add(reqGrp);
     }
 
     /***
      * Validate message. A message is valid if all its non-optional fields have
      * been set. <br>
      */
     public final void validate() throws FieldValidationException
     {
         String errMsg = validateMsg(this, null);
         if (errMsg != null && errMsg.length() != 0)
         {
             errMsg = "\nMessage name = " + this.getName() + "\n" + errMsg;
             throw new FieldValidationException(errMsg);
         }
         validateRequiredGrps();
     }
 
     /***
      * Validate message. A message is valid if all its non-optional fields have
      * been set. <br>
      */
     public final void notRecuriveValidate() throws FieldValidationException
     {
         StringBuffer errors = null;
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             // Make sure that all non-optional fields have been set
             RFld fld = fldsArray[i];
             if (fld.isValSet() || fld.getOptional())
                 continue;
 
             if (errors == null)
                 errors = new StringBuffer(128);
             errors.append("\tRequired field not set: ").append(fld.getName())
                     .append('\n');
         }
         if (errors != null)
             throw new FieldValidationException(errors.toString());
 
         validateRequiredGrps();
     }
 
     /***
      * Recusively validiate the RMsg
      * 
      * @param msg
      *            The RMsg to validate
      * @param outerFieldNameList
      *            a way to keep track of the fieldname during recursion.
      * @return Returns error if any field in message in invalid. Returns empty
      *         string if message is valid.
      */
     public static String validateMsg(RMsg msg, List outerFieldNameList)
     {
         String err = "";
         RFld[] fldsArray = msg.getFieldsAsArray();
         for (int i = 0; i < fldsArray.length; i++)
         {
             err = validateFld(fldsArray[i], outerFieldNameList);
             if (err != null)
                 break;
         }
         return err;
     }
 
     /***
      * If the field contains another RMsg, then call validateMsg, otherwise just
      * check if all not optional fields were set.
      * 
      * @param fld
      *            The RFld to validate.
      * @param outerFieldNameList
      *            a way to keep track of the fieldname during recursion.
      */
     public static String validateFld(RFld fld, List outerFieldNameList)
     {
         String errors = null;
         if (fld.isValSet())
         {
             if (fld.getType().equals(RFldType.MSGOBJ))
             {
                 if (outerFieldNameList == null)
                     outerFieldNameList = new ArrayList();
                 String outerFldName = fld.getName() + ".";
                 outerFieldNameList.add(outerFldName);
                 errors = validateMsg(((RFldMsgObj) fld).getValue(),
                         outerFieldNameList);
                 outerFieldNameList.remove(outerFldName);
             }
         }
         else if (!fld.getOptional())
         {
             String outerFieldName = convertList(outerFieldNameList);
             errors = "Required field <" + outerFieldName + fld.getName()
                     + "> not set\n";
         }
         return errors;
     }
 
     private static String convertList(List list)
     {
         String ret = "";
         if (list != null)
         {
             StringBuffer sb = new StringBuffer();
             for (int i = 0; i < list.size(); i++)
             {
                 sb.append(list.get(i));
             }
             ret = sb.toString();
         }
         return ret;
     }
 
     /***
      * Validate required field groups.
      */
     public final void validateRequiredGrps() throws FieldValidationException
     {
         if (reqGrps_ == null)
             return;
 
         for (int i = reqGrps_.size() - 1; i >= 0; --i)
         {
             RRequiredGrp reqGrp = (RRequiredGrp) reqGrps_.get(i);
             String[] condFldNames = reqGrp.getConditionalFields();
             String[] condFldValues = reqGrp.getConditionalValues();
 
             // Sanity check
             if (condFldNames.length != condFldValues.length)
                 throw new FieldValidationException(
                         "Conditional field name/value count mismatch");
 
             // Check if all conditional fields are set to their specified value
             boolean enabled = true;
             for (int j = 0; j < condFldNames.length; ++j)
             {
                 RFld condFld = getField(condFldNames[j]);
                 if (!condFld.isValSet())
                     throw new FieldValidationException(
                             "Conditional field not set: " + condFld.getName());
 
                 String condValue = condFldValues[j];
                 if (condFld instanceof RFldString)
                 {
                     RFldString fldStr = (RFldString) condFld;
                     if (!condValue.equals(fldStr.getValue()))
                     {
                         enabled = false;
                         break;
                     }
                 }
                 else if (condFld instanceof RFldBool)
                 {
                     RFldBool fldBool = (RFldBool) condFld;
                     if (Boolean.valueOf(condValue).booleanValue() != fldBool
                             .getValue())
                     {
                         enabled = false;
                         break;
                     }
                 }
                 else if (condFld instanceof RFldNumeric)
                 {
                     // TODO: handle numeric fields.
                     throw new FieldValidationException("Not implemented");
                 }
             }
 
             // If the conditional trigger is enabled then make sure
             // the required fields are set.
             if (enabled)
             {
                 String[] reqFlds = reqGrp.getRequiredFields();
                 for (int j = reqFlds.length - 1; j >= 0; --j)
                 {
                     RFld reqFld = getField(reqFlds[j]);
                     if (!reqFld.isValSet())
                         throw new FieldValidationException("Field not set: "
                                 + reqFlds[j]);
                 }
             }
         }
     }
 
     /***
      * Apply a functor to all fields in the message.
      * 
      * @param func
      *            Functor
      * @return The number of fields to which the functor was applied.
      * @see RFunctor
      */
     public final int apply(RFunctor func) throws FieldValidationException
     {
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
             func.apply(fldsArray[i]);
 
         return fldsArray.length;
     }
 
     /***
      * Apply a functor to a named field in the message.
      * 
      * @param func
      *            Functor.
      * @param fldName
      *            Field name.
      * @return <tt>true</tt> if the named field was found and the functor was
      *         applied to it.
      * @see RFunctor
      */
     public final boolean apply(RFunctor func, String fldName)
             throws FieldValidationException
     {
         func.apply(getField(fldName));
         return true;
     }
 
     /***
      * Get a named field from this message. Returns <tt>null</tt> if the named
      * field is not in the message. Either there is an exact match for the field
      * name, or, case-insentitive names are enabled and there is a
      * case-insensitive field name match.
      * 
      * @param fldName
      *            Field name.
      * @return Named field.
      */
     public final RFld getFieldIfExists(String fldName)
             throws FieldValidationException
     {
         RFld fld = (RFld) flds_.get(fldName);
         if (fld == null && noCaseFlds_ != null)
             fld = (RFld) noCaseFlds_.get(fldName.toUpperCase());
 
         return fld;
     }
 
     /***
      * Get a named field from this message. Throws an exception if the named
      * field is not in the message. Either there is an exact match for the field
      * name, or, case-insentitive names are enabled and there is a
      * case-insensitive field name match.
      * 
      * @param fldName
      *            Field name.
      * @return Named field.
      */
     public final RFld getField(String fldName) throws FieldValidationException
     {
         RFld fld = getFieldIfExists(fldName);
         if (fld != null)
             return fld;
 
         throw new FieldValidationException("Field not found in message: "
                 + fldName);
     }
 
     /***
      * Get Lock/Unlock property of the message object. If a message is locked
      * then all the setter methods are disabled.
      * 
      * @return Returns <tt>true</tt> if object is locked. Otherwise, returns
      *         <tt>false</tt>.
      */
     public final boolean isLocked()
     {
         return locked_;
     }
 
     /***
      * Lock/Unlock the message object and all its fields.
      * 
      * @param locked
      *            <tt>true</tt> to lock the object. Otherwise, <tt>false</tt>
      *            to unlock the object.
      */
     public final void setLocked(boolean locked)
     {
         // Lock message and all fields.
         locked_ = locked;
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
             fldsArray[i].setLocked(locked);
     }
 
     /***
      * Check if the send subject has been fixed.
      * 
      * @return Returns <tt>true</tt> if the send subject has been fixed.
      *         Otherwise, returns <tt>false</tt>.
      * @see #setSendSubject(String)
      * @see #clearSendSubject()
      */
     public final boolean isSendSubjectFixed()
     {
         return (fixedSendSubject_ != null);
     }
 
     /***
      * Clears the send subject if it has been fixed.
      * 
      * @see #isSendSubjectFixed()
      * @see #setSendSubject(String)
      */
     public final void clearSendSubject()
     {
         fixedSendSubject_ = null;
     }
 
     /***
      * Set the send subject. Once the send subject has been fixed, it is not
      * re-computed at run time, and is instead used for single and multiple send
      * subjects.
      * 
      * @param fixedSendSubject
      *            Fixed send subject.
      * @see #isSendSubjectFixed()
      * @see #clearSendSubject()
      */
     public final void setSendSubject(String fixedSendSubject)
     {
         fixedSendSubject_ = fixedSendSubject;
     }
 
     /***
      * Set subject parameters.
      * 
      * @param params
      *            Map of parameter placeholder values. Key into the hashtable is
      *            the name of the placeholder and the value is the value of the
      *            placeholder. Parameter values in this parameter override field
      *            value substitution. <br>
      *            For example, suppose the parameterized subject specification
      *            is <tt>UM.[ClientId].ADMIN</tt>, and the message has a
      *            field named <tt>ClientId</tt> with value <tt>JPM</tt>. If
      *            a key/value <tt>ClientId/BARZ</tt> is passed here then the
      *            send subject will be <tt>UM.BARZ.ADMIN</tt>. If the
      *            key/value is not passed then the send subject will be
      *            <tt>UM.JPM.ADMIN</tt>.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects()
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(boolean)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      */
     public final synchronized static void setSubjectParams(
             java.util.Hashtable params)
     {
         subjectParams_ = params;
     }
 
     /***
      * Determine if the message has exactly one subject specification.
      * 
      * @return Returns <tt>true</tt> if the message has exactly one subject
      *         specification. Returns <tt>false</tt> if the message has zero
      *         or more than one subject specification.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects()
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(boolean)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      */
     public final boolean hasOneSubjectSpec()
     {
         return (subjectSpec_ != null && subjectSpec_.length == 1);
     }
 
     /***
      * Set the subject specification. More then one subject specification can be
      * set with each specification separated by the SUBJECT_DELIMITER.
      * 
      * @param subjectSpec
      *            One or more subject specifications separated by
      *            SUBJECT_DELIMITER.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects()
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(boolean)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      * @see #SUBJECT_DELIMITER
      */
     protected final void setSubjectSpec(String[] subjectSpec,
             String[][] subjectSpecComponents)
     {
         subjectSpec_ = subjectSpec;
         subjectSpecComponents_ = subjectSpecComponents;
     }
 
     /***
      * Get the subject specifications.
      * 
      * @return Subject specifications.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects()
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(boolean)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      */
     public final String[] getSubjectSpec()
     {
         return subjectSpec_;
     }
 
     /***
      * Get the send subject for this message. Throws an exception if the message
      * does not have exactly one send subject.
      * 
      * @return Send subject for this message.
      * @see #setSendSubject(String)
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects()
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(boolean)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      */
     public final String getSendSubject() throws MsgValidationException
     {
         if (hasOneSubjectSpec() || isSendSubjectFixed())
             return buildSubject(null, false, 0);
         else if (subjectSpec_ != null && subjectSpec_.length > 0)
             throw new MsgValidationException(
                     "Message has multiple send subjects");
         else
             throw new MsgValidationException("Message has no send subject");
     }
 
     /***
      * Get the send subject for this message. Throws an exception if the message
      * does not have exactly one send subject.
      * 
      * @param params
      *            Map of parameter placeholder values. Key into the hashtable is
      *            the name of the placeholder and the value is the value of the
      *            placeholder. Parameter values in this parameter override field
      *            value substitution. <br>
      *            For example, suppose the parameterized subject specification
      *            is <tt>UM.[ClientId].ADMIN</tt>, and the message has a
      *            field named <tt>ClientId</tt> with value <tt>JPM</tt>. If
      *            a key/value <tt>ClientId/BARZ</tt> is passed here then the
      *            send subject will be <tt>UM.BARZ.ADMIN</tt>. If the
      *            key/value is not passed then the send subject will be
      *            <tt>UM.JPM.ADMIN</tt>.
      * @return Send subject for this message.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubjects()
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(boolean)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      */
     public final String getSendSubject(java.util.Hashtable params)
             throws MsgValidationException
     {
         if (hasOneSubjectSpec() || isSendSubjectFixed())
             return buildSubject(params, false, 0);
         else if (subjectSpec_ != null && subjectSpec_.length > 0)
             throw new MsgValidationException(
                     "Message has multiple send subjects");
         else
             throw new MsgValidationException("Message has no send subject");
     }
 
     /***
      * Get the send subjects for this message. Throws an exception if the
      * message does not have any send subjects.
      * 
      * @return Send subject for this message.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(boolean)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      */
     public final String[] getSendSubjects() throws MsgValidationException
     {
         String[] sendSubjects = getSubjects(null, false);
         if (sendSubjects.length != 0)
             return sendSubjects;
 
         throw new MsgValidationException("Message has no send subjects");
     }
 
     /***
      * Get the send subjects for this message. Throws an exception if the
      * message does not have any send subject.
      * 
      * @param params
      *            Map of parameter placeholder values. Key into the hashtable is
      *            the name of the placeholder and the value is the value of the
      *            placeholder. Parameter values in this parameter override field
      *            value substitution. <br>
      *            For example, suppose the parameterized subject specification
      *            is <tt>UM.[ClientId].ADMIN</tt>, and the message has a
      *            field named <tt>ClientId</tt> with value <tt>JPM</tt>. If
      *            a key/value <tt>ClientId/BARZ</tt> is passed here then the
      *            send subject will be <tt>UM.BARZ.ADMIN</tt>. If the
      *            key/value is not passed then the send subject will be
      *            <tt>UM.JPM.ADMIN</tt>.
      * @return Send subjects for this message.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects()
      * @see #getListenSubject(boolean)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      */
     public final String[] getSendSubjects(java.util.Hashtable params)
             throws MsgValidationException
     {
         String[] sendSubjects = getSubjects(params, false);
         if (sendSubjects.length != 0)
             return sendSubjects;
 
         throw new MsgValidationException("Message has no send subjects");
     }
 
     /***
      * Get the listen subject for this message. Throws an exception if the
      * message does not have exactly one listen subject.
      * 
      * @param wildcard
      *            If <tt>true</tt> all parameterized components in the subject
      *            specification are converted into wildcard '*'.
      * @return Listen subjects for this message.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects()
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      */
     public final String getListenSubject(boolean wildcard)
             throws MsgValidationException
     {
         if (hasOneSubjectSpec() || isSendSubjectFixed())
             return buildSubject(null, wildcard, 0);
         else if (subjectSpec_.length > 0)
             throw new MsgValidationException(
                     "Message has multiple listen subjects");
         else
             throw new MsgValidationException("Message has no listen subject");
     }
 
     /***
      * Get the listen subject for this message. Throws an exception if the
      * message does not have exactly one listen subject.
      * 
      * @param params
      *            Map of parameter placeholder values. Key into the hashtable is
      *            the name of the placeholder and the value is the value of the
      *            placeholder. Values in this parameter override field value
      *            substitution. <br>
      *            For example, suppose the parameterized subject specification
      *            is <tt>UM.[ClientId].ADMIN</tt>, and the message has a
      *            field named <tt>ClientId</tt> with value <tt>JPM</tt>. If
      *            a key/value <tt>ClientId/BARZ</tt> is passed here then the
      *            listen subject will be <tt>UM.BARZ.ADMIN</tt>. If the
      *            key/value is not passed then the listen subject will be
      *            <tt>UM.JPM.ADMIN</tt>.
      * @param wildcard
      *            If <tt>true</tt> all parameterized components in the subject
      *            specification are converted into wildcard '*'.
      * @return Listen subjects for this message.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects()
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(boolean)
      * @see #getListenSubjects(boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      */
     public final String getListenSubject(java.util.Hashtable params,
             boolean wildcard) throws MsgValidationException
     {
         if (hasOneSubjectSpec())
             return buildSubject(params, wildcard, 0);
         else if (subjectSpec_.length > 0)
             throw new MsgValidationException(
                     "Message has multiple listen subjects");
         else
             throw new MsgValidationException("Message has no listen subject");
     }
 
     /***
      * Get the listen subjects for this message. Throws an exception if the
      * message does not have any listen subject.
      * 
      * @param wildcard
      *            If <tt>true</tt> all parameterized components in the subject
      *            specification are converted into wildcard '*'.
      * @return Listen subjects for this message.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects()
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(boolean)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(java.util.Hashtable, boolean)
      */
     public final String[] getListenSubjects(boolean wildcard)
             throws MsgValidationException
     {
         String[] listenSubjects = getSubjects(null, wildcard);
         if (listenSubjects.length != 0)
             return listenSubjects;
 
         throw new MsgValidationException("Message has no listen subjects");
     }
 
     /***
      * Get the listen subjects for this message. Throws an exception if the
      * message does not have exactly any listen subject.
      * 
      * @param params
      *            Map of parameter placeholder values. Key into the hashtable is
      *            the name of the placeholder and the value is the value of the
      *            placeholder. Values in this parameter override field value
      *            substitution. <br>
      *            For example, suppose the parameterized subject specification
      *            is <tt>UM.[ClientId].ADMIN</tt>, and the message has a
      *            field named <tt>ClientId</tt> with value <tt>JPM</tt>. If
      *            a key/value <tt>ClientId/BARZ</tt> is passed here then the
      *            listen subject will be <tt>UM.BARZ.ADMIN</tt>. If the
      *            key/value is not passed then the listen subject will be
      *            <tt>UM.JPM.ADMIN</tt>.
      * @param wildcard
      *            If <tt>true</tt> all parameterized components in the subject
      *            specification are converted into wildcard '*'.
      * @return Listen subjects for this message.
      * @see #setSendSubject(String)
      * @see #getSendSubject()
      * @see #getSendSubject(java.util.Hashtable)
      * @see #getSendSubjects()
      * @see #getSendSubjects(java.util.Hashtable)
      * @see #getListenSubject(boolean)
      * @see #getListenSubject(java.util.Hashtable, boolean)
      * @see #getListenSubjects(boolean)
      */
     public final String[] getListenSubjects(java.util.Hashtable params,
             boolean wildcard) throws MsgValidationException
     {
         String[] listenSubjects = getSubjects(params, wildcard);
         if (listenSubjects.length != 0)
             return listenSubjects;
 
         throw new MsgValidationException("Message has no listen subjects");
     }
 
     /***
      * Build subjects for this message.
      * 
      * @param params
      * @param wildcard
      *            Flag to indicate if parameterized subject components should be
      *            converted to wildcard '*'. If <tt>true</tt> then all the
      *            parameterized subject components are converted to wildcard.
      * @return Subjects for this message. Returns <tt>zero length</tt> array
      *         if the message does not have any subject specification.
      */
     protected final String[] getSubjects(java.util.Hashtable params,
             boolean wildcard) throws MsgValidationException
     {
         if (subjectSpec_ == null || subjectSpec_.length == 0)
             return NOSUBJECT_ARRAY;
 
         String[] sendSubjects = new String[subjectSpec_.length];
         for (int specIndex = subjectSpec_.length - 1; specIndex >= 0; --specIndex)
             sendSubjects[specIndex] = buildSubject(params, wildcard, specIndex);
 
         return sendSubjects;
     }
 
     /***
      * Build the subject from the subject specification.
      * 
      * @param params
      *            Map of parameter placeholder values.
      * @param wildcard
      *            Flag to indicate if parameterized subject components should be
      *            converted to wildcard '*'. If <tt>true</tt> then all the
      *            parameterized subject components are converted to wildcard.
      * @param specIndex
      *            Subject specification index.
      * @return Send subject.
      */
     private final String buildSubject(java.util.Hashtable params,
             boolean wildcard, int specIndex) throws MsgValidationException
     {
         // If wildcard is false - i.e. this request is not for a send subject
         // since send
         // subjects cannot have wildacards - and the fixed send subject has
         // been set then
         // return the fixed send subject
         if (!wildcard && fixedSendSubject_ != null)
             return fixedSendSubject_;
 
         if (specIndex < 0 || specIndex > subjectSpec_.length)
             throw new MsgValidationException(
                     "Subject specification index out of bounds: " + specIndex);
 
         StringBuffer wrkSpace = new StringBuffer();
         StringBuffer expression = new StringBuffer();
         String subject = subjectSpec_[specIndex];
         for (int componentIndex = subjectSpecComponents_[specIndex].length - 1; componentIndex >= 0; --componentIndex)
         {
             String component = subjectSpecComponents_[specIndex][componentIndex];
 
             // The subject component can be one of two types. The first type is
             // a direct name, and the second type is an indirect name.
 
             // A direct name is simply a key that is used to look up an entry
             // in the
             // maps or in the message itself. For example, a direct name
             // component
             // might be [ClientId].
 
             // An indirect name consists of two parts - the second part is an
             // identifier
             // that is used to look to look up an entry in the maps or in the
             // message itself.
             // If an entry is found, then the value of that entry is used to do
             // another lookup.
             // The value of the second lookup is used to fill the subject
             // component. For
             // example, an indirect name component might be
             // [FGG:RoutingDestination]. For this
             // indirect name component, the key RoutingDestination will be used
             // to look up the
             // value. Suppose there is a field named RoutingDestination in the
             // message with
             // the value 'FGNY'. In that case, the value 'FGNY' will be used to
             // do another
             // lookup. Suppose the value of the key 'FGNY' in the map is 'FG1'
             // - that will be
             // value of the subject component [FGG:RoutingDestination].
             String replacement = null;
             int indirectLookup = component
                     .indexOf(INDIRECT_COMPONENT_DELIMITER);
             if (indirectLookup < 0)
             {
                 // Direct name
                 replacement = getReplacement(params, wildcard, component);
             }
             else
             {
                 // Indirect name - extract lookup name
                 String subComponent = component.substring(indirectLookup + 1);
 
                 // First lookup
                 replacement = getReplacement(params, wildcard, subComponent);
 
                 // Second lookup
                 replacement = getReplacement(params, wildcard, replacement);
             }
 
             // Zap out previous expression and build new one
             expression.setLength(0);
             expression.append(SUBJECT_PARAM_START).append(component).append(
                     SUBJECT_PARAM_END);
 
             subject = substitute(subject, expression.toString(), replacement,
                     wrkSpace);
         }
         return subject;
     }
 
     /***
      * Create the replacement string for a subject name component.
      * 
      * @param params
      *            Map of parameter placeholder values.
      * @param wildcard
      *            Flag to indicate if parameterized subject components should be
      *            converted to wildcard '*'. If <tt>true</tt> then all the
      *            parameterized subject components are converted to wildcard.
      * @param component
      *            Subject name component.
      */
     private final String getReplacement(java.util.Hashtable params,
             boolean wildcard, String component) throws MsgValidationException
     {
         if (wildcard)
         {
             return SUBJECT_WILDCARD;
         }
         else if (params != null && params.containsKey(component))
         {
             return (String) params.get(component);
         }
         else if (subjectParams_ != null
                 && subjectParams_.containsKey(component))
         {
             return (String) subjectParams_.get(component);
         }
         else if (fieldExists(component))
         {
             try
             {
                 RFld fld = getField(component);
                 if (fld.isValSet())
                     return fld.getValueAsString();
 
                 throw new MsgValidationException("Field not set: " + component);
             }
             catch (FieldValidationException ex)
             {
                 throw new MsgValidationException(ex);
             }
         }
         else
             throw new MsgValidationException(
                     "Unknown component in subject specification: " + component);
     }
 
     /***
      * Substitute all occurances of a match string by a replacement string in a
      * source string.
      * 
      * @param source
      *            Source string.
      * @param match
      *            Match string.
      * @param replacement
      *            Replacement string.
      * @param wrkSpace
      *            Work space - simply to reduce object creation per invocation.
      * @return Source string with all occurances of the match string replaced by
      *         the replacement string.
      */
     private static String substitute(String source, String match,
             String replacement, StringBuffer wrkSpace)
     {
         // Wipe out work buffer
         wrkSpace.setLength(0);
 
         int subjectLen = source.length();
         int matchLen = match.length();
         for (int beginIndex = 0; beginIndex < subjectLen;)
         {
             int matchStartIndex = source.indexOf(match, beginIndex);
             if (matchStartIndex >= 0)
             {
                 wrkSpace.append(source.substring(beginIndex, matchStartIndex))
                         .append(replacement);
                 beginIndex = matchStartIndex + matchLen;
             }
             else
             {
                 wrkSpace.append(source.substring(beginIndex));
                 break;
             }
         }
 
         return wrkSpace.toString();
     }
 
     /***
      * Get message specification version.
      * 
      * @return Message specification version number. If version is not defined,
      *         returns <tt>null</tt>.
      */
     public final String getMsgVersion()
     {
         return version_;
     }
 
     /***
      * Set message specification version number.
      * 
      * @param version
      *            Message specification version number.
      */
     protected final void setMsgVersion(String version)
     {
         version_ = version;
     }
 
     /***
      * Get the value of a field. A reference to the data is returned so be
      * careful about modifying the data through the reference. For fields nested
      * within RFldTibrvMsg (TibrvMsg) fields the name can be a dot notation
      * field name.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFld
      * @see RFldTibrvMsg#getValueAsObject(String, String)
      */
     public final Object getFieldValueAsObject(String fldName)
             throws FieldValidationException
     {
         // If a non-nested field exists with the specified name, simply return
         // it.
         // Otherwise, attempt to find a nested field with the specified name.
         if (fieldExists(fldName))
             return getField(fldName).getValueAsObject();
 
         return getNestedFieldValueAsObject(fldName);
     }
 
     /***
      * Get the value of a field. A reference to the data is returned so be
      * careful about modifying the data through the reference.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFld
      */
     protected final Object getNestedFieldValueAsObject(String fldName)
             throws FieldValidationException
     {
         int beginIndex = fldName.indexOf(NESTED_FIELDNAME_DELIMITER);
 
         // Get the top-level container field
         String containerFldName = null;
         if (beginIndex >= 0)
             containerFldName = fldName.substring(0, beginIndex);
 
         if (containerFldName == null)
             throw new FieldValidationException("Field not found: " + fldName);
 
         RFld containerFld = getField(containerFldName);
         if (!(containerFld instanceof RFldTibrvMsg))
             throw new FieldValidationException("Invalid field type: " + fldName);
 
         RFldTibrvMsg msgFld = (RFldTibrvMsg) containerFld;
         return msgFld.getValueAsObject(fldName.substring(beginIndex + 1),
                 NESTED_FIELDNAME_DELIMITER);
     }
 
     /***
      * Get field value as string.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      */
     public final String getFieldValueAsString(String fldName)
             throws FieldValidationException
     {
         Object fldVal = getFieldValueAsObject(fldName);
         return (fldVal != null) ? fldVal.toString() : null;
     }
 
     /***
      * Get the value of a <tt>TibrvMsg</tt> field. A reference to the data is
      * returned so be careful about modifying the data through the reference.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldTibrvMsg
      */
     public final Object getTibrvMsg(String fldName)
             throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldTibrvMsg) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a Opaque field. A reference to the data is returned so
      * be careful about modifying the data through the reference.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldOpaque
      */
     public final byte[] getOpaque(String fldName)
             throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldOpaque) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a datetime field. A reference to the data is returned so
      * be careful about modifying the data through the reference.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldDatetime
      */
     public final java.util.Date getDate(String fldName)
             throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldDatetime) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a boolean field.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldBool
      */
     public final boolean getBoolean(String fldName)
             throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldBool) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a opaque field. A reference to the data is returned so
      * be careful about modifying the data through the reference.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldOpaque
      */
     public final byte[] getBytes(String fldName)
             throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldOpaque) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a float field.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldF32
      */
     public final float getFloat(String fldName) throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldF32) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a double field.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldF64
      */
     public final double getDouble(String fldName)
             throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldF64) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a byte field.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldI8
      */
     public final byte getByte(String fldName) throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldI8) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a short field.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldI16
      */
     public final short getShort(String fldName) throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldI16) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a integer field.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldI32
      */
     public final int getInt(String fldName) throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldI32) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a long field.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldI64
      */
     public final long getLong(String fldName) throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldI64) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a bean field.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldBean
      */
     public final Object getBean(String fldName) throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldBean) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a string field.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldString
      */
     public final String getString(String fldName)
             throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldString) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a memo field.
      * 
      * @param fldName
      *            Field name.
      * @return Field value.
      * @see RFldMemo
      */
     public final String getMemo(String fldName) throws FieldValidationException
     {
         try
         {
             RFld fld = getField(fldName);
             return ((RFldMemo) fld).getValue();
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Add a TibrvMsg field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldTibrvMsg
      */
     public final void addMsg(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldTibrvMsg(fldName, fieldId, fldDesc));
     }
 
     /***
      * Add an Opaque field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldOpaque
      */
     public final void addOpaque(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldOpaque(fldName, fieldId, fldDesc));
     }
 
     /***
      * GAdd a datetime field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldDatetime
      */
     public final void addDate(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldDatetime(fldName, fieldId, fldDesc));
     }
 
     /***
      * Add a boolean field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldBool
      */
     public final void addBoolean(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldBool(fldName, fieldId, fldDesc));
     }
 
     /***
      * Add a float field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldF32
      */
     public final void addFloat(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldF32(fldName, fieldId, fldDesc));
     }
 
     /***
      * Add a double field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldF64
      */
     public final void addDouble(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldF64(fldName, fieldId, fldDesc));
     }
 
     /***
      * Add a short field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldI16
      */
     public final void addShort(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldI16(fldName, fieldId, fldDesc));
     }
 
     /***
      * Add an integer field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldI32
      */
     public final void addInt(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldI32(fldName, fieldId, fldDesc));
     }
 
     /***
      * Get the value of a long field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldI64
      */
     public final void addLong(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldI64(fldName, fieldId, fldDesc));
     }
 
     /***
      * Add a string field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldString
      */
     public final void addString(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldString(fldName, fieldId, fldDesc));
     }
 
     /***
      * Add a memo field.
      * 
      * @param fldName
      *            Field name.
      * @param fieldId
      *            Field Id. <tt>0</tt> means the field has no id.
      * @param fldDesc
      *            Field description. Can be <tt>null</tt>.
      * @see RFldMemo
      */
     public final void addMemo(String fldName, int fieldId, String fldDesc)
             throws FieldValidationException
     {
         if (fieldId < 0)
             throw new FieldValidationException(
                     "Field Id must be greater or equal to 0");
 
         addField(new RFldMemo(fldName, fieldId, fldDesc));
     }
 
     /***
      * Set the value of a TibrvMsg field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldTibrvMsg
      */
     public final void setTibrvMsg(String fldName, Object val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             fld.set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Set the value of a Opaque field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldOpaque
      */
     public final void setOpaque(String fldName, byte[] val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldOpaque) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a datetime field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            value.
      * @see RFldDatetime
      */
     public final void setDate(String fldName, java.util.Date val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
         try
         {
             RFld fld = getField(fldName);
             ((RFldDatetime) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a datetime field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            value.
      * @see RFldDatetime
      */
     public final void setDate(String fldName, long val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldDatetime) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a boolean field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldBool
      */
     public final void setBoolean(String fldName, boolean val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldBool) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Get the value of a opaque field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldOpaque
      */
     public final void setBytes(String fldName, byte[] val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldOpaque) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Set the value of a float field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldF32
      */
     public final void setFloat(String fldName, float val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldF32) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Set the value of a double field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldF64
      */
     public final void setDouble(String fldName, double val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldF64) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Set the value of a byte field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldI8
      */
     public final void setByte(String fldName, byte val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldI8) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Set the value of a short field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldI16
      */
     public final void setShort(String fldName, short val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldI16) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Set the value of a integer field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldI32
      */
     public final void setInt(String fldName, int val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldI32) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Set the value of a long field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldI64
      */
     public final void setLong(String fldName, long val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldI64) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Set the value of a field from an object.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFld
      */
     public final void setFieldFromObject(String fldName, Object val)
             throws FieldValidationException
     {
         getField(fldName).set(val);
     }
 
     /***
      * Set the value of a bean field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldString
      */
     public final void setBean(String fldName, Object val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldBean) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Set the value of a string field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldString
      */
     public final void setString(String fldName, String val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldString) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Set the value of a memo field.
      * 
      * @param fldName
      *            Field name.
      * @param val
      *            Field value.
      * @see RFldMemo
      */
     public final void setMemo(String fldName, String val)
             throws FieldValidationException
     {
         if (isLocked())
             throw new FieldValidationException("Message is locked");
 
         try
         {
             RFld fld = getField(fldName);
             ((RFldMemo) fld).set(val);
         }
         catch (java.lang.ClassCastException ex)
         {
             throw new FieldValidationException("Field type mismatch: "
                     + fldName);
         }
     }
 
     /***
      * Check if a named field exists in this message. Either there is an exact
      * match for the field name, or, case-insentitive names are enabled and
      * there is a case-insensitive field name match.
      * 
      * @param fldName
      *            Field name.
      * @return <tt>true</tt> if the named field exists. Otherwise returns
      *         <tt>false</tt>.
      */
     public final boolean fieldExists(String fldName)
     {
         // Either there is an exact match for the field name, or,
         // case-insentitive
         // names are enabled and there is a case-insensitive match.
         return (flds_.containsKey(fldName) || (noCaseFlds_ != null && noCaseFlds_
                 .containsKey(fldName.toUpperCase())));
     }
 
     /***
      * Determine if the value of a named message field has been set.
      * 
      * @param fldName
      *            Field name.
      * @return <tt>true</tt> if the value of a named message field has been
      *         set. Otherwise, returns <tt>false</tt>.
      */
     public final boolean isValSet(String fldName)
             throws FieldValidationException
     {
         return getField(fldName).isValSet();
     }
 
     /***
      * Determine if the value of a named message has any constraints.
      * 
      * @param fldName
      *            Field name.
      * @return <tt>true</tt> if the value of a named message field has been
      *         constrained. Otherwise, returns <tt>false</tt>.
      */
     public final boolean isConstrained(String fldName)
             throws FieldValidationException
     {
         return getField(fldName).isConstrained();
     }
 
     /***
      * Determine if a named message field is locked.
      * 
      * @param fldName
      *            Field name.
      * @return <tt>true</tt> if the named field is locked. Otherwise, returns
      *         <tt>false</tt>.
      */
     public final boolean isLocked(String fldName)
             throws FieldValidationException
     {
         return getField(fldName).isLocked();
     }
 
     /***
      * Get the number of fields in this message.
      * 
      * @return Number of fields in this message.
      */
     public final int getFieldCount()
     {
         return flds_.size();
     }
 
     /***
      * Get all names of all fields in the message.
      * 
      * @return Iterator over all field names in the message.
      */
     public final java.util.Iterator getFieldNames()
     {
         return flds_.keySet().iterator();
     }
 
     /***
      * Check if this is an empty message. An empty message is one that has not
      * been defined externally via XML. These empty messages have their fields
      * added dynamically by the application at run-time.
      * 
      * @return <tt>true</tt> if this is an empty message. Otherwise returns
      *         <tt>false</tt>.
      * @see #setEmptyMsg(boolean)
      */
     public final boolean isEmptyMsg()
     {
         return emptyMsg_;
     }
 
     /***
      * Set the <tt>empty</tt> attribute of this message.
      * 
      * @param emptyMsg
      *            <tt>true</tt> if this is an empty message. Otherwise
      *            <tt>false</tt>.
      * @see #isEmptyMsg()
      */
     public final void setEmptyMsg(boolean emptyMsg)
     {
         emptyMsg_ = emptyMsg;
     }
 
     /***
      * Set the case-insensitive field name option.
      * 
      * @param val
      *            If <tt>true</tt> then the framework allows field names to be
      *            accessed in a case-insensitive manner. Otherwise, field names
      *            are case sensitive.
      * @see#getField(String)
      * @see#fieldExists(String)
      */
     public static final void supportNoCaseFldNames(boolean val)
     {
         noCaseFldNames_ = val;
     }
 
     /***
      * Register custom XML field tag.
      * 
      * @param newTag
      *            New XML field tag.
      */
     public static final void setXmlTag(String newTag)
             throws FieldValidationException
     {
         if (newTag == null)
             throw new FieldValidationException("NULL tag");
 
         XML_TAG = newTag;
     }
 
     /***
      * Register custom XML attribute names.
      * 
      * @param name
      *            New name of the message name attribute.
      */
     public static final void setXmlAttrNames(String name)
             throws FieldValidationException
     {
         if (name == null)
             throw new FieldValidationException("NULL attribute name");
 
         XML_ATTR_NAME = name;
     }
 
     /***
      * Get 'pretty print' string representation of message contents.
      * 
      * @return Pretty print String representation of message contents.
      */
     public String toPrettyPrintString()
     {
         int indentLevel = 0;
         String str = toString();
         int len = str.length();
         StringBuffer sb = new StringBuffer(len + (len / 80) + 20);
         for (int i = 0; i < len;)
         {
             if (str.charAt(i) == NESTED_FIELD_START)
             {
                 sb.append('\n');
                 indent(sb, indentLevel);
 
                 sb.append(NESTED_FIELD_START);
 
                 ++indentLevel;
 
                 ++i;
             }
             else if (str.charAt(i) == NESTED_FIELD_END)
             {
                 sb.append('\n');
                 --indentLevel;
 
                 indent(sb, indentLevel);
                 sb.append(NESTED_FIELD_END);
 
                 ++i;
             }
             else if (str.charAt(i) == EXPOSED_FIELD_DELIMITER)
             {
                 ++i;
             }
             else
             {
                 sb.append('\n');
                 indent(sb, indentLevel);
 
                 // Insert field name/contents
                 char c = str.charAt(i);
                 while (c != EXPOSED_FIELD_DELIMITER && c != NESTED_FIELD_START
                         && c != NESTED_FIELD_END)
                 {
                     sb.append(c);
 
                     ++i;
                     if (i >= len)
                         break;
 
                     c = str.charAt(i);
                 }
             }
         }
         return sb.toString();
     }
 
     /***
      * Insert indentation into a string buffer.
      * 
      * @param sb
      *            String buffer.
      * @param indentLevel
      *            Indentation level.
      */
     private final void indent(StringBuffer sb, int indentLevel)
     {
         // Indent - 4 spaces per indent level
         for (int j = 0; j < indentLevel; ++j)
             sb.append("    ");
     }
 
     /***
      * Get string representation of message contents.
      * 
      * @return String representation of message contents.
      */
     public String toString()
     {
         StringBuffer sb = new StringBuffer(128);
         sb.append(NESTED_FIELD_START);
 
         boolean notFirst = false;
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             RFld fld = fldsArray[i];
             if (notFirst)
                 sb.append(EXPOSED_FIELD_DELIMITER);
             else
                 notFirst = true;
 
             if (fld.isValSet())
                 sb.append(fld.getName()).append(FIELD_EQUAL).append(
                         fld.getValueAsString());
             else
                 sb.append(fld.getName()).append(FIELD_EQUAL).append(NA_VALUE);
         }
         sb.append(NESTED_FIELD_END);
         return sb.toString();
     }
 
     /***
      * Check if another message is equal to this message. Equality is defined as
      * both messages having the same fields (name, type), and all fields having
      * the same, non-null, value.
      * 
      * @param anObject
      *            Another message.
      * @return <tt>true</tt> if another message is equal to this message.
      *         Otherwise, returns <tt>false</tt>.
      */
     public boolean equals(Object anObject)
     {
         // Sanity checks
         if (this == anObject)
             return true;
         else if (!(anObject instanceof RMsg))
             return false;
 
         // Compare number of fields - quick check to compare messages
         RMsg anotherMsg = (RMsg) anObject;
         if (getFieldCount() != anotherMsg.getFieldCount())
             return false;
 
         // Compare each field
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             try
             {
                 RFld fld = fldsArray[i];
                 String fldName = fld.getName();
                 if (!anotherMsg.fieldExists(fldName))
                     return false;
 
                 boolean fldValSet = fld.isValSet();
 
                 RFld anotherFld = anotherMsg.getField(fldName);
                 boolean anotherFldValSet = anotherFld.isValSet();
 
                 // Skip this field if it is set in neither message
                 if (!fldValSet && !anotherFldValSet)
                     continue;
                 // If this field is not set in ONE of the messages, or if the
                 // field values
                 // are not equal in the two messages, then the messages are not
                 // equal
                 else if ((fldValSet != anotherFldValSet)
                         || (!fld.equals(anotherFld)))
                     return false;
             }
             catch (FieldValidationException ex)
             {
                 return false;
             }
         }
         return true;
     }
 
     /***
      * Check if another message is equal to this message. Equality is defined in
      * the same way as for <tt>equals</tt> except for the following: only the
      * fields with the specified <tt>tag</tt> are checked for equality.
      * 
      * @param anObject
      *            Another message.
      * @param tag
      *            Tag to look for.
      * @param ignoreCase
      *            If <tt>true</tt> then tag search is case-insensitive.
      * @return <tt>true</tt> if another message is equal to this message.
      *         Otherwise, returns <tt>false</tt>.
      * @see #equals(Object)
      */
     public boolean equalsUsingTaggedFields(Object anObject, String tag,
             boolean ignoreCase)
     {
         // Sanity checks
         if (this == anObject)
             return true;
         else if (!(anObject instanceof RMsg))
             return false;
 
         RMsg anotherMsg = (RMsg) anObject;
 
         // Compare number of tagged fields - quick check to compare messages
         if (getTaggedFields(tag, ignoreCase).size() != anotherMsg
                 .getTaggedFields(tag, ignoreCase).size())
             return false;
 
         // Compare tagged fields
         for (java.util.Iterator iter = getTaggedFields(tag, ignoreCase)
                 .iterator(); iter.hasNext();)
         {
             try
             {
                 String fldName = (String) iter.next();
                 RFld fld = getField(fldName);
                 if (!anotherMsg.fieldExists(fldName))
                     return false;
 
                 boolean fldValSet = fld.isValSet();
 
                 RFld anotherFld = anotherMsg.getField(fldName);
                 boolean anotherFldValSet = anotherFld.isValSet();
 
                 // Skip this field if it is set in neither message
                 if (!fldValSet && !anotherFldValSet)
                     continue;
                 // If this field is not set in ONE of the messages, or if the
                 // field values
                 // are not equal in the two messages, then the messages are not
                 // equal
                 else if ((fldValSet != anotherFldValSet)
                         || (!fld.equals(anotherFld)))
                     return false;
             }
             catch (FieldValidationException ex)
             {
                 return false;
             }
         }
         return true;
     }
 
     /***
      * Check if another message is equal to this message. Equality is defined as
      * both messages having the same number of fields, and all fields having the
      * same, non-null, value. It returns(in sb) a formatted string of fields
      * that fail the test
      * 
      * @param anObject
      *            Another message.
      * @param sbResultText -
      *            StringBuffer object to print non-matching fields
      * @return <tt>true</tt> if another message is equal to this message.
      *         Otherwise, returns <tt>false</tt>.
      */
     public boolean equalsDebug(Object anObject, StringBuffer sbResultText)
     {
         boolean l_stat = true;
         StringBuffer sb = new StringBuffer();
 
         // Sanity checks
         if (this == anObject)
             return true;
         else if (anObject == null || !(anObject instanceof RMsg))
             return false;
 
         // Compare number of fields
         RMsg anotherMsg = (RMsg) anObject;
         if (getFieldCount() != anotherMsg.getFieldCount())
             return false;
 
         // Compare each field
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             RFld fld = fldsArray[i];
             String fldName = fld.getName();
             try
             {
                 RFld anotherFld = anotherMsg.getField(fldName);
                 if (!fld.isValSet() && !anotherFld.isValSet())
                     continue;
                 else if (!(fld.equals(anotherFld)))
                 {
                     sb.append(" Field -> " + fldName + " this = ["
                             + fld.getValueAsString() + "] another = ["
                             + anotherFld.getValueAsString() + "] \n");
                     l_stat = false;
 
                 }
             }
             catch (FieldValidationException ex)
             {
                 sb.append(" Field -> " + fldName + " contains null \n");
                 l_stat = false;
             }
         }
         if (!l_stat)
         {
             sbResultText.setLength(0);
             try
             {
                 sbResultText.append("\n********" + getString("MessageName")
                         + "**************************\n");
             }
             catch (Exception e)
             {
                 sbResultText.append("\n********" + this
                         + "*******************************\n");
             }
             sbResultText.append(sb.toString());
             sbResultText
                     .append("**************************************************************\n");
             return false;
         }
         return true;
     }
 
     /***
      * Check if another message is equal to this message based on a subset of
      * the fields in the messages. This is the debug version that prints the
      * fields that do not match
      * 
      * @param anObject
      *            Another message.
      * @param ignoreFields
      *            Field to ignore when checking for equality.
      */
     public boolean equalIgnoreValuesDebug(Object anObject,
             java.util.Vector ignoreFields)
     {
         // Sanity checks
         if (this == anObject)
             return true;
         else if (anObject == null || !(anObject instanceof RMsg))
             return false;
 
         // Compare number of fields
         RMsg anotherMsg = (RMsg) anObject;
         if (getFieldCount() != anotherMsg.getFieldCount())
             return false;
 
         boolean isEqual = true;
         StringBuffer sb = new StringBuffer();
         // Compare each field, ignoring the values of those in ignoreFields.
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             try
             {
                 RFld fld = fldsArray[i];
                 String fldName = fld.getName();
 
                 //if current iteration of field is not in the ignoreFields,
                 //compare values.
                 if (!ignoreFields.contains(fldName))
                 {
                     RFld anotherFld = anotherMsg.getField(fldName);
                     if (!fld.isValSet() && !anotherFld.isValSet())
                         continue;
 
                     if (!(fld.equals(anotherFld)))
                     {
                         sb.append(" FieldName -> " + fldName + " this = ["
                                 + fld.getValueAsString() + "] another = ["
                                 + anotherFld.getValueAsString() + "] \n");
                         isEqual = false;
                     }
                 }
             }
             catch (FieldValidationException ex)
             {
                 return false;
             }
         } //end while
         if (sb.length() != 0)
         {
             try
             {
                 System.out.println("********" + getString("MessageName")
                         + "*********");
             }
             catch (FieldValidationException e)
             {
                 System.out
                         .println("\n******** Could not obtain field MessageName ****");
             }
             System.out.println(sb.toString());
             System.out.println("\n**************************");
         }
 
         return isEqual;
     }
 
     /***
      * Check if another message is equal to this message based on a subset of
      * the fields in the messages.
      * 
      * @param anObject
      *            Another message.
      * @param ignoreFields
      *            Fields to ignore when checking for equality.
      */
     public boolean equalIgnoreValues(Object anObject,
             java.util.Vector ignoreFields)
     {
         // Sanity checks
         if (this == anObject)
             return true;
         else if (anObject == null || !(anObject instanceof RMsg))
             return false;
 
         // Compare number of fields
         RMsg anotherMsg = (RMsg) anObject;
         if (getFieldCount() != anotherMsg.getFieldCount())
             return false;
 
         // Compare each field, ignoring the values of those in ignoreFields.
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             try
             {
                 RFld fld = fldsArray[i];
                 String fldName = fld.getName();
 
                 // if current iteration of field is not in the ignoreFields,
                 // compare values.
                 if (!ignoreFields.contains(fldName))
                 {
                     RFld anotherFld = anotherMsg.getField(fldName);
                     if (!fld.isValSet() && !anotherFld.isValSet())
                         continue;
 
                     //System.out.println("Comparing field " + fldName);
                     if (!(fld.equals(anotherFld)))
                         return false;
                 }
             }
             catch (FieldValidationException ex)
             {
                 return false;
             }
         }
         return true;
     }
 
     /***
      * Similar to the comments for hashcode in <tt>java.util.Hashtable</tt>
      * Returns the hash code value for the Message. The hash code of the message
      * is defined to be the sum of the hash code of each field value in the
      * message. It is important that all the message field classes also
      * implement equals and hashCode in a similar manner. The broad design of
      * this method is taken from the book
      * <tt>Effective Java (first edition) by Joshua Bloch</tt>
      * 
      * @return Hash code value for this message.
      */
     public int hashCode()
     {
         int result = 17;
         RFld[] fldsArray = getFieldsAsArray();
         for (int i = fldsArray.length - 1; i >= 0; --i)
         {
             RFld fld = fldsArray[i];
             int hashCode = 0;
             if (fld.isValSet())
                 hashCode = fld.hashCode();
             result = (37 * result) + hashCode;
         }
         return result;
     }
 
     /***
      * Version field.
      */
     protected String version_;
 
     /***
      * Message name.
      */
     protected String name_;
 
     /***
      * Message description.
      */
     protected String desc_;
 
     /***
      * Flag to make message immutable.
      */
     protected boolean locked_;
 
     /***
      * Fixed send subject. If the send subject is fixed by the application then
      * the subject specification is ignored in comnputing the send subject.
      */
     protected String fixedSendSubject_;
 
     /***
      * The send/listen subject specification for this message. The subject
      * specification can either be static - e.g. UM.ADMIN, or parameterized -
      * e.g. UM.[ClientId].ADMIN. If the subject is parameterized then the
      * parameters must be the names of String fields in the message. Multiple
      * send/listen subjects may be specified by provided a comma separated list
      * of send subjects - e.g. UM.ADMIN,UM.[ClientId].ADMIN.
      */
     protected String[] subjectSpec_;
 
     /***
      * For each entry in subjectSpec_ this array contains the names of the
      * parameterized components. For example, if subjectSpec_[0] is
      * FB.FE.[ClientId].[UserId].ORD then subjectSpecComponents_[0] will contain
      * twl elements - ClientId and UserId.
      */
     protected String[][] subjectSpecComponents_;
 
     /***
      * Message fields.
      */
     protected java.util.Map flds_;
 
     protected transient RFld[] fldsArray_;
 
     /***
      * Message fields - key into the <tt>Map</tt> is uppercase field names.
      */
     protected java.util.Map noCaseFlds_;
 
     /***
      * Field to indicate if this message has no fields.
      */
     protected boolean emptyMsg_;
 
     /***
      * Required field groups.
      * 
      * @see RRequiredGrp
      */
     protected java.util.List reqGrps_;
 
     /***
      * Subject specification parameters.
      */
     protected static transient java.util.Hashtable subjectParams_;
 
     /***
      * Delimiter for indirect subject components.
      */
     protected static final transient char INDIRECT_COMPONENT_DELIMITER = ':';
 
     /***
      * Delimiter for multiple subject specifications.
      */
     protected static final transient String NESTED_FIELDNAME_DELIMITER = ".";
 
     /***
      * Delimiter for multiple subject specifications.
      */
     protected static final transient String SUBJECT_DELIMITER = ",";
 
     /***
      * Delimiter for start of parameterized subject name component.
      */
     protected static final transient char SUBJECT_PARAM_START = '[';
 
     /***
      * Delimiter for end of parameterized subject name component.
      */
     protected static final transient char SUBJECT_PARAM_END = ']';
 
     /***
      * Wildcard for parameterized subject name component - we use a
      */
     protected static final transient String SUBJECT_WILDCARD = "*";
 
     /***
      * Delimiter for exposed fields within string representation.
      */
     protected static final transient char EXPOSED_FIELD_DELIMITER = '&';
 
     /***
      * Delimiter for fields within hashtable entry string representation.
      */
     protected static final transient char HASHTABLE_ENTRY_DELIMITER = ',';
 
     /***
      * Start delimiter for nested fields within string representation.
      */
     protected static final transient char NESTED_FIELD_START = '{';
 
     /***
      * End delimiter for nested fields within string representation.
      */
     protected static final transient char NESTED_FIELD_END = '}';
 
     /***
      * End delimiter for nested fields within string representation.
      */
     protected static final transient char FIELD_EQUAL = '=';
 
     /***
      * Not Applicable (not set) value.
      */
     protected static final transient String NA_VALUE = "N/A";
 
     /***
      * XML tag for this element type.
      */
     static transient String XML_TAG = "msg";
 
     /***
      * Attribute 'name' of JDOM element.
      */
     protected static transient String XML_ATTR_NAME = "name";
 
     /***
      * Flag to indicate whether access to fields is done in a case-insensitive
      * manner. Default is <tt>true</tt>.
      */
     protected static transient boolean noCaseFldNames_ = true;
 
     private static transient final String[] NOSUBJECT_ARRAY = new String[0];
 }