FileDocCategorySizeDatePackage
ObjectStreamClass_1_3_1.javaAPI DocJava SE 5 API38894Fri Aug 26 14:54:28 BST 2005com.sun.corba.se.impl.orbutil

ObjectStreamClass_1_3_1

public class ObjectStreamClass_1_3_1 extends Object implements Serializable
A ObjectStreamClass_1_3_1 describes a class that can be serialized to a stream or a class that was serialized to a stream. It contains the name and the serialVersionUID of the class.
The ObjectStreamClass_1_3_1 for a specific class loaded in this Java VM can be found using the lookup method.
author
Roger Riggs
(#)ObjectStreamClass_1_3_1.java
1.17 99/06/07
since
JDK1.1

Fields Summary
public static final long
kDefaultUID
private static Object[]
noArgsList
private static Class[]
noTypesList
private static Hashtable
translatedFields
private static ObjectStreamClassEntry[]
descriptorFor
private String
name
private ObjectStreamClass_1_3_1
superclass
private boolean
serializable
private boolean
externalizable
private ObjectStreamField[]
fields
private Class
ofClass
boolean
forProxyClass
private long
suid
private String
suidStr
private long
actualSuid
private String
actualSuidStr
int
primBytes
int
objFields
private Object
lock
private boolean
hasWriteObjectMethod
private boolean
hasExternalizableBlockData
Method
writeObjectMethod
Method
readObjectMethod
private Method
writeReplaceObjectMethod
private Method
readResolveObjectMethod
private ObjectStreamClass_1_3_1
localClassDesc
private static Class
classSerializable
private static Class
classExternalizable
private static final long
serialVersionUID
use serialVersionUID from JDK 1.1. for interoperability
public static final ObjectStreamField[]
NO_FIELDS
Set serialPersistentFields of a Serializable class to this value to denote that the class has no Serializable fields.
private static Comparator
compareClassByName
private static Comparator
compareMemberByName
Constructors Summary
private ObjectStreamClass_1_3_1(Class cl, ObjectStreamClass_1_3_1 superdesc, boolean serial, boolean extern)

	ofClass = cl;		/* created from this class */

        if (Proxy.isProxyClass(cl)) {
            forProxyClass = true;
        }

	name = cl.getName();
	superclass = superdesc;
	serializable = serial;
        if (!forProxyClass) {
            // proxy classes are never externalizable
            externalizable = extern;
        }

	/*
	 * Enter this class in the table of known descriptors.
	 * Otherwise, when the fields are read it may recurse
	 * trying to find the descriptor for itself.
	 */
	insertDescriptorFor(this);

        /*
         * The remainder of initialization occurs in init(), which is called
         * after the lock on the global class descriptor table has been
         * released.
         */
    
ObjectStreamClass_1_3_1(String n, long s)

	name = n;
	suid = s;
	superclass = null;
    
Methods Summary
static booleancompareClassNames(java.lang.String streamName, java.lang.String localName, char pkgSeparator)

	/* compare the class names, stripping off package names. */
	int streamNameIndex = streamName.lastIndexOf(pkgSeparator);
	if (streamNameIndex < 0)
	    streamNameIndex = 0;

	int localNameIndex = localName.lastIndexOf(pkgSeparator);
	if (localNameIndex < 0)
	    localNameIndex = 0;

	return streamName.regionMatches(false, streamNameIndex,
					localName, localNameIndex,
					streamName.length() - streamNameIndex);
    
private voidcomputeFieldInfo()

	primBytes = 0;
	objFields = 0;

	for (int i = 0; i < fields.length; i++ ) {
	    switch (fields[i].getTypeCode()) {
	    case 'B":
	    case 'Z":
	    	primBytes += 1;
	    	break;
	    case 'C":
	    case 'S":
	    	primBytes += 2;
	    	break;

	    case 'I":
	    case 'F":
	    	primBytes += 4;
	    	break;
	    case 'J":
	    case 'D" :
	    	primBytes += 8;
	    	break;

	    case 'L":
	    case '[":
	    	objFields += 1;
	    	break;
	    }
	}
    
private static longcomputeStructuralUID(com.sun.corba.se.impl.orbutil.ObjectStreamClass_1_3_1 osc, java.lang.Class cl)

	ByteArrayOutputStream devnull = new ByteArrayOutputStream(512);
		
	long h = 0;
	try {

	    if ((!java.io.Serializable.class.isAssignableFrom(cl)) ||
		(cl.isInterface())){
		return 0;
	    }
			
	    if (java.io.Externalizable.class.isAssignableFrom(cl)) {
		return 1;
	    }

	    MessageDigest md = MessageDigest.getInstance("SHA");
	    DigestOutputStream mdo = new DigestOutputStream(devnull, md);
	    DataOutputStream data = new DataOutputStream(mdo);

	    // Get SUID of parent
	    Class parent = cl.getSuperclass();
	    if ((parent != null))  
	    // SerialBug 1; acc. to spec the one for 
	    // java.lang.object
	    // should be computed and put
	    //     && (parent != java.lang.Object.class)) 
	    {
				//data.writeLong(computeSerialVersionUID(null,parent));
		data.writeLong(computeStructuralUID(lookup(parent), parent));
	    }

	    if (osc.hasWriteObject())
		data.writeInt(2);
	    else
		data.writeInt(1);

	    /* Sort the field names to get a deterministic order */
            // Field[] field = ObjectStreamClass_1_3_1.getDeclaredFields(cl);

            ObjectStreamField[] fields = osc.getFields();

            // Must make sure that the Field array we allocate
            // below is exactly the right size.  Bug fix for
            // 4397133.
            int numNonNullFields = 0;
            for (int i = 0; i < fields.length; i++)
                if (fields[i].getField() != null)
                    numNonNullFields++;

            Field [] field = new java.lang.reflect.Field[numNonNullFields];
            for (int i = 0, fieldNum = 0; i < fields.length; i++) {
	        if (fields[i].getField() != null) {
                    field[fieldNum++] = fields[i].getField();
	        }
            }

	    if (field.length > 1)
                Arrays.sort(field, compareMemberByName);

	    for (int i = 0; i < field.length; i++) {
		Field f = field[i];
				
				/* Include in the hash all fields except those that are
				 * transient 
				 */
		int m = f.getModifiers();
	        //Serial 6
		//if (Modifier.isTransient(m) || Modifier.isStatic(m))
	        // spec reference 00-01-06.pdf, 1.3.5.6, states non-static
	        // non-transient, public fields are mapped to Java IDL.
	        //
                // Here's the quote from the first paragraph:
	        // Java non-static non-transient public fields are mapped to 
	        // OMG IDL public data members, and other Java fields are 
	        // not mapped.

		// if (Modifier.isTransient(m) || Modifier.isStatic(m))
		//     continue;
				
		data.writeUTF(f.getName());
		data.writeUTF(getSignature(f.getType()));
	    }
			
	    /* Compute the hash value for this class.
	     * Use only the first 64 bits of the hash.
	     */
	    data.flush();
	    byte hasharray[] = md.digest();
	    // int minimum = Math.min(8, hasharray.length);
	    // SerialBug 3: SHA computation is wrong; for loop reversed
	    //for (int i = minimum; i > 0; i--) 
	    for (int i = 0; i < Math.min(8, hasharray.length); i++) {
		h += (long)(hasharray[i] & 255) << (i * 8);
	    }
	} catch (IOException ignore) {
	    /* can't happen, but be deterministic anyway. */
	    h = -1;
	} catch (NoSuchAlgorithmException complain) {
	    throw new SecurityException(complain.getMessage());
	}
	return h;
    
private static com.sun.corba.se.impl.orbutil.ObjectStreamClass_1_3_1findDescriptorFor(java.lang.Class cl)


    /*
     * findDescriptorFor a Class.  This looks in the cache for a
     * mapping from Class -> ObjectStreamClass mappings.  The hashCode
     * of the Class is used for the lookup since the Class is the key.
     * The entries are extended from java.lang.ref.SoftReference so the
     * gc will be able to free them if needed.
     */
         

	int hash = cl.hashCode();
	int index = (hash & 0x7FFFFFFF) % descriptorFor.length;
	ObjectStreamClassEntry e;
	ObjectStreamClassEntry prev;

	/* Free any initial entries whose refs have been cleared */
	while ((e = descriptorFor[index]) != null && e.get() == null) {
	    descriptorFor[index] = e.next;
	}

	/* Traverse the chain looking for a descriptor with ofClass == cl.
	 * unlink entries that are unresolved.
	 */
	prev = e;
	while (e != null ) {
	    ObjectStreamClass_1_3_1 desc = (ObjectStreamClass_1_3_1)(e.get());
	    if (desc == null) {
		// This entry has been cleared,  unlink it
		prev.next = e.next;
	    } else {
		if (desc.ofClass == cl)
		    return desc;
		prev = e;
	    }
	    e = e.next;
	}
	return null;
    
public final java.lang.ClassforClass()
Return the class in the local VM that this version is mapped to. Null is returned if there is no corresponding local class.

	return ofClass;
    
public static final longgetActualSerialVersionUID(java.lang.Class clazz)
Return the actual (computed) serialVersionUID for this class.

	ObjectStreamClass_1_3_1 theosc = ObjectStreamClass_1_3_1.lookup( clazz );
	if( theosc != null )
	{
		return theosc.getActualSerialVersionUID( );
	}
	return 0;
    
public final longgetActualSerialVersionUID()
Return the actual (computed) serialVersionUID for this class.

	return actualSuid;
    
public final java.lang.StringgetActualSerialVersionUIDStr()
Return the actual (computed) serialVersionUID for this class.

	if (actualSuidStr == null)
	    actualSuidStr = Long.toHexString(actualSuid).toUpperCase();
	return actualSuidStr;
    
private static java.lang.reflect.Field[]getDeclaredFields(java.lang.Class clz)

        return (Field[]) AccessController.doPrivileged(new PrivilegedAction() {
            public Object run() {
                return clz.getDeclaredFields();
            }
        });
    
public final ObjectStreamFieldgetField(java.lang.String name)
Get the field of this class by name.

return
The ObjectStreamField object of the named field or null if there is no such named field.

    	/* Binary search of fields by name.
	 */
    	for (int i = fields.length-1; i >= 0; i--) {
    	    if (name.equals(fields[i].getName())) {
    	    	return fields[i];
	    }
    	}
	return null;
    
public ObjectStreamField[]getFields()
Return an array of the fields of this serializable class.

return
an array containing an element for each persistent field of this class. Returns an array of length zero if there are no fields.
since
JDK1.2

    	// Return a copy so the caller can't change the fields.
	if (fields.length > 0) {
	    ObjectStreamField[] dup = new ObjectStreamField[fields.length];
	    System.arraycopy(fields, 0, dup, 0, fields.length);
	    return dup;
	} else {
	    return fields;
	}
    
final ObjectStreamField[]getFieldsNoCopy()

	return fields;
    
public final java.lang.StringgetName()
The name of the class described by this descriptor.

	return name;
    
public static final longgetSerialVersionUID(java.lang.Class clazz)
Return the serialVersionUID for this class. The serialVersionUID defines a set of classes all with the same name that have evolved from a common root class and agree to be serialized and deserialized using a common format.

	ObjectStreamClass_1_3_1 theosc = ObjectStreamClass_1_3_1.lookup( clazz );
        if( theosc != null )
	{
		return theosc.getSerialVersionUID( );
	}
	return 0;
    
public final longgetSerialVersionUID()
Return the serialVersionUID for this class. The serialVersionUID defines a set of classes all with the same name that have evolved from a common root class and agree to be serialized and deserialized using a common format.

	return suid;
    
public final java.lang.StringgetSerialVersionUIDStr()
Return the serialVersionUID string for this class. The serialVersionUID defines a set of classes all with the same name that have evolved from a common root class and agree to be serialized and deserialized using a common format.

	if (suidStr == null)
	    suidStr = Long.toHexString(suid).toUpperCase();
	return suidStr;
    
static java.lang.StringgetSignature(java.lang.Class clazz)
Compute the JVM signature for the class.

	String type = null;
	if (clazz.isArray()) {
	    Class cl = clazz;
	    int dimensions = 0;
	    while (cl.isArray()) {
		dimensions++;
		cl = cl.getComponentType();
	    }
	    StringBuffer sb = new StringBuffer();
	    for (int i = 0; i < dimensions; i++) {
		sb.append("[");
	    }
	    sb.append(getSignature(cl));
	    type = sb.toString();
	} else if (clazz.isPrimitive()) {
	    if (clazz == Integer.TYPE) {
		type = "I";
	    } else if (clazz == Byte.TYPE) {
		type = "B";
	    } else if (clazz == Long.TYPE) {
		type = "J";
	    } else if (clazz == Float.TYPE) {
		type = "F";
	    } else if (clazz == Double.TYPE) {
		type = "D";
	    } else if (clazz == Short.TYPE) {
		type = "S";
	    } else if (clazz == Character.TYPE) {
		type = "C";
	    } else if (clazz == Boolean.TYPE) {
		type = "Z";
	    } else if (clazz == Void.TYPE) {
		type = "V";
	    }
	} else {
	    type = "L" + clazz.getName().replace('.", '/") + ";";
	}
	return type;
    
static java.lang.StringgetSignature(java.lang.reflect.Method meth)

	StringBuffer sb = new StringBuffer();

	sb.append("(");

	Class[] params = meth.getParameterTypes(); // avoid clone
	for (int j = 0; j < params.length; j++) {
	    sb.append(getSignature(params[j]));
	}
	sb.append(")");
	sb.append(getSignature(meth.getReturnType()));
	return sb.toString();
    
static java.lang.StringgetSignature(java.lang.reflect.Constructor cons)

	StringBuffer sb = new StringBuffer();

	sb.append("(");

	Class[] params = cons.getParameterTypes(); // avoid clone
	for (int j = 0; j < params.length; j++) {
	    sb.append(getSignature(params[j]));
	}
	sb.append(")V");
	return sb.toString();
    
final com.sun.corba.se.impl.orbutil.ObjectStreamClass_1_3_1getSuperclass()

	return superclass;
    
booleanhasExternalizableBlockDataMode()

	return hasExternalizableBlockData;
    
public booleanhasField(org.omg.CORBA.ValueMember field)


	for (int i = 0; i < fields.length; i++){
	    try{
		if (fields[i].getName().equals(field.name)) {

		    if (fields[i].getSignature().equals(ValueUtility.getSignature(field)))
			return true;
		}
	    }
	    catch(Throwable t){}
	}
	return false;
    
final booleanhasWriteObject()

	return hasWriteObjectMethod;
    
private voidinit()

      synchronized (lock) {

	final Class cl = ofClass;
 
	if (fields != null) // already initialized
                return;


	if (!serializable ||
	    externalizable ||
	    forProxyClass ||
	    name.equals("java.lang.String")) {
	    fields = NO_FIELDS;
	} else if (serializable) {

            /* Ask for permission to override field access checks.
             */
            AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
		/* Fill in the list of persistent fields.
		 * If it is declared, use the declared serialPersistentFields.
		 * Otherwise, extract the fields from the class itself.
		 */
		try {
                    Field pf = cl.getDeclaredField("serialPersistentFields");
	            // serial bug 7; the serialPersistentFields were not
	            // being read and stored as Accessible bit was not set
		    pf.setAccessible(true);
	            // serial bug 7; need to find if the field is of type
	            // java.io.ObjectStreamField
                    java.io.ObjectStreamField[] f =
                           (java.io.ObjectStreamField[])pf.get(cl);
		    int mods = pf.getModifiers();
		    if ((Modifier.isPrivate(mods)) &&
			(Modifier.isStatic(mods)) &&
			(Modifier.isFinal(mods)))
	            {
			fields = (ObjectStreamField[])translateFields((Object[])pf.get(cl));
		    }
		} catch (NoSuchFieldException e) {
		    fields = null;
		} catch (IllegalAccessException e) {
		    fields = null;
		} catch (IllegalArgumentException e) {
		    fields = null;
                } catch (ClassCastException e) {
                    /* Thrown if a field serialPersistentField exists
                     * but it is not of type ObjectStreamField.
                     */
                    fields = null;
                }


		if (fields == null) {
		    /* Get all of the declared fields for this
		     * Class. setAccessible on all fields so they
		     * can be accessed later.  Create a temporary
		     * ObjectStreamField array to hold each
		     * non-static, non-transient field. Then copy the
		     * temporary array into an array of the correct
		     * size once the number of fields is known.
		     */
                    Field[] actualfields = cl.getDeclaredFields();

		    int numFields = 0;
		    ObjectStreamField[] tempFields =
			new ObjectStreamField[actualfields.length];
		    for (int i = 0; i < actualfields.length; i++) {
			int modifiers = actualfields[i].getModifiers();
			if (!Modifier.isStatic(modifiers) &&
			    !Modifier.isTransient(modifiers)) {
			    tempFields[numFields++] =
				new ObjectStreamField(actualfields[i]);
			}
		    }
		    fields = new ObjectStreamField[numFields];
		    System.arraycopy(tempFields, 0, fields, 0, numFields);

		} else {
		    // For each declared persistent field, look for an actual
		    // reflected Field. If there is one, make sure it's the correct
		    // type and cache it in the ObjectStreamClass_1_3_1 for that field.
		    for (int j = fields.length-1; j >= 0; j--) {
			try {
                            Field reflField = cl.getDeclaredField(fields[j].getName());
			    if (fields[j].getType() == reflField.getType()) {
				// reflField.setAccessible(true);
				fields[j].setField(reflField);
			    }
			} catch (NoSuchFieldException e) {
			    // Nothing to do
			}
		    }
		}
	        return null;
	    }
	    });

	    if (fields.length > 1)
		Arrays.sort(fields);

	    /* Set up field data for use while writing using the API api. */
	    computeFieldInfo();
	}

        /* Get the serialVersionUID from the class.
         * It uses the access override mechanism so make sure
         * the field objects is only used here.
         *
         * NonSerializable classes have a serialVerisonUID of 0L.
         */
         if (isNonSerializable()) {
             suid = 0L;
         } else {
             // Lookup special Serializable members using reflection.
             AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                if (forProxyClass) {
                    // proxy classes always have serialVersionUID of 0L
                    suid = 0L;
                } else {
	            try {
                        final Field f = cl.getDeclaredField("serialVersionUID");
	                int mods = f.getModifiers();
		    // SerialBug 5:  static final SUID should be read
	                if (Modifier.isStatic(mods) && 
                            Modifier.isFinal(mods) ) {
                            f.setAccessible(true);
		            suid = f.getLong(cl);
	                    // get rid of native code
	                    // suid = getSerialVersionUIDField(cl);
	            // SerialBug 2: should be computed after writeObject
	            // actualSuid = computeStructuralUID(cl);
	                } else {
		            suid = ObjectStreamClass.getSerialVersionUID(cl);
	                    // SerialBug 2: should be computed after writeObject
	                    // actualSuid = computeStructuralUID(cl);
	                }
	            } catch (NoSuchFieldException ex) {
	                suid = ObjectStreamClass.getSerialVersionUID(cl);
	                // SerialBug 2: should be computed after writeObject
	                // actualSuid = computeStructuralUID(cl);
                    } catch (IllegalAccessException ex) {
                        suid = ObjectStreamClass.getSerialVersionUID(cl);
                    }
	        }


	        try {
                    writeReplaceObjectMethod = cl.getDeclaredMethod("writeReplace", noTypesList);
	            if (Modifier.isStatic(writeReplaceObjectMethod.getModifiers())) {
	                writeReplaceObjectMethod = null;
                    } else {
                        writeReplaceObjectMethod.setAccessible(true);
                    } 

	        } catch (NoSuchMethodException e2) {

	        }
	
	        try {
                    readResolveObjectMethod = cl.getDeclaredMethod("readResolve", noTypesList);
	            if (Modifier.isStatic(readResolveObjectMethod.getModifiers())) {
	               readResolveObjectMethod = null;
                    } else {
                       readResolveObjectMethod.setAccessible(true);
                    }

	        } catch (NoSuchMethodException e2) {

	        }
	
                /* Cache lookup of writeObject and readObject for
                 * Serializable classes. (Do not lookup for
                 * Externalizable)
                 */

                if (serializable && !forProxyClass) {

	            /* Look for the writeObject method
	             * Set the accessible flag on it here. ObjectOutputStream
	             * will call it as necessary.
	             */
	            try {
	              Class[] args = {java.io.ObjectOutputStream.class};
                      writeObjectMethod = cl.getDeclaredMethod("writeObject", args);
	              hasWriteObjectMethod = true;
	              int mods = writeObjectMethod.getModifiers();

	              // Method must be private and non-static
	              if (!Modifier.isPrivate(mods) ||
		        Modifier.isStatic(mods)) {
		        writeObjectMethod = null;
		        hasWriteObjectMethod = false;
	              }

	            } catch (NoSuchMethodException e) {
	            }

	            /* Look for the readObject method
	             * set the access override and save the reference for
	             * ObjectInputStream so it can all the method directly.
	             */
	            try {
	              Class[] args = {java.io.ObjectInputStream.class};
                      readObjectMethod = cl.getDeclaredMethod("readObject", args);
	              int mods = readObjectMethod.getModifiers();

	              // Method must be private and non-static
	              if (!Modifier.isPrivate(mods) ||
		        Modifier.isStatic(mods)) {
		        readObjectMethod = null;
	              }
	            } catch (NoSuchMethodException e) {
                    }
                    // Compute the structural UID.  This must be done after the
                    // calculation for writeObject.  Fixed 4/20/2000, eea1
	            // SerialBug 2: to have correct value in RepId
	        }
	        return null;
	    }
	  });
	}

        actualSuid = computeStructuralUID(this, cl);
      }

    
