public static String abbrevFor(Class clz) 
{
      if (clz == Boolean.TYPE) {
         return "Z";
      }
      else if (clz == Byte.TYPE) {
         return "B";
      }
      else if (clz == Character.TYPE) {
         return "C";
      }
      else if (clz == Double.TYPE) {
         return "D";
      }
      else if (clz == Float.TYPE) {
         return "F";
      }
      else if (clz == Integer.TYPE) {
         return "I";
      }
      else if (clz == Long.TYPE) {
         return "J";
      }
      else if (clz == Short.TYPE) {
         return "S";
      }
      else if (clz == Void.TYPE) {
         return "V";
      }
      else if (clz == String.class) {
         return "G"; // strinG
      }
      else if (RmiIdlUtil.isRMIIDLRemoteInterface(clz)) {
         return "R" + clz.getName(); // Remote interface
      }
      else if (clz == org.omg.CORBA.Object.class) {
         return "M"; // oMg (CORBA Object)
      }
      else if (org.omg.CORBA.Object.class.isAssignableFrom(clz)) {
         return "N" + clz.getName(); // IDL iNterface
      }
      else if (IDLEntity.class.isAssignableFrom(clz)) {
         return "L" + clz.getName(); // vaLuetype
      }
      else if (clz == Serializable.class) {
         return "E"; // sErializablE
      }
      else if (RmiIdlUtil.isAbstractInterface(clz)) {
         return "A"; // Abstract interface
      }
      else if (Serializable.class.isAssignableFrom(clz)) {
         return "L" + clz.getName(); // vaLuetype
      }
      else if (Externalizable.class.isAssignableFrom(clz)) {
         return "X"; // eXternalizable
      }
      else if (clz == Object.class) {
         return "O"; // Object
      }
      else {
         return "L" + clz.getName(); // vaLuetype
      }
}

Returns the abbreviated name of the marshaller for given Class.

Abbreviated names of marshallers for basic types follow the usual Java convention:


type abbrev name
boolean "Z"
byte "B"
char "C"
double "D"
float "F"
int "I"
long "J"
short "S"
void "V"

The abbreviated names of marshallers for object types are:


java.lang.String "G" (strinG)
RMI remote interface "R" + interfaceName
RMI abstract interface "A"
serializable "E" (sErializablE)
valuetype "L" + className
externalizable "X" (eXternalizable)
org.omg.CORBA.Object "M" (oMg)
IDL interface "N" + interfaceName
java.lang.Object "O"

As an example: the abbreviated name of a marshaller for a valuetype class named Foo is the string "LFoo".

 public static CDRStreamReader readerFor(Class clz) 
{
      if (clz == Boolean.TYPE) {
         return BooleanReader.instance;
      }
      else if (clz == Byte.TYPE) {
         return ByteReader.instance;
      }
      else if (clz == Character.TYPE) {
         return CharReader.instance;
      }
      else if (clz == Double.TYPE) {
         return DoubleReader.instance;
      }
      else if (clz == Float.TYPE) {
         return FloatReader.instance;
      }
      else if (clz == Integer.TYPE) {
         return IntReader.instance;
      }
      else if (clz == Long.TYPE) {
         return LongReader.instance;
      }
      else if (clz == Short.TYPE) {
         return ShortReader.instance;
      }
      else if (clz == Void.TYPE) {
         return null;
      }
      else if (clz == String.class) {
         return StringReader.instance;
      }
      else if (RmiIdlUtil.isRMIIDLRemoteInterface(clz)) {
         return new RemoteReader(clz);
      }
      else if (clz == org.omg.CORBA.Object.class) {
         return CorbaObjectReader.instance;
      }
      else if (org.omg.CORBA.Object.class.isAssignableFrom(clz)) {
         return new IdlInterfaceReader(clz);
      }
      else if (IDLEntity.class.isAssignableFrom(clz)) {
         return new ValuetypeReader(clz);
      }
      else if (clz == Serializable.class) {
         return SerializableReader.instance;
      }
      else if (RmiIdlUtil.isAbstractInterface(clz)) {
         return AbstractInterfaceReader.instance;
      }
      else if (Serializable.class.isAssignableFrom(clz)) {
         return new ValuetypeReader(clz);
      }
      else if (Externalizable.class.isAssignableFrom(clz)) {
         return ExternalizableReader.instance;
      }
      else if (clz == Object.class) {
         return ObjectReader.instance;
      }
      else {
         return new ValuetypeReader(clz);
      }
}

