content: /*
  * Conditions Of Use
  *
  * This software was developed by employees of the National Institute of
  * Standards and Technology (NIST), an agency of the Federal Government.
  * Pursuant to title 15 Untied States Code Section 105, works of NIST
  * employees are not subject to copyright protection in the United States
  * and are considered to be in the public domain.  As a result, a formal
  * license is not needed to use the software.
  *
  * This software is provided by NIST as a service and is expressly
  * provided "AS IS."  NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
  * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
  * AND DATA ACCURACY.  NIST does not warrant or make any representations
  * regarding the use of the software or the results thereof, including but
  * not limited to the correctness, accuracy, reliability or usefulness of
  * the software.
  *
  * Permission to use this software is contingent upon your acceptance
  * of the terms of this agreement
  *
  * .
  *
  */
  /*******************************************************************************
   * Product of NIST/ITL Advanced Networking Technologies Division (ANTD)        *
   ******************************************************************************/
  package gov2.nist.javax2.sip.message;
  
  import gov2.nist.core.*;
  
  import java.lang.reflect.*;
  
  /**
   * This is the root object from which all other objects in this package
   * are derived. This class is never directly instantiated (and hence it
   * is abstract).
   *
   * @version 1.2 $Revision: 1.7 $ $Date: 2009/07/17 18:57:54 $
   * @since 1.1
   *
   * @author M. Ranganathan   <br/>
   *
   *
   */
  public abstract class MessageObject extends GenericObject {
      public abstract String encode();
  
      public void dbgPrint() {
          super.dbgPrint();
      }
  
      /**
       * An introspection based string formatting method. We need this because
       * in this package (although it is an exact duplicate of the one in
       * the superclass) because it needs to access the protected members
       * of the other objects in this class.
       */
      public String debugDump() {
          stringRepresentation = "";
          Class<?> myclass = getClass();
          sprint(myclass.getName());
          sprint("{");
          Field[] fields = myclass.getDeclaredFields();
          for (int i = 0; i < fields.length; i++) {
              Field f = fields[i];
              // Only print protected and public members.
              int modifier = f.getModifiers();
              if (modifier == Modifier.PRIVATE)
                  continue;
              Class<?> fieldType = f.getType();
              String fieldName = f.getName();
              if (fieldName.compareTo("stringRepresentation") == 0) {
                  // avoid nasty recursions...
                  continue;
              }
              if (fieldName.compareTo("indentation") == 0) {
                  // formatting stuff - not relevant here.
                  continue;
              }
              sprint(fieldName + ":");
              try {
                  // Primitive fields are printed with type: value
                  if (fieldType.isPrimitive()) {
                      String fname = fieldType.toString();
                      sprint(fname + ":");
                      if (fname.compareTo("int") == 0) {
                          int intfield = f.getInt(this);
                          sprint(intfield);
                      } else if (fname.compareTo("short") == 0) {
                          short shortField = f.getShort(this);
                          sprint(shortField);
                      } else if (fname.compareTo("char") == 0) {
                          char charField = f.getChar(this);
                          sprint(charField);
                      } else if (fname.compareTo("long") == 0) {
                          long longField = f.getLong(this);
                          sprint(longField);
                      } else if (fname.compareTo("boolean") == 0) {
                          boolean booleanField = f.getBoolean(this);
                          sprint(booleanField);
                      } else if (fname.compareTo("double") == 0) {
                          double doubleField = f.getDouble(this);
                          sprint(doubleField);
                      } else if (fname.compareTo("float") == 0) {
                          float floatField = f.getFloat(this);
                          sprint(floatField);
                      }
                  } else if (
                      GenericObject.class.isAssignableFrom(
                          fieldType)) {
                      if (f.get(this) != null) {
                          sprint(
                              ((GenericObject) f.get(this)).debugDump(
                                  this.indentation + 1));
                      } else {
                          sprint("<null>");
                      }
  
                  } else if (GenericObjectList.class.isAssignableFrom(
                          fieldType)) {
                      if (f.get(this) != null) {
                          sprint(
                              ((GenericObjectList) f.get(this)).debugDump(
                                  indentation + 1));
                      } else {
                          sprint("<null>");
                      }
  
                  } else {
                      // Dont do recursion on things that are not
                      // of our header type...
                      if (f.get(this) != null) {
                          sprint(f.get(this).getClass().getName() + ":");
                      } else {
                          sprint(fieldType.getName() + ":");
                      }
  
                      sprint("{");
                      if (f.get(this) != null) {
                          sprint(f.get(this).toString());
                      } else {
                          sprint("<null>");
                      }
                      sprint("}");
                  }
              } catch (IllegalAccessException ex1) {
                  continue; // we are accessing a private field...
              }
          }
          sprint("}");
          return stringRepresentation;
      }
  
  
      protected MessageObject() {
          super();
      }
  
      /**
       * Formatter with a given starting indentation (for nested structs).
       */
      public String dbgPrint(int indent) {
          int save = indentation;
          indentation = indent;
          String retval = this.toString();
          indentation = save;
          return retval;
      }
  }
  