private static voidinsertDescriptorFor(com.sun.corba.se.impl.orbutil.ObjectStreamClass_1_3_1 desc)

	// Make sure not already present
	if (findDescriptorFor(desc.ofClass) != null) {
	    return;
	}

	int hash = desc.ofClass.hashCode();
	int index = (hash & 0x7FFFFFFF) % descriptorFor.length;
	ObjectStreamClassEntry e = new ObjectStreamClassEntry(desc);
	e.next = descriptorFor[index];
       	descriptorFor[index] = e;
    
final booleanisCustomMarshaled()

	return (hasWriteObject() || isExternalizable());
    
booleanisExternalizable()

	return externalizable;
    
booleanisNonSerializable()

        return ! (externalizable || serializable);
    
booleanisSerializable()

	return serializable;
    
final com.sun.corba.se.impl.orbutil.ObjectStreamClass_1_3_1localClassDescriptor()

	return localClassDesc;
    
static final com.sun.corba.se.impl.orbutil.ObjectStreamClass_1_3_1lookup(java.lang.Class cl)
Find the descriptor for a class that can be serialized. Null is returned if the specified class does not implement java.io.Serializable or java.io.Externalizable.


                                 
        
    
	ObjectStreamClass_1_3_1 desc = lookupInternal(cl);
	if (desc.isSerializable() || desc.isExternalizable())
	    return desc;
	return null;
    