Returns the CDRStreamReader for a given Class.

 public static CDRStreamReader readerFor(String s,
    ClassLoader cl) 
{
      switch (s.charAt(0)) {
      case 'A":
         return AbstractInterfaceReader.instance;
      case 'B":
         return ByteReader.instance;
      case 'C":
         return CharReader.instance;
      case 'D":
         return DoubleReader.instance;
      case 'E":
         return SerializableReader.instance;
      case 'F":
         return FloatReader.instance;
      case 'G":
         return StringReader.instance;
      case 'I":
         return IntReader.instance;
      case 'J":
         return LongReader.instance;
      case 'L":
         try {
            // Use Class.forName() (rather than cl.loadClass()), because 
            // Class.forName() loads Java array types (which are valuetypes).
            return new ValuetypeReader(Class.forName(s.substring(1), 
                                                     true, 
                                                     cl));
         }
         catch (ClassNotFoundException e) {
            throw new RuntimeException("Error loading class " 
                                       + s.substring(1) + ": " + e);
         }
      case 'M":
         return CorbaObjectReader.instance;
      case 'N":
         try {
            return new IdlInterfaceReader(cl.loadClass(s.substring(1)));
         }
         catch (ClassNotFoundException e) {
            throw new RuntimeException("Error loading class " 
                                       + s.substring(1) + ": " + e);
         }
      case 'O":
         return ObjectReader.instance;
      case 'R":
         try {
            return new RemoteReader(cl.loadClass(s.substring(1)));
         }
         catch (ClassNotFoundException e) {
            throw new RuntimeException("Error loading class " 
                                       + s.substring(1) + ": " + e);
         }
      case 'S":
         return ShortReader.instance;
      case 'V":
         return null;
      case 'X": 
         return ExternalizableReader.instance;
      case 'Z":
         return BooleanReader.instance;
      default:
         return null;
      }
}

Returns a CDRStreamReader given an abbreviated name and a ClassLoader for valuetype classes.

 public static CDRStreamWriter writerFor(Class clz) 
{
      if (clz == Boolean.TYPE) {
         return BooleanWriter.instance;
      }
      else if (clz == Byte.TYPE) {
         return ByteWriter.instance;
      }
      else if (clz == Character.TYPE) {
         return CharWriter.instance;
      }
      else if (clz == Double.TYPE) {
         return DoubleWriter.instance;
      }
      else if (clz == Float.TYPE) {
         return FloatWriter.instance;
      }
      else if (clz == Integer.TYPE) {
         return IntWriter.instance;
      }
      else if (clz == Long.TYPE) {
         return LongWriter.instance;
      }
      else if (clz == Short.TYPE) {
         return ShortWriter.instance;
      }
      else if (clz == String.class) {
         return StringWriter.instance;
      }
      else if (clz == Void.TYPE) {
         return null;
      }
      else if (RmiIdlUtil.isRMIIDLRemoteInterface(clz)) {
         return RemoteWriter.instance;
      }
      else if (clz == org.omg.CORBA.Object.class) {
         return CorbaObjectWriter.instance;
      }
      else if (org.omg.CORBA.Object.class.isAssignableFrom(clz)) {
         return new IdlInterfaceWriter(clz);
      }
      else if (IDLEntity.class.isAssignableFrom(clz)) {
         return new ValuetypeWriter(clz);
      }
      else if (clz == Serializable.class) {
         return SerializableWriter.instance;
      } 
      else if (RmiIdlUtil.isAbstractInterface(clz)) {
         return AbstractInterfaceWriter.instance;
      }
      else if (Serializable.class.isAssignableFrom(clz)) {
         return new ValuetypeWriter(clz);
      }
      else if (Externalizable.class.isAssignableFrom(clz)) {
         return ExternalizableWriter.instance;
      }
      else if (clz == Object.class) {
         return ObjectWriter.instance;
      }
      else {
         return new ValuetypeWriter(clz);
      }
}

Returns the CDRStreamWriter for a given Class.

 public static CDRStreamWriter writerFor(String s,
    ClassLoader cl) 
{
      switch (s.charAt(0)) {
      case 'A":
         return AbstractInterfaceWriter.instance;
      case 'B":
         return ByteWriter.instance;
      case 'C":
         return CharWriter.instance;
      case 'D":
         return DoubleWriter.instance;
      case 'E":
         return SerializableWriter.instance;
      case 'F":
         return FloatWriter.instance;
      case 'G":
         return StringWriter.instance;
      case 'I":
         return IntWriter.instance;
      case 'J":
         return LongWriter.instance;
      case 'L":  
         try {
            // Use Class.forName() (rather than cl.loadClass()), because 
            // Class.forName() loads Java array types (which are valuetypes).
            return new ValuetypeWriter(Class.forName(s.substring(1), 
                                                     true, 
                                                     cl));
         }
         catch (ClassNotFoundException e) {
            throw new RuntimeException("Error loading class " 
                                       + s.substring(1) + ": " + e);
         }
      case 'M":
         return CorbaObjectWriter.instance;
      case 'N":
         try {
            return new IdlInterfaceWriter(cl.loadClass(s.substring(1)));
         }
         catch (ClassNotFoundException e) {
            throw new RuntimeException("Error loading class " 
                                       + s.substring(1) + ": " + e);
         }
      case 'O":
         return ObjectWriter.instance;
      case 'R":
         return RemoteWriter.instance;
      case 'S":
         return ShortWriter.instance;
      case 'V":
         return null;
      case 'X": 
         return ExternalizableWriter.instance;
      case 'Z":
         return BooleanWriter.instance;
      default:
         return null;
      }
}

Returns a CDRStreamWriter given an abbreviated name and a ClassLoader for valuetype classes.