static com.sun.corba.se.impl.orbutil.ObjectStreamClass_1_3_1lookupInternal(java.lang.Class cl)

	/* Synchronize on the hashtable so no two threads will do
	 * this at the same time.
	 */
	ObjectStreamClass_1_3_1 desc = null;
	synchronized (descriptorFor) {
	    /* Find the matching descriptor if it already known */
	    desc = findDescriptorFor(cl);
	    if (desc != null) {
		return desc;
	    }

                /* Check if it's serializable */
                boolean serializable = classSerializable.isAssignableFrom(cl);
                /* If the class is only Serializable,
                 * lookup the descriptor for the superclass.
                 */
                ObjectStreamClass_1_3_1 superdesc = null;
                if (serializable) {
                    Class superclass = cl.getSuperclass();
                    if (superclass != null)
                        superdesc = lookup(superclass);
                }

                /* Check if its' externalizable.
                 * If it's Externalizable, clear the serializable flag.
                 * Only one or the other may be set in the protocol.
                 */
                boolean externalizable = false;
                if (serializable) {
                    externalizable =
                        ((superdesc != null) && superdesc.isExternalizable()) ||
                        classExternalizable.isAssignableFrom(cl);
                    if (externalizable) {
                        serializable = false;
                    }
                }

	    /* Create a new version descriptor,
	     * it put itself in the known table.
	     */
	    desc = new ObjectStreamClass_1_3_1(cl, superdesc,
					 serializable, externalizable);
	}
	desc.init();
	return desc;
    
public java.lang.ObjectreadResolve(java.lang.Object value)

	if (readResolveObjectMethod != null) {
	    try {
		return readResolveObjectMethod.invoke(value,noArgsList);
	    }
	    catch(Throwable t) {
		throw new RuntimeException(t.getMessage());
	    }
	}
	else return value;
    
final voidsetSuperclass(com.sun.corba.se.impl.orbutil.ObjectStreamClass_1_3_1 s)

	superclass = s;
    
public final java.lang.StringtoString()
Return a string describing this ObjectStreamClass_1_3_1.

	StringBuffer sb = new StringBuffer();

	sb.append(name);
	sb.append(": static final long serialVersionUID = ");
	sb.append(Long.toString(suid));
	sb.append("L;");
	return sb.toString();
    
private static java.lang.Object[]translateFields(java.lang.Object[] objs)

        try{
            java.io.ObjectStreamField fields[] = (java.io.ObjectStreamField[])objs;
            Object translation[] = null;
                       
            if (translatedFields == null)
                translatedFields = new Hashtable();
                       
            translation = (Object[])translatedFields.get(fields);
                       
            if (translation != null)
                return translation;
            else {
                Class osfClass = com.sun.corba.se.impl.orbutil.ObjectStreamField.class;

                translation = (Object[])java.lang.reflect.Array.newInstance(osfClass, objs.length);
                Object arg[] = new Object[2];
                Class types[] = {String.class, Class.class};
                Constructor constructor = osfClass.getDeclaredConstructor(types);
                for (int i = fields.length -1; i >= 0; i--){
                    arg[0] = fields[i].getName();
                    arg[1] = fields[i].getType();
                       
                    translation[i] = constructor.newInstance(arg);
                }
                translatedFields.put(fields, translation);
                       
            }

            return (Object[])translation;
        }
        catch(Throwable t){
            throw new NoSuchFieldException();
        }
    
final booleantypeEquals(com.sun.corba.se.impl.orbutil.ObjectStreamClass_1_3_1 other)

	return (suid == other.suid) &&
	    compareClassNames(name, other.name, '.");
    
public java.io.SerializablewriteReplace(java.io.Serializable value)

	if (writeReplaceObjectMethod != null) {
	    try {
		return (Serializable) writeReplaceObjectMethod.invoke(value,noArgsList);
	    }
	    catch(Throwable t) {
		throw new RuntimeException(t.getMessage());
	    }
	}
	else return value;