This is the mail archive of the
java-patches@gcc.gnu.org
mailing list for the Java project.
FYI: Patch: java.io - code reformating
- From: Michael Koch <konqueror at gmx dot de>
- To: java-patches at gcc dot gnu dot org
- Date: Tue, 30 Dec 2003 16:56:03 +0100
- Subject: FYI: Patch: java.io - code reformating
Hi list,
I commited the attached patch to reformat some code in ObjectInputStream,
ObjectOutputStream and ObjectStreamClass. There are no functional code
changes. This patch makes these classes more merged with classpath.
Michael
Index: ChangeLog
===================================================================
RCS file: /cvs/gcc/gcc/libjava/ChangeLog,v
retrieving revision 1.2500
diff -u -b -B -r1.2500 ChangeLog
--- ChangeLog 30 Dec 2003 13:43:24 -0000 1.2500
+++ ChangeLog 30 Dec 2003 15:49:35 -0000
@@ -1,5 +1,12 @@
2003-12-30 Michael Koch <konqueror@gmx.de>
+ * java/io/ObjectInputStream.java,
+ java/io/ObjectOutputStream.java,
+ java/io/ObjectStreamClass.java:
+ Reformated, no functional code changes.
+
+2003-12-30 Michael Koch <konqueror@gmx.de>
+
* gnu/java/net/protocol/http/Connection.java
(outputStream): New field.
(bufferedOutputStream): New field.
Index: java/io/ObjectInputStream.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/ObjectInputStream.java,v
retrieving revision 1.23
diff -u -b -B -r1.23 ObjectInputStream.java
--- java/io/ObjectInputStream.java 23 Dec 2003 22:06:01 -0000 1.23
+++ java/io/ObjectInputStream.java 30 Dec 2003 15:49:35 -0000
@@ -73,7 +73,7 @@
*
* @see #readStreamHeader()
*/
- public ObjectInputStream (InputStream in)
+ public ObjectInputStream(InputStream in)
throws IOException, StreamCorruptedException
{
if (Configuration.DEBUG)
@@ -96,14 +96,14 @@
this.blockDataPosition = 0;
this.blockDataBytes = 0;
this.blockData = new byte[BUFFER_SIZE];
- this.blockDataInput = new DataInputStream (this);
- this.realInputStream = new DataInputStream (in);
+ this.blockDataInput = new DataInputStream(this);
+ this.realInputStream = new DataInputStream(in);
this.nextOID = baseWireHandle;
- this.objectLookupTable = new Hashtable ();
- this.validators = new Vector ();
+ this.objectLookupTable = new Hashtable();
+ this.validators = new Vector();
this.classLookupTable = new Hashtable();
- setBlockDataMode (true);
- readStreamHeader ();
+ setBlockDataMode(true);
+ readStreamHeader();
}
@@ -122,10 +122,10 @@
* @exception IOException Exception from underlying
* <code>InputStream</code>.
*/
- public final Object readObject () throws ClassNotFoundException, IOException
+ public final Object readObject() throws ClassNotFoundException, IOException
{
if (this.useSubclassMethod)
- return readObjectOverride ();
+ return readObjectOverride();
boolean was_deserializing;
@@ -133,12 +133,12 @@
was_deserializing = this.isDeserializing;
boolean is_consumed = false;
- boolean old_mode = setBlockDataMode (false);
+ boolean old_mode = setBlockDataMode(false);
this.isDeserializing = true;
- byte marker = this.realInputStream.readByte ();
- dumpElement ("MARKER: 0x" + Integer.toHexString(marker) + " ");
+ byte marker = this.realInputStream.readByte();
+ dumpElement("MARKER: 0x" + Integer.toHexString(marker) + " ");
try
{
@@ -155,43 +155,43 @@
case TC_BLOCKDATALONG:
{
if (marker == TC_BLOCKDATALONG)
- dumpElementln ("BLOCKDATALONG");
+ dumpElementln("BLOCKDATALONG");
else
- dumpElementln ("BLOCKDATA");
- readNextBlock (marker);
- throw new StreamCorruptedException ("Unexpected blockData");
+ dumpElementln("BLOCKDATA");
+ readNextBlock(marker);
+ throw new StreamCorruptedException("Unexpected blockData");
}
case TC_NULL:
{
- dumpElementln ("NULL");
+ dumpElementln("NULL");
ret_val = null;
break;
}
case TC_REFERENCE:
{
- dumpElement ("REFERENCE ");
- Integer oid = new Integer (this.realInputStream.readInt ());
- dumpElementln (Integer.toHexString(oid.intValue()));
+ dumpElement("REFERENCE ");
+ Integer oid = new Integer(this.realInputStream.readInt());
+ dumpElementln(Integer.toHexString(oid.intValue()));
ret_val = ((ObjectIdentityWrapper)
- this.objectLookupTable.get (oid)).object;
+ this.objectLookupTable.get(oid)).object;
break;
}
case TC_CLASS:
{
- dumpElementln ("CLASS");
- ObjectStreamClass osc = (ObjectStreamClass)readObject ();
- Class clazz = osc.forClass ();
- assignNewHandle (clazz);
+ dumpElementln("CLASS");
+ ObjectStreamClass osc = (ObjectStreamClass)readObject();
+ Class clazz = osc.forClass();
+ assignNewHandle(clazz);
ret_val = clazz;
break;
}
case TC_PROXYCLASSDESC:
{
- dumpElementln ("PROXYCLASS");
+ dumpElementln("PROXYCLASS");
int n_intf = this.realInputStream.readInt();
String[] intfs = new String[n_intf];
for (int i = 0; i < n_intf; i++)
@@ -200,41 +200,41 @@
System.out.println(intfs[i]);
}
- boolean oldmode = setBlockDataMode (true);
+ boolean oldmode = setBlockDataMode(true);
Class cl = resolveProxyClass(intfs);
setBlockDataMode(oldmode);
ObjectStreamClass osc = lookupClass(cl);
- assignNewHandle (osc);
+ assignNewHandle(osc);
if (!is_consumed)
{
- byte b = this.realInputStream.readByte ();
+ byte b = this.realInputStream.readByte();
if (b != TC_ENDBLOCKDATA)
- throw new IOException ("Data annotated to class was not consumed." + b);
+ throw new IOException("Data annotated to class was not consumed." + b);
}
else
is_consumed = false;
- ObjectStreamClass superosc = (ObjectStreamClass)readObject ();
- osc.setSuperclass (superosc);
+ ObjectStreamClass superosc = (ObjectStreamClass)readObject();
+ osc.setSuperclass(superosc);
ret_val = osc;
break;
}
case TC_CLASSDESC:
{
- ObjectStreamClass osc = readClassDescriptor ();
+ ObjectStreamClass osc = readClassDescriptor();
if (!is_consumed)
{
- byte b = this.realInputStream.readByte ();
+ byte b = this.realInputStream.readByte();
if (b != TC_ENDBLOCKDATA)
- throw new IOException ("Data annotated to class was not consumed." + b);
+ throw new IOException("Data annotated to class was not consumed." + b);
}
else
is_consumed = false;
- osc.setSuperclass ((ObjectStreamClass)readObject ());
+ osc.setSuperclass ((ObjectStreamClass)readObject());
ret_val = osc;
break;
}
@@ -242,105 +242,107 @@
case TC_STRING:
case TC_LONGSTRING:
{
- dumpElement ("STRING=");
- String s = this.realInputStream.readUTF ();
- dumpElementln (s);
- ret_val = processResolution (s, assignNewHandle (s));
+ dumpElement("STRING=");
+ String s = this.realInputStream.readUTF();
+ dumpElementln(s);
+ ret_val = processResolution(s, assignNewHandle(s));
break;
}
case TC_ARRAY:
{
- dumpElementln ("ARRAY");
- ObjectStreamClass osc = (ObjectStreamClass)readObject ();
- Class componentType = osc.forClass ().getComponentType ();
- dumpElement ("ARRAY LENGTH=");
- int length = this.realInputStream.readInt ();
+ dumpElementln("ARRAY");
+ ObjectStreamClass osc = (ObjectStreamClass)readObject();
+ Class componentType = osc.forClass().getComponentType();
+ dumpElement("ARRAY LENGTH=");
+ int length = this.realInputStream.readInt();
dumpElementln (length + "; COMPONENT TYPE=" + componentType);
- Object array = Array.newInstance (componentType, length);
- int handle = assignNewHandle (array);
- readArrayElements (array, componentType);
- for (int i=0, len=Array.getLength(array); i < len; i++)
- dumpElementln (" ELEMENT[" + i + "]=" + Array.get(array, i));
- ret_val = processResolution (array, handle);
+ Object array = Array.newInstance(componentType, length);
+ int handle = assignNewHandle(array);
+ readArrayElements(array, componentType);
+ for (int i = 0, len = Array.getLength(array); i < len; i++)
+ dumpElementln(" ELEMENT[" + i + "]=" + Array.get(array, i));
+ ret_val = processResolution(array, handle);
break;
}
case TC_OBJECT:
{
- dumpElementln ("OBJECT");
- ObjectStreamClass osc = (ObjectStreamClass)readObject ();
- Class clazz = osc.forClass ();
+ dumpElementln("OBJECT");
+ ObjectStreamClass osc = (ObjectStreamClass)readObject();
+ Class clazz = osc.forClass();
+
+ if (!Serializable.class.isAssignableFrom(clazz))
+ throw new NotSerializableException
+ (clazz + " is not Serializable, and thus cannot be deserialized.");
- if (!Serializable.class.isAssignableFrom (clazz))
- throw new NotSerializableException (clazz + " is not Serializable, and thus cannot be deserialized.");
-
- if (Externalizable.class.isAssignableFrom (clazz))
+ if (Externalizable.class.isAssignableFrom(clazz))
{
Externalizable obj = null;
try
{
- obj = (Externalizable)clazz.newInstance ();
+ obj = (Externalizable)clazz.newInstance();
}
catch (InstantiationException e)
{
- throw new ClassNotFoundException ("Instance of " + clazz
- + " could not be created");
+ throw new ClassNotFoundException
+ ("Instance of " + clazz + " could not be created");
}
catch (IllegalAccessException e)
{
- throw new ClassNotFoundException ("Instance of " + clazz
- + " could not be created because class or zero-argument constructor is not accessible");
+ throw new ClassNotFoundException
+ ("Instance of " + clazz + " could not be created because class or "
+ + "zero-argument constructor is not accessible");
}
catch (NoSuchMethodError e)
{
- throw new ClassNotFoundException ("Instance of " + clazz
+ throw new ClassNotFoundException
+ ("Instance of " + clazz
+ " could not be created because zero-argument constructor is not defined");
}
- int handle = assignNewHandle (obj);
+ int handle = assignNewHandle(obj);
- boolean read_from_blocks = ((osc.getFlags () & SC_BLOCK_DATA) != 0);
+ boolean read_from_blocks = ((osc.getFlags() & SC_BLOCK_DATA) != 0);
boolean oldmode = this.readDataFromBlock;
if (read_from_blocks)
- setBlockDataMode (true);
+ setBlockDataMode(true);
- obj.readExternal (this);
+ obj.readExternal(this);
if (read_from_blocks)
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
- ret_val = processResolution (obj, handle);
+ ret_val = processResolution(obj, handle);
break;
} // end if (Externalizable.class.isAssignableFrom (clazz))
// find the first non-serializable, non-abstract
// class in clazz's inheritance hierarchy
- Class first_nonserial = clazz.getSuperclass ();
- while (Serializable.class.isAssignableFrom (first_nonserial)
- || Modifier.isAbstract (first_nonserial.getModifiers ()))
- first_nonserial = first_nonserial.getSuperclass ();
+ Class first_nonserial = clazz.getSuperclass();
+ while (Serializable.class.isAssignableFrom(first_nonserial)
+ || Modifier.isAbstract(first_nonserial.getModifiers()))
+ first_nonserial = first_nonserial.getSuperclass();
Object obj = null;
- obj = newObject (clazz, first_nonserial);
+ obj = newObject(clazz, first_nonserial);
if (obj == null)
- throw new ClassNotFoundException ("Instance of " + clazz +
- " could not be created");
+ throw new ClassNotFoundException
+ ("Instance of " + clazz + " could not be created");
- int handle = assignNewHandle (obj);
+ int handle = assignNewHandle(obj);
this.currentObject = obj;
ObjectStreamClass[] hierarchy =
inputGetObjectStreamClasses(clazz);
- for (int i=0; i < hierarchy.length; i++)
+ for (int i = 0; i < hierarchy.length; i++)
{
this.currentObjectStreamClass = hierarchy[i];
- dumpElementln ("Reading fields of "
- + this.currentObjectStreamClass.getName ());
+ dumpElementln("Reading fields of " + this.currentObjectStreamClass.getName ());
// XXX: should initialize fields in classes in the hierarchy
// that aren't in the stream
@@ -350,68 +352,69 @@
if (this.currentObjectStreamClass.hasReadMethod())
{
fieldsAlreadyRead = false;
- boolean oldmode = setBlockDataMode (true);
- callReadMethod (obj, this.currentObjectStreamClass);
- setBlockDataMode (oldmode);
- dumpElement ("ENDBLOCKDATA? ");
+ boolean oldmode = setBlockDataMode(true);
+ callReadMethod(obj, this.currentObjectStreamClass);
+ setBlockDataMode(oldmode);
+ dumpElement("ENDBLOCKDATA? ");
try
{
// FIXME: XXX: This try block is to catch EOF which is
// thrown for some objects. That indicates a bug in the logic.
- if (this.realInputStream.readByte () != TC_ENDBLOCKDATA)
- throw new IOException ("No end of block data seen for class with readObject (ObjectInputStream) method.");
- dumpElementln ("yes");
+ if (this.realInputStream.readByte() != TC_ENDBLOCKDATA)
+ throw new IOException
+ ("No end of block data seen for class with readObject (ObjectInputStream) method.");
+ dumpElementln("yes");
}
catch (EOFException e)
{
- dumpElementln ("no, got EOFException");
+ dumpElementln("no, got EOFException");
}
catch (IOException e)
{
- dumpElementln ("no, got IOException");
+ dumpElementln("no, got IOException");
}
}
else
{
- readFields (obj, currentObjectStreamClass);
+ readFields(obj, currentObjectStreamClass);
}
}
this.currentObject = null;
this.currentObjectStreamClass = null;
- ret_val = processResolution (obj, handle);
+ ret_val = processResolution(obj, handle);
break;
}
case TC_RESET:
- dumpElementln ("RESET");
- clearHandles ();
- ret_val = readObject ();
+ dumpElementln("RESET");
+ clearHandles();
+ ret_val = readObject();
break;
case TC_EXCEPTION:
{
- dumpElement ("EXCEPTION=");
- Exception e = (Exception)readObject ();
- dumpElementln (e.toString());
- clearHandles ();
- throw new WriteAbortedException ("Exception thrown during writing of stream", e);
+ dumpElement("EXCEPTION=");
+ Exception e = (Exception)readObject();
+ dumpElementln(e.toString());
+ clearHandles();
+ throw new WriteAbortedException("Exception thrown during writing of stream", e);
}
default:
- throw new IOException ("Unknown marker on stream: " + marker);
+ throw new IOException("Unknown marker on stream: " + marker);
}
}
finally
{
- setBlockDataMode (old_mode);
+ setBlockDataMode(old_mode);
this.isDeserializing = was_deserializing;
if (! was_deserializing)
{
- if (validators.size () > 0)
- invokeValidators ();
+ if (validators.size() > 0)
+ invokeValidators();
}
}
@@ -434,30 +437,30 @@
* @throws InvalidClassException If there was a compatibility problem
* between the class present in the system and the serialized class.
*/
- protected ObjectStreamClass readClassDescriptor ()
+ protected ObjectStreamClass readClassDescriptor()
throws ClassNotFoundException, IOException
{
- dumpElement ("CLASSDESC NAME=");
- String name = this.realInputStream.readUTF ();
- dumpElement (name + "; UID=");
+ dumpElement("CLASSDESC NAME=");
+ String name = this.realInputStream.readUTF();
+ dumpElement(name + "; UID=");
long uid = this.realInputStream.readLong ();
- dumpElement (Long.toHexString(uid) + "; FLAGS=");
+ dumpElement(Long.toHexString(uid) + "; FLAGS=");
byte flags = this.realInputStream.readByte ();
- dumpElement (Integer.toHexString(flags) + "; FIELD COUNT=");
- short field_count = this.realInputStream.readShort ();
- dumpElementln (Short.toString(field_count));
+ dumpElement(Integer.toHexString(flags) + "; FIELD COUNT=");
+ short field_count = this.realInputStream.readShort();
+ dumpElementln(Short.toString(field_count));
ObjectStreamField[] fields = new ObjectStreamField[field_count];
- ObjectStreamClass osc = new ObjectStreamClass (name, uid,
+ ObjectStreamClass osc = new ObjectStreamClass(name, uid,
flags, fields);
- assignNewHandle (osc);
+ assignNewHandle(osc);
- for (int i=0; i < field_count; i++)
+ for (int i = 0; i < field_count; i++)
{
- dumpElement (" TYPE CODE=");
- char type_code = (char)this.realInputStream.readByte ();
- dumpElement (type_code + "; FIELD NAME=");
- String field_name = this.realInputStream.readUTF ();
- dumpElementln (field_name);
+ dumpElement(" TYPE CODE=");
+ char type_code = (char)this.realInputStream.readByte();
+ dumpElement(type_code + "; FIELD NAME=");
+ String field_name = this.realInputStream.readUTF();
+ dumpElementln(field_name);
String class_name;
// If the type code is an array or an object we must
@@ -465,9 +468,9 @@
// the type code and pass it to ObjectStreamField.
// Type codes are decoded by gnu.java.lang.reflect.TypeSignature.
if (type_code == 'L' || type_code == '[')
- class_name = (String)readObject ();
+ class_name = (String)readObject();
else
- class_name = String.valueOf (type_code);
+ class_name = String.valueOf(type_code);
fields[i] =
new ObjectStreamField(field_name, class_name, currentLoader());
@@ -495,10 +498,10 @@
}
}
- boolean oldmode = setBlockDataMode (true);
- osc.setClass (clazz, lookupClass(clazz.getSuperclass()));
+ boolean oldmode = setBlockDataMode(true);
+ osc.setClass(clazz, lookupClass(clazz.getSuperclass()));
classLookupTable.put(clazz, osc);
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
return osc;
}
@@ -522,7 +525,7 @@
* @exception IOException Exception from underlying
* <code>OutputStream</code>.
*/
- public void defaultReadObject ()
+ public void defaultReadObject()
throws ClassNotFoundException, IOException, NotActiveException
{
if (this.currentObject == null || this.currentObjectStreamClass == null)
@@ -535,7 +538,7 @@
+ "defaultReadObject or readFields)");
boolean oldmode = setBlockDataMode(false);
- readFields (this.currentObject, this.currentObjectStreamClass);
+ readFields(this.currentObject, this.currentObjectStreamClass);
setBlockDataMode(oldmode);
fieldsAlreadyRead = true;
@@ -560,19 +563,19 @@
* validator outside of the <code>readObject</code> method of the
* object currently being deserialized
*/
- public void registerValidation (ObjectInputValidation validator,
+ public void registerValidation(ObjectInputValidation validator,
int priority)
throws InvalidObjectException, NotActiveException
{
if (this.currentObject == null || this.currentObjectStreamClass == null)
- throw new NotActiveException ("registerValidation called by non-active "
- +"class and/or object");
+ throw new NotActiveException("registerValidation called by non-active "
+ + "class and/or object");
if (validator == null)
- throw new InvalidObjectException ("attempt to add a null "
- +"ObjectInputValidation object");
+ throw new InvalidObjectException("attempt to add a null "
+ + "ObjectInputValidation object");
- this.validators.addElement (new ValidatorAndPriority (validator,
+ this.validators.addElement(new ValidatorAndPriority (validator,
priority));
}
@@ -593,7 +596,7 @@
*
* @see java.io.ObjectOutputStream#annotateClass (java.lang.Class)
*/
- protected Class resolveClass (ObjectStreamClass osc)
+ protected Class resolveClass(ObjectStreamClass osc)
throws ClassNotFoundException, IOException
{
return Class.forName(osc.getName(), true, currentLoader());
@@ -609,7 +612,7 @@
*/
private ClassLoader currentLoader()
{
- SecurityManager sm = System.getSecurityManager ();
+ SecurityManager sm = System.getSecurityManager();
if (sm == null)
sm = new SecurityManager () {};
@@ -627,13 +630,13 @@
* @return A valid instance of ObjectStreamClass corresponding
* to the specified class.
*/
- private ObjectStreamClass lookupClass (Class clazz)
+ private ObjectStreamClass lookupClass(Class clazz)
{
ObjectStreamClass oclazz;
- oclazz = (ObjectStreamClass) classLookupTable.get(clazz);
+ oclazz = (ObjectStreamClass)classLookupTable.get(clazz);
if (oclazz == null)
- return ObjectStreamClass.lookup (clazz);
+ return ObjectStreamClass.lookup(clazz);
else
return oclazz;
}
@@ -650,9 +653,9 @@
* @return An array of valid {@link java.io.ObjectStreamClass} instances which
* represent the class hierarchy for clazz.
*/
- private ObjectStreamClass[] inputGetObjectStreamClasses (Class clazz)
+ private ObjectStreamClass[] inputGetObjectStreamClasses(Class clazz)
{
- ObjectStreamClass osc = lookupClass (clazz);
+ ObjectStreamClass osc = lookupClass(clazz);
ObjectStreamClass[] ret_val;
@@ -691,24 +694,25 @@
*
* @see #enableResolveObject(boolean)
*/
- protected Object resolveObject (Object obj) throws IOException
+ protected Object resolveObject(Object obj) throws IOException
{
return obj;
}
- protected Class resolveProxyClass (String[] intfs)
+ protected Class resolveProxyClass(String[] intfs)
throws IOException, ClassNotFoundException
{
- SecurityManager sm = System.getSecurityManager ();
+ SecurityManager sm = System.getSecurityManager();
if (sm == null)
- sm = new SecurityManager () {};
+ sm = new SecurityManager() {};
- ClassLoader cl = currentClassLoader (sm);
+ ClassLoader cl = currentClassLoader(sm);
Class[] clss = new Class[intfs.length];
- if(cl == null){
+ if(cl == null)
+ {
for (int i = 0; i < intfs.length; i++)
clss[i] = Class.forName(intfs[i]);
cl = ClassLoader.getSystemClassLoader();
@@ -716,9 +720,12 @@
else
for (int i = 0; i < intfs.length; i++)
clss[i] = cl.loadClass(intfs[i]);
- try {
+ try
+ {
return Proxy.getProxyClass(cl, clss);
- } catch (IllegalArgumentException e) {
+ }
+ catch (IllegalArgumentException e)
+ {
throw new ClassNotFoundException(null, e);
}
}
@@ -736,9 +743,9 @@
{
if (enable)
{
- SecurityManager sm = System.getSecurityManager ();
+ SecurityManager sm = System.getSecurityManager();
if (sm != null)
- sm.checkPermission (new SerializablePermission ("enableSubstitution"));
+ sm.checkPermission(new SerializablePermission("enableSubstitution"));
}
boolean old_val = this.resolveEnabled;
@@ -755,31 +762,31 @@
* @exception StreamCorruptedException An invalid stream magic
* number or stream version was read from the stream.
*/
- protected void readStreamHeader ()
+ protected void readStreamHeader()
throws IOException, StreamCorruptedException
{
- dumpElement ("STREAM MAGIC ");
- if (this.realInputStream.readShort () != STREAM_MAGIC)
- throw new StreamCorruptedException ("Invalid stream magic number");
+ dumpElement("STREAM MAGIC ");
+ if (this.realInputStream.readShort() != STREAM_MAGIC)
+ throw new StreamCorruptedException("Invalid stream magic number");
- dumpElementln ("STREAM VERSION ");
- if (this.realInputStream.readShort () != STREAM_VERSION)
- throw new StreamCorruptedException ("Invalid stream version number");
+ dumpElementln("STREAM VERSION ");
+ if (this.realInputStream.readShort() != STREAM_VERSION)
+ throw new StreamCorruptedException("Invalid stream version number");
}
- public int read () throws IOException
+ public int read() throws IOException
{
if (this.readDataFromBlock)
{
if (this.blockDataPosition >= this.blockDataBytes)
- readNextBlock ();
+ readNextBlock();
return (this.blockData[this.blockDataPosition++] & 0xff);
}
else
- return this.realInputStream.read ();
+ return this.realInputStream.read();
}
- public int read (byte[] data, int offset, int length) throws IOException
+ public int read(byte[] data, int offset, int length) throws IOException
{
if (this.readDataFromBlock)
{
@@ -788,7 +795,7 @@
int remain = this.blockDataBytes - this.blockDataPosition;
if (remain != 0)
{
- System.arraycopy (this.blockData, this.blockDataPosition,
+ System.arraycopy(this.blockData, this.blockDataPosition,
data, offset, remain);
offset += remain;
length -= remain;
@@ -796,17 +803,17 @@
readNextBlock ();
}
- System.arraycopy (this.blockData, this.blockDataPosition,
+ System.arraycopy(this.blockData, this.blockDataPosition,
data, offset, length);
this.blockDataPosition += length;
return length;
}
else
- return this.realInputStream.read (data, offset, length);
+ return this.realInputStream.read(data, offset, length);
}
- public int available () throws IOException
+ public int available() throws IOException
{
if (this.readDataFromBlock)
{
@@ -816,15 +823,15 @@
return this.blockDataBytes - this.blockDataPosition;
}
else
- return this.realInputStream.available ();
+ return this.realInputStream.available();
}
- public void close () throws IOException
+ public void close() throws IOException
{
- this.realInputStream.close ();
+ this.realInputStream.close();
}
- public boolean readBoolean () throws IOException
+ public boolean readBoolean() throws IOException
{
boolean switchmode = true;
boolean oldmode = this.readDataFromBlock;
@@ -838,160 +845,160 @@
return value;
}
- public byte readByte () throws IOException
+ public byte readByte() throws IOException
{
boolean switchmode = true;
boolean oldmode = this.readDataFromBlock;
if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 1)
switchmode = false;
if (switchmode)
- oldmode = setBlockDataMode (true);
- byte value = this.dataInputStream.readByte ();
+ oldmode = setBlockDataMode(true);
+ byte value = this.dataInputStream.readByte();
if (switchmode)
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
return value;
}
- public int readUnsignedByte () throws IOException
+ public int readUnsignedByte() throws IOException
{
boolean switchmode = true;
boolean oldmode = this.readDataFromBlock;
if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 1)
switchmode = false;
if (switchmode)
- oldmode = setBlockDataMode (true);
- int value = this.dataInputStream.readUnsignedByte ();
+ oldmode = setBlockDataMode(true);
+ int value = this.dataInputStream.readUnsignedByte();
if (switchmode)
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
return value;
}
- public short readShort () throws IOException
+ public short readShort() throws IOException
{
boolean switchmode = true;
boolean oldmode = this.readDataFromBlock;
if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 2)
switchmode = false;
if (switchmode)
- oldmode = setBlockDataMode (true);
- short value = this.dataInputStream.readShort ();
+ oldmode = setBlockDataMode(true);
+ short value = this.dataInputStream.readShort();
if (switchmode)
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
return value;
}
- public int readUnsignedShort () throws IOException
+ public int readUnsignedShort() throws IOException
{
boolean switchmode = true;
boolean oldmode = this.readDataFromBlock;
if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 2)
switchmode = false;
if (switchmode)
- oldmode = setBlockDataMode (true);
- int value = this.dataInputStream.readUnsignedShort ();
+ oldmode = setBlockDataMode(true);
+ int value = this.dataInputStream.readUnsignedShort();
if (switchmode)
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
return value;
}
- public char readChar () throws IOException
+ public char readChar() throws IOException
{
boolean switchmode = true;
boolean oldmode = this.readDataFromBlock;
if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 2)
switchmode = false;
if (switchmode)
- oldmode = setBlockDataMode (true);
- char value = this.dataInputStream.readChar ();
+ oldmode = setBlockDataMode(true);
+ char value = this.dataInputStream.readChar();
if (switchmode)
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
return value;
}
- public int readInt () throws IOException
+ public int readInt() throws IOException
{
boolean switchmode = true;
boolean oldmode = this.readDataFromBlock;
if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 4)
switchmode = false;
if (switchmode)
- oldmode = setBlockDataMode (true);
- int value = this.dataInputStream.readInt ();
+ oldmode = setBlockDataMode(true);
+ int value = this.dataInputStream.readInt();
if (switchmode)
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
return value;
}
- public long readLong () throws IOException
+ public long readLong() throws IOException
{
boolean switchmode = true;
boolean oldmode = this.readDataFromBlock;
if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 8)
switchmode = false;
if (switchmode)
- oldmode = setBlockDataMode (true);
- long value = this.dataInputStream.readLong ();
+ oldmode = setBlockDataMode(true);
+ long value = this.dataInputStream.readLong();
if (switchmode)
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
return value;
}
- public float readFloat () throws IOException
+ public float readFloat() throws IOException
{
boolean switchmode = true;
boolean oldmode = this.readDataFromBlock;
if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 4)
switchmode = false;
if (switchmode)
- oldmode = setBlockDataMode (true);
- float value = this.dataInputStream.readFloat ();
+ oldmode = setBlockDataMode(true);
+ float value = this.dataInputStream.readFloat();
if (switchmode)
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
return value;
}
- public double readDouble () throws IOException
+ public double readDouble() throws IOException
{
boolean switchmode = true;
boolean oldmode = this.readDataFromBlock;
if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 8)
switchmode = false;
if (switchmode)
- oldmode = setBlockDataMode (true);
- double value = this.dataInputStream.readDouble ();
+ oldmode = setBlockDataMode(true);
+ double value = this.dataInputStream.readDouble();
if (switchmode)
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
return value;
}
- public void readFully (byte data[]) throws IOException
+ public void readFully(byte data[]) throws IOException
{
- this.dataInputStream.readFully (data);
+ this.dataInputStream.readFully(data);
}
- public void readFully (byte data[], int offset, int size)
+ public void readFully(byte data[], int offset, int size)
throws IOException
{
- this.dataInputStream.readFully (data, offset, size);
+ this.dataInputStream.readFully(data, offset, size);
}
- public int skipBytes (int len) throws IOException
+ public int skipBytes(int len) throws IOException
{
- return this.dataInputStream.skipBytes (len);
+ return this.dataInputStream.skipBytes(len);
}
/**
* @deprecated
* @see java.io.DataInputStream#readLine ()
*/
- public String readLine () throws IOException
+ public String readLine() throws IOException
{
- return this.dataInputStream.readLine ();
+ return this.dataInputStream.readLine();
}
- public String readUTF () throws IOException
+ public String readUTF() throws IOException
{
- return this.dataInputStream.readUTF ();
+ return this.dataInputStream.readUTF();
}
/**
@@ -1002,36 +1009,36 @@
*/
public static abstract class GetField
{
- public abstract ObjectStreamClass getObjectStreamClass ();
+ public abstract ObjectStreamClass getObjectStreamClass();
- public abstract boolean defaulted (String name)
+ public abstract boolean defaulted(String name)
throws IOException, IllegalArgumentException;
- public abstract boolean get (String name, boolean defvalue)
+ public abstract boolean get(String name, boolean defvalue)
throws IOException, IllegalArgumentException;
- public abstract char get (String name, char defvalue)
+ public abstract char get(String name, char defvalue)
throws IOException, IllegalArgumentException;
- public abstract byte get (String name, byte defvalue)
+ public abstract byte get(String name, byte defvalue)
throws IOException, IllegalArgumentException;
- public abstract short get (String name, short defvalue)
+ public abstract short get(String name, short defvalue)
throws IOException, IllegalArgumentException;
- public abstract int get (String name, int defvalue)
+ public abstract int get(String name, int defvalue)
throws IOException, IllegalArgumentException;
- public abstract long get (String name, long defvalue)
+ public abstract long get(String name, long defvalue)
throws IOException, IllegalArgumentException;
- public abstract float get (String name, float defvalue)
+ public abstract float get(String name, float defvalue)
throws IOException, IllegalArgumentException;
- public abstract double get (String name, double defvalue)
+ public abstract double get(String name, double defvalue)
throws IOException, IllegalArgumentException;
- public abstract Object get (String name, Object defvalue)
+ public abstract Object get(String name, Object defvalue)
throws IOException, IllegalArgumentException;
}
@@ -1048,17 +1055,17 @@
* @throws ClassNotFoundException
* @throws NotActiveException
*/
- public GetField readFields ()
+ public GetField readFields()
throws IOException, ClassNotFoundException, NotActiveException
{
if (this.currentObject == null || this.currentObjectStreamClass == null)
- throw new NotActiveException ("readFields called by non-active class and/or object");
+ throw new NotActiveException("readFields called by non-active class and/or object");
if (prereadFields != null)
return prereadFields;
if (fieldsAlreadyRead)
- throw new NotActiveException ("readFields called but fields already read from"
+ throw new NotActiveException("readFields called but fields already read from"
+ " stream (by defaultReadObject or readFields)");
final ObjectStreamClass clazz = this.currentObjectStreamClass;
@@ -1068,20 +1075,20 @@
// Apparently Block data is not used with GetField as per
// empirical evidence against JDK 1.2. Also see Mauve test
// java.io.ObjectInputOutput.Test.GetPutField.
- boolean oldmode = setBlockDataMode (false);
- readFully (prim_field_data);
+ boolean oldmode = setBlockDataMode(false);
+ readFully(prim_field_data);
for (int i = 0; i < objs.length; ++ i)
- objs[i] = readObject ();
- setBlockDataMode (oldmode);
+ objs[i] = readObject();
+ setBlockDataMode(oldmode);
prereadFields = new GetField()
{
- public ObjectStreamClass getObjectStreamClass ()
+ public ObjectStreamClass getObjectStreamClass()
{
return clazz;
}
- public boolean defaulted (String name)
+ public boolean defaulted(String name)
throws IOException, IllegalArgumentException
{
ObjectStreamField f = clazz.getField(name);
@@ -1107,69 +1114,69 @@
}
catch (NoSuchFieldException e)
{
- throw new IllegalArgumentException (e.getMessage());
+ throw new IllegalArgumentException(e.getMessage());
}
}
- public boolean get (String name, boolean defvalue)
+ public boolean get(String name, boolean defvalue)
throws IOException, IllegalArgumentException
{
- ObjectStreamField field = getField (name, Boolean.TYPE);
+ ObjectStreamField field = getField(name, Boolean.TYPE);
if (field == null)
return defvalue;
- return prim_field_data[field.getOffset ()] == 0 ? false : true;
+ return prim_field_data[field.getOffset()] == 0 ? false : true;
}
- public char get (String name, char defvalue)
+ public char get(String name, char defvalue)
throws IOException, IllegalArgumentException
{
- ObjectStreamField field = getField (name, Character.TYPE);
+ ObjectStreamField field = getField(name, Character.TYPE);
if (field == null)
return defvalue;
- int off = field.getOffset ();
+ int off = field.getOffset();
return (char)(((prim_field_data[off++] & 0xFF) << 8)
| (prim_field_data[off] & 0xFF));
}
- public byte get (String name, byte defvalue)
+ public byte get(String name, byte defvalue)
throws IOException, IllegalArgumentException
{
- ObjectStreamField field = getField (name, Byte.TYPE);
+ ObjectStreamField field = getField(name, Byte.TYPE);
if (field == null)
return defvalue;
- return prim_field_data[field.getOffset ()];
+ return prim_field_data[field.getOffset()];
}
- public short get (String name, short defvalue)
+ public short get(String name, short defvalue)
throws IOException, IllegalArgumentException
{
- ObjectStreamField field = getField (name, Short.TYPE);
+ ObjectStreamField field = getField(name, Short.TYPE);
if (field == null)
return defvalue;
- int off = field.getOffset ();
+ int off = field.getOffset();
return (short)(((prim_field_data[off++] & 0xFF) << 8)
| (prim_field_data[off] & 0xFF));
}
- public int get (String name, int defvalue)
+ public int get(String name, int defvalue)
throws IOException, IllegalArgumentException
{
- ObjectStreamField field = getField (name, Integer.TYPE);
+ ObjectStreamField field = getField(name, Integer.TYPE);
if (field == null)
return defvalue;
- int off = field.getOffset ();
+ int off = field.getOffset();
return ((prim_field_data[off++] & 0xFF) << 24)
| ((prim_field_data[off++] & 0xFF) << 16)
@@ -1177,15 +1184,15 @@
| (prim_field_data[off] & 0xFF);
}
- public long get (String name, long defvalue)
+ public long get(String name, long defvalue)
throws IOException, IllegalArgumentException
{
- ObjectStreamField field = getField (name, Long.TYPE);
+ ObjectStreamField field = getField(name, Long.TYPE);
if (field == null)
return defvalue;
- int off = field.getOffset ();
+ int off = field.getOffset();
return (long)(((prim_field_data[off++] & 0xFF) << 56)
| ((prim_field_data[off++] & 0xFF) << 48)
@@ -1197,31 +1204,31 @@
| (prim_field_data[off] & 0xFF));
}
- public float get (String name, float defvalue)
+ public float get(String name, float defvalue)
throws IOException, IllegalArgumentException
{
- ObjectStreamField field = getField (name, Float.TYPE);
+ ObjectStreamField field = getField(name, Float.TYPE);
if (field == null)
return defvalue;
- int off = field.getOffset ();
+ int off = field.getOffset();
- return Float.intBitsToFloat (((prim_field_data[off++] & 0xFF) << 24)
+ return Float.intBitsToFloat(((prim_field_data[off++] & 0xFF) << 24)
| ((prim_field_data[off++] & 0xFF) << 16)
| ((prim_field_data[off++] & 0xFF) << 8)
| (prim_field_data[off] & 0xFF));
}
- public double get (String name, double defvalue)
+ public double get(String name, double defvalue)
throws IOException, IllegalArgumentException
{
- ObjectStreamField field = getField (name, Double.TYPE);
+ ObjectStreamField field = getField(name, Double.TYPE);
if (field == null)
return defvalue;
- int off = field.getOffset ();
+ int off = field.getOffset();
return Double.longBitsToDouble
( (long) (((prim_field_data[off++] & 0xFF) << 56)
@@ -1234,22 +1241,22 @@
| (prim_field_data[off] & 0xFF)));
}
- public Object get (String name, Object defvalue)
+ public Object get(String name, Object defvalue)
throws IOException, IllegalArgumentException
{
ObjectStreamField field =
- getField (name, defvalue == null ? null : defvalue.getClass ());
+ getField(name, defvalue == null ? null : defvalue.getClass ());
if (field == null)
return defvalue;
- return objs[field.getOffset ()];
+ return objs[field.getOffset()];
}
- private ObjectStreamField getField (String name, Class type)
+ private ObjectStreamField getField(String name, Class type)
throws IllegalArgumentException
{
- ObjectStreamField field = clazz.getField (name);
+ ObjectStreamField field = clazz.getField(name);
boolean illegal = false;
try
@@ -1300,7 +1307,7 @@
*/
try
{
- Field f = clazz.forClass().getDeclaredField (name);
+ Field f = clazz.forClass().getDeclaredField(name);
if (Modifier.isTransient(f.getModifiers()))
throw new IllegalArgumentException
("no such field (non transient) " + name);
@@ -1333,12 +1340,12 @@
*
* @see #readObjectOverride()
*/
- protected ObjectInputStream ()
+ protected ObjectInputStream()
throws IOException, SecurityException
{
- SecurityManager sec_man = System.getSecurityManager ();
+ SecurityManager sec_man = System.getSecurityManager();
if (sec_man != null)
- sec_man.checkPermission (SUBCLASS_IMPLEMENTATION_PERMISSION);
+ sec_man.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
this.useSubclassMethod = true;
}
@@ -1351,10 +1358,10 @@
*
* @see #ObjectInputStream()
*/
- protected Object readObjectOverride ()
+ protected Object readObjectOverride()
throws ClassNotFoundException, IOException, OptionalDataException
{
- throw new IOException ("Subclass of ObjectInputStream must implement readObjectOverride");
+ throw new IOException("Subclass of ObjectInputStream must implement readObjectOverride");
}
/**
@@ -1363,14 +1370,14 @@
* @param obj The object for which we want a new handle.
* @return A valid handle for the specified object.
*/
- private int assignNewHandle (Object obj)
+ private int assignNewHandle(Object obj)
{
- this.objectLookupTable.put (new Integer (this.nextOID),
- new ObjectIdentityWrapper (obj));
+ this.objectLookupTable.put(new Integer(this.nextOID),
+ new ObjectIdentityWrapper(obj));
return this.nextOID++;
}
- private Object processResolution (Object obj, int handle)
+ private Object processResolution(Object obj, int handle)
throws IOException
{
if (obj instanceof Serializable)
@@ -1380,7 +1387,7 @@
{
Class classArgs[] = {};
m = getMethod(obj.getClass(), "readResolve", classArgs);
- obj = m.invoke (obj, new Object[] {});
+ obj = m.invoke(obj, new Object[] {});
}
catch (NoSuchMethodException ignore)
{
@@ -1394,42 +1401,42 @@
}
if (this.resolveEnabled)
- obj = resolveObject (obj);
+ obj = resolveObject(obj);
- this.objectLookupTable.put (new Integer (handle),
- new ObjectIdentityWrapper (obj));
+ this.objectLookupTable.put(new Integer(handle),
+ new ObjectIdentityWrapper(obj));
return obj;
}
- private void clearHandles ()
+ private void clearHandles()
{
- this.objectLookupTable.clear ();
+ this.objectLookupTable.clear();
this.nextOID = baseWireHandle;
}
- private void readNextBlock () throws IOException
+ private void readNextBlock() throws IOException
{
- readNextBlock (this.realInputStream.readByte ());
+ readNextBlock(this.realInputStream.readByte());
}
- private void readNextBlock (byte marker) throws IOException
+ private void readNextBlock(byte marker) throws IOException
{
if (marker == TC_BLOCKDATA)
{
- dumpElement ("BLOCK DATA SIZE=");
- this.blockDataBytes = this.realInputStream.readUnsignedByte ();
+ dumpElement("BLOCK DATA SIZE=");
+ this.blockDataBytes = this.realInputStream.readUnsignedByte();
dumpElementln (Integer.toString(this.blockDataBytes));
}
else if (marker == TC_BLOCKDATALONG)
{
- dumpElement ("BLOCK DATA LONG SIZE=");
- this.blockDataBytes = this.realInputStream.readInt ();
+ dumpElement("BLOCK DATA LONG SIZE=");
+ this.blockDataBytes = this.realInputStream.readInt();
dumpElementln (Integer.toString(this.blockDataBytes));
}
else
{
- throw new EOFException ("Attempt to read primitive data, but no data block is active.");
+ throw new EOFException("Attempt to read primitive data, but no data block is active.");
}
if (this.blockData.length < this.blockDataBytes)
@@ -1442,62 +1449,62 @@
private void readArrayElements (Object array, Class clazz)
throws ClassNotFoundException, IOException
{
- if (clazz.isPrimitive ())
+ if (clazz.isPrimitive())
{
if (clazz == Boolean.TYPE)
{
boolean[] cast_array = (boolean[])array;
for (int i=0; i < cast_array.length; i++)
- cast_array[i] = this.realInputStream.readBoolean ();
+ cast_array[i] = this.realInputStream.readBoolean();
return;
}
if (clazz == Byte.TYPE)
{
byte[] cast_array = (byte[])array;
for (int i=0; i < cast_array.length; i++)
- cast_array[i] = this.realInputStream.readByte ();
+ cast_array[i] = this.realInputStream.readByte();
return;
}
if (clazz == Character.TYPE)
{
char[] cast_array = (char[])array;
for (int i=0; i < cast_array.length; i++)
- cast_array[i] = this.realInputStream.readChar ();
+ cast_array[i] = this.realInputStream.readChar();
return;
}
if (clazz == Double.TYPE)
{
double[] cast_array = (double[])array;
for (int i=0; i < cast_array.length; i++)
- cast_array[i] = this.realInputStream.readDouble ();
+ cast_array[i] = this.realInputStream.readDouble();
return;
}
if (clazz == Float.TYPE)
{
float[] cast_array = (float[])array;
for (int i=0; i < cast_array.length; i++)
- cast_array[i] = this.realInputStream.readFloat ();
+ cast_array[i] = this.realInputStream.readFloat();
return;
}
if (clazz == Integer.TYPE)
{
int[] cast_array = (int[])array;
for (int i=0; i < cast_array.length; i++)
- cast_array[i] = this.realInputStream.readInt ();
+ cast_array[i] = this.realInputStream.readInt();
return;
}
if (clazz == Long.TYPE)
{
long[] cast_array = (long[])array;
for (int i=0; i < cast_array.length; i++)
- cast_array[i] = this.realInputStream.readLong ();
+ cast_array[i] = this.realInputStream.readLong();
return;
}
if (clazz == Short.TYPE)
{
short[] cast_array = (short[])array;
for (int i=0; i < cast_array.length; i++)
- cast_array[i] = this.realInputStream.readShort ();
+ cast_array[i] = this.realInputStream.readShort();
return;
}
}
@@ -1505,7 +1512,7 @@
{
Object[] cast_array = (Object[])array;
for (int i=0; i < cast_array.length; i++)
- cast_array[i] = readObject ();
+ cast_array[i] = readObject();
}
}
@@ -1535,7 +1542,7 @@
else
{
stream_field = stream_fields[stream_idx];
- type = stream_field.getType ();
+ type = stream_field.getType();
}
if (real_idx == real_fields.length)
@@ -1543,8 +1550,8 @@
else
{
real_field = real_fields[real_idx];
- type = real_field.getType ();
- field_name = real_field.getName ();
+ type = real_field.getType();
+ field_name = real_field.getName();
}
if (set_value && !default_initialize)
@@ -1583,82 +1590,82 @@
if (type == Boolean.TYPE)
{
boolean value =
- default_initialize ? false : this.realInputStream.readBoolean ();
+ default_initialize ? false : this.realInputStream.readBoolean();
if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
+ dumpElementln(" " + field_name + ": " + value);
if (set_value)
- setBooleanField (obj, stream_osc.forClass (), field_name, value);
+ setBooleanField(obj, stream_osc.forClass(), field_name, value);
}
else if (type == Byte.TYPE)
{
byte value =
- default_initialize ? 0 : this.realInputStream.readByte ();
+ default_initialize ? 0 : this.realInputStream.readByte();
if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
+ dumpElementln(" " + field_name + ": " + value);
if (set_value)
- setByteField (obj, stream_osc.forClass (), field_name, value);
+ setByteField(obj, stream_osc.forClass(), field_name, value);
}
else if (type == Character.TYPE)
{
char value =
- default_initialize ? (char)0 : this.realInputStream.readChar ();
+ default_initialize ? (char)0 : this.realInputStream.readChar();
if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
+ dumpElementln(" " + field_name + ": " + value);
if (set_value)
- setCharField (obj, stream_osc.forClass (), field_name, value);
+ setCharField(obj, stream_osc.forClass(), field_name, value);
}
else if (type == Double.TYPE)
{
double value =
- default_initialize ? 0 : this.realInputStream.readDouble ();
+ default_initialize ? 0 : this.realInputStream.readDouble();
if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
+ dumpElementln(" " + field_name + ": " + value);
if (set_value)
- setDoubleField (obj, stream_osc.forClass (), field_name, value);
+ setDoubleField(obj, stream_osc.forClass(), field_name, value);
}
else if (type == Float.TYPE)
{
float value =
- default_initialize ? 0 : this.realInputStream.readFloat ();
+ default_initialize ? 0 : this.realInputStream.readFloat();
if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
+ dumpElementln(" " + field_name + ": " + value);
if (set_value)
- setFloatField (obj, stream_osc.forClass (), field_name, value);
+ setFloatField(obj, stream_osc.forClass(), field_name, value);
}
else if (type == Integer.TYPE)
{
int value =
- default_initialize ? 0 : this.realInputStream.readInt ();
+ default_initialize ? 0 : this.realInputStream.readInt();
if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
+ dumpElementln(" " + field_name + ": " + value);
if (set_value)
- setIntField (obj, stream_osc.forClass (), field_name, value);
+ setIntField(obj, stream_osc.forClass(), field_name, value);
}
else if (type == Long.TYPE)
{
long value =
- default_initialize ? 0 : this.realInputStream.readLong ();
+ default_initialize ? 0 : this.realInputStream.readLong();
if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
+ dumpElementln(" " + field_name + ": " + value);
if (set_value)
- setLongField (obj, stream_osc.forClass (), field_name, value);
+ setLongField(obj, stream_osc.forClass(), field_name, value);
}
else if (type == Short.TYPE)
{
short value =
- default_initialize ? (short)0 : this.realInputStream.readShort ();
+ default_initialize ? (short)0 : this.realInputStream.readShort();
if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
+ dumpElementln(" " + field_name + ": " + value);
if (set_value)
- setShortField (obj, stream_osc.forClass (), field_name, value);
+ setShortField(obj, stream_osc.forClass(), field_name, value);
}
else
{
Object value =
- default_initialize ? null : readObject ();
+ default_initialize ? null : readObject();
if (set_value)
- setObjectField (obj, stream_osc.forClass (), field_name,
- real_field.getTypeString (), value);
+ setObjectField(obj, stream_osc.forClass(), field_name,
+ real_field.getTypeString(), value);
}
}
catch (NoSuchFieldError e)
@@ -1699,20 +1706,20 @@
// runs all registered ObjectInputValidations in prioritized order
// on OBJ
- private void invokeValidators () throws InvalidObjectException
+ private void invokeValidators() throws InvalidObjectException
{
- Object[] validators = new Object[this.validators.size ()];
+ Object[] validators = new Object[this.validators.size()];
this.validators.copyInto (validators);
Arrays.sort (validators);
try
{
for (int i=0; i < validators.length; i++)
- ((ObjectInputValidation)validators[i]).validateObject ();
+ ((ObjectInputValidation)validators[i]).validateObject();
}
finally
{
- this.validators.removeAllElements ();
+ this.validators.removeAllElements();
}
}
@@ -1789,7 +1796,7 @@
Class classArgs[] = {ObjectInputStream.class};
Method m = getMethod (klass, "readObject", classArgs);
Object args[] = {this};
- m.invoke (obj, args);
+ m.invoke(obj, args);
}
catch (NoSuchMethodException nsme)
{
@@ -1804,12 +1811,12 @@
if (exception instanceof IOException)
throw (IOException) exception;
- throw new IOException ("Exception thrown from readObject() on " +
+ throw new IOException("Exception thrown from readObject() on " +
klass + ": " + exception.getClass().getName());
}
catch (Exception x)
{
- throw new IOException ("Failure invoking readObject() on " +
+ throw new IOException("Failure invoking readObject() on " +
klass + ": " + x.getClass().getName());
}
@@ -1833,13 +1840,13 @@
* @throws InvalidClassException if the specified field has not the required type.
* @throws IOException if there is no field of that name in the specified class.
*/
- private void setBooleanField (Object obj, Class klass, String field_name,
+ private void setBooleanField(Object obj, Class klass, String field_name,
boolean val) throws IOException, InvalidClassException
{
try
{
- Field f = getField (klass, field_name);
- f.setBoolean (obj, val);
+ Field f = getField(klass, field_name);
+ f.setBoolean(obj, val);
}
catch (IllegalArgumentException _)
{
@@ -1861,13 +1868,13 @@
* @throws InvalidClassException if the specified field has not the required type.
* @throws IOException if there is no field of that name in the specified class.
*/
- private void setByteField (Object obj, Class klass, String field_name,
+ private void setByteField(Object obj, Class klass, String field_name,
byte val) throws IOException, InvalidClassException
{
try
{
- Field f = getField (klass, field_name);
- f.setByte (obj, val);
+ Field f = getField(klass, field_name);
+ f.setByte(obj, val);
}
catch (IllegalArgumentException _)
{
@@ -1889,13 +1896,13 @@
* @throws InvalidClassException if the specified field has not the required type.
* @throws IOException if there is no field of that name in the specified class.
*/
- private void setCharField (Object obj, Class klass, String field_name,
+ private void setCharField(Object obj, Class klass, String field_name,
char val) throws IOException, InvalidClassException
{
try
{
- Field f = getField (klass, field_name);
- f.setChar (obj, val);
+ Field f = getField(klass, field_name);
+ f.setChar(obj, val);
}
catch (IllegalArgumentException _)
{
@@ -1917,13 +1924,13 @@
* @throws InvalidClassException if the specified field has not the required type.
* @throws IOException if there is no field of that name in the specified class.
*/
- private void setDoubleField (Object obj, Class klass, String field_name,
+ private void setDoubleField(Object obj, Class klass, String field_name,
double val) throws IOException, InvalidClassException
{
try
{
- Field f = getField (klass, field_name);
- f.setDouble (obj, val);
+ Field f = getField(klass, field_name);
+ f.setDouble(obj, val);
}
catch (IllegalArgumentException _)
{
@@ -1945,13 +1952,13 @@
* @throws InvalidClassException if the specified field has not the required type.
* @throws IOException if there is no field of that name in the specified class.
*/
- private void setFloatField (Object obj, Class klass, String field_name,
+ private void setFloatField(Object obj, Class klass, String field_name,
float val) throws IOException, InvalidClassException
{
try
{
- Field f = getField (klass, field_name);
- f.setFloat (obj, val);
+ Field f = getField(klass, field_name);
+ f.setFloat(obj, val);
}
catch (IllegalArgumentException _)
{
@@ -1973,13 +1980,13 @@
* @throws InvalidClassException if the specified field has not the required type.
* @throws IOException if there is no field of that name in the specified class.
*/
- private void setIntField (Object obj, Class klass, String field_name,
+ private void setIntField(Object obj, Class klass, String field_name,
int val) throws IOException, InvalidClassException
{
try
{
- Field f = getField (klass, field_name);
- f.setInt (obj, val);
+ Field f = getField(klass, field_name);
+ f.setInt(obj, val);
}
catch (IllegalArgumentException _)
{
@@ -2001,13 +2008,13 @@
* @throws InvalidClassException if the specified field has not the required type.
* @throws IOException if there is no field of that name in the specified class.
*/
- private void setLongField (Object obj, Class klass, String field_name,
+ private void setLongField(Object obj, Class klass, String field_name,
long val) throws IOException, InvalidClassException
{
try
{
- Field f = getField (klass, field_name);
- f.setLong (obj, val);
+ Field f = getField(klass, field_name);
+ f.setLong(obj, val);
}
catch (IllegalArgumentException _)
{
@@ -2029,13 +2036,13 @@
* @throws InvalidClassException if the specified field has not the required type.
* @throws IOException if there is no field of that name in the specified class.
*/
- private void setShortField (Object obj, Class klass, String field_name,
+ private void setShortField(Object obj, Class klass, String field_name,
short val) throws IOException, InvalidClassException
{
try
{
- Field f = getField (klass, field_name);
- f.setShort (obj, val);
+ Field f = getField(klass, field_name);
+ f.setShort(obj, val);
}
catch (IllegalArgumentException _)
{
@@ -2057,25 +2064,26 @@
* @throws InvalidClassException if the specified field has not the required type.
* @throws IOException if there is no field of that name in the specified class.
*/
- private void setObjectField (Object obj, Class klass, String field_name,
+ private void setObjectField(Object obj, Class klass, String field_name,
String type_code, Object val) throws IOException, InvalidClassException
{
try
{
- Field f = getField (klass, field_name);
+ Field f = getField(klass, field_name);
ObjectStreamField of = new ObjectStreamField(field_name, f.getType());
if (of.getTypeString() == null ||
!of.getTypeString().equals(type_code))
throw new InvalidClassException("incompatible field type for " + klass.getName() + "." + field_name);
- f.set (obj, val);
+ f.set(obj, val);
}
catch (InvalidClassException e)
{
throw e;
}
catch (Exception _)
- {}
+ {
+ }
}
private static final int BUFFER_SIZE = 1024;
Index: java/io/ObjectOutputStream.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/ObjectOutputStream.java,v
retrieving revision 1.22
diff -u -b -B -r1.22 ObjectOutputStream.java
--- java/io/ObjectOutputStream.java 23 Dec 2003 22:06:01 -0000 1.22
+++ java/io/ObjectOutputStream.java 30 Dec 2003 15:49:35 -0000
@@ -132,18 +132,18 @@
*/
public ObjectOutputStream (OutputStream out) throws IOException
{
- realOutput = new DataOutputStream (out);
+ realOutput = new DataOutputStream(out);
blockData = new byte[ BUFFER_SIZE ];
blockDataCount = 0;
- blockDataOutput = new DataOutputStream (this);
- setBlockDataMode (true);
+ blockDataOutput = new DataOutputStream(this);
+ setBlockDataMode(true);
replacementEnabled = false;
isSerializing = false;
nextOID = baseWireHandle;
- OIDLookupTable = new Hashtable ();
+ OIDLookupTable = new Hashtable();
protocolVersion = defaultProtocolVersion;
useSubclassMethod = false;
- writeStreamHeader ();
+ writeStreamHeader();
}
/**
@@ -165,16 +165,16 @@
* @exception IOException Exception from underlying
* <code>OutputStream</code>.
*/
- public final void writeObject (Object obj) throws IOException
+ public final void writeObject(Object obj) throws IOException
{
if (useSubclassMethod)
{
- writeObjectOverride (obj);
+ writeObjectOverride(obj);
return;
}
boolean was_serializing = isSerializing;
- boolean old_mode = setBlockDataMode (false);
+ boolean old_mode = setBlockDataMode(false);
try
{
isSerializing = true;
@@ -185,49 +185,49 @@
{
if (obj == null)
{
- realOutput.writeByte (TC_NULL);
+ realOutput.writeByte(TC_NULL);
break;
}
- Integer handle = findHandle (obj);
+ Integer handle = findHandle(obj);
if (handle != null)
{
- realOutput.writeByte (TC_REFERENCE);
- realOutput.writeInt (handle.intValue ());
+ realOutput.writeByte(TC_REFERENCE);
+ realOutput.writeInt(handle.intValue());
break;
}
if (obj instanceof Class)
{
Class cl = (Class)obj;
- ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject (cl);
- assignNewHandle (obj);
- realOutput.writeByte (TC_CLASS);
+ ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject(cl);
+ assignNewHandle(obj);
+ realOutput.writeByte(TC_CLASS);
if (!osc.isProxyClass)
{
writeObject (osc);
}
else
{
- realOutput.writeByte (TC_PROXYCLASSDESC);
+ realOutput.writeByte(TC_PROXYCLASSDESC);
Class[] intfs = cl.getInterfaces();
realOutput.writeInt(intfs.length);
for (int i = 0; i < intfs.length; i++)
realOutput.writeUTF(intfs[i].getName());
- boolean oldmode = setBlockDataMode (true);
+ boolean oldmode = setBlockDataMode(true);
annotateProxyClass(cl);
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
realOutput.writeByte(TC_ENDBLOCKDATA);
- writeObject (osc.getSuper());
+ writeObject(osc.getSuper());
}
break;
}
if (obj instanceof ObjectStreamClass)
{
- writeClassDescriptor ((ObjectStreamClass) obj);
+ writeClassDescriptor((ObjectStreamClass) obj);
break;
}
@@ -247,7 +247,7 @@
// m can't be null by definition since an
// exception would have been thrown so a check
// for null is not needed.
- obj = m.invoke (obj, new Object[] {});
+ obj = m.invoke(obj, new Object[] {});
}
catch (NoSuchMethodException ignore)
{
@@ -261,7 +261,7 @@
}
if (replacementEnabled)
- obj = replaceObject (obj);
+ obj = replaceObject(obj);
replaceDone = true;
continue;
@@ -269,45 +269,45 @@
if (obj instanceof String)
{
- realOutput.writeByte (TC_STRING);
- assignNewHandle (obj);
- realOutput.writeUTF ((String)obj);
+ realOutput.writeByte(TC_STRING);
+ assignNewHandle(obj);
+ realOutput.writeUTF((String)obj);
break;
}
- Class clazz = obj.getClass ();
- ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject (clazz);
+ Class clazz = obj.getClass();
+ ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject(clazz);
if (osc == null)
- throw new NotSerializableException (clazz.getName ());
+ throw new NotSerializableException(clazz.getName());
if (clazz.isArray ())
{
- realOutput.writeByte (TC_ARRAY);
- writeObject (osc);
- assignNewHandle (obj);
- writeArraySizeAndElements (obj, clazz.getComponentType ());
+ realOutput.writeByte(TC_ARRAY);
+ writeObject(osc);
+ assignNewHandle(obj);
+ writeArraySizeAndElements(obj, clazz.getComponentType());
break;
}
- realOutput.writeByte (TC_OBJECT);
- writeObject (osc);
+ realOutput.writeByte(TC_OBJECT);
+ writeObject(osc);
if (replaceDone)
- assignNewHandle (replacedObject);
+ assignNewHandle(replacedObject);
else
- assignNewHandle (obj);
+ assignNewHandle(obj);
if (obj instanceof Externalizable)
{
if (protocolVersion == PROTOCOL_VERSION_2)
- setBlockDataMode (true);
+ setBlockDataMode(true);
- ((Externalizable)obj).writeExternal (this);
+ ((Externalizable)obj).writeExternal(this);
if (protocolVersion == PROTOCOL_VERSION_2)
{
- setBlockDataMode (false);
- realOutput.writeByte (TC_ENDBLOCKDATA);
+ setBlockDataMode(false);
+ realOutput.writeByte(TC_ENDBLOCKDATA);
}
break;
@@ -317,22 +317,22 @@
{
currentObject = obj;
ObjectStreamClass[] hierarchy =
- ObjectStreamClass.getObjectStreamClasses (clazz);
+ ObjectStreamClass.getObjectStreamClasses(clazz);
- for (int i=0; i < hierarchy.length; i++)
+ for (int i = 0; i < hierarchy.length; i++)
{
currentObjectStreamClass = hierarchy[i];
fieldsAlreadyWritten = false;
- if (currentObjectStreamClass.hasWriteMethod ())
+ if (currentObjectStreamClass.hasWriteMethod())
{
- setBlockDataMode (true);
- callWriteMethod (obj, currentObjectStreamClass);
- setBlockDataMode (false);
- realOutput.writeByte (TC_ENDBLOCKDATA);
+ setBlockDataMode(true);
+ callWriteMethod(obj, currentObjectStreamClass);
+ setBlockDataMode(false);
+ realOutput.writeByte(TC_ENDBLOCKDATA);
}
else
- writeFields (obj, currentObjectStreamClass);
+ writeFields(obj, currentObjectStreamClass);
}
currentObject = null;
@@ -341,7 +341,7 @@
break;
}
- throw new NotSerializableException (clazz.getName ());
+ throw new NotSerializableException(clazz.getName ());
} // end pseudo-loop
}
catch (ObjectStreamException ose)
@@ -351,100 +351,103 @@
}
catch (IOException e)
{
- realOutput.writeByte (TC_EXCEPTION);
- reset (true);
+ realOutput.writeByte(TC_EXCEPTION);
+ reset(true);
- setBlockDataMode (false);
+ setBlockDataMode(false);
try
{
- writeObject (e);
+ writeObject(e);
}
catch (IOException ioe)
{
- throw new StreamCorruptedException ("Exception " + ioe + " thrown while exception ("+e+") was being written to stream.");
+ throw new StreamCorruptedException
+ ("Exception " + ioe + " thrown while exception was being written to stream.");
}
reset (true);
+
}
finally
{
isSerializing = was_serializing;
- setBlockDataMode (old_mode);
+ setBlockDataMode(old_mode);
}
}
- protected void writeClassDescriptor (ObjectStreamClass osc) throws IOException
+ protected void writeClassDescriptor(ObjectStreamClass osc) throws IOException
{
- realOutput.writeByte (TC_CLASSDESC);
- realOutput.writeUTF (osc.getName ());
- realOutput.writeLong (osc.getSerialVersionUID ());
- assignNewHandle (osc);
+ realOutput.writeByte(TC_CLASSDESC);
+ realOutput.writeUTF(osc.getName());
+ realOutput.writeLong(osc.getSerialVersionUID());
+ assignNewHandle(osc);
- int flags = osc.getFlags ();
+ int flags = osc.getFlags();
if (protocolVersion == PROTOCOL_VERSION_2
- && osc.isExternalizable ())
+ && osc.isExternalizable())
flags |= SC_BLOCK_DATA;
- realOutput.writeByte (flags);
+ realOutput.writeByte(flags);
ObjectStreamField[] fields = osc.fields;
- realOutput.writeShort (fields.length);
+ realOutput.writeShort(fields.length);
ObjectStreamField field;
- for (int i=0; i < fields.length; i++)
+ for (int i = 0; i < fields.length; i++)
{
field = fields[i];
- realOutput.writeByte (field.getTypeCode ());
- realOutput.writeUTF (field.getName ());
+ realOutput.writeByte(field.getTypeCode ());
+ realOutput.writeUTF(field.getName ());
- if (! field.isPrimitive ())
- writeObject (field.getTypeString ());
+ if (! field.isPrimitive())
+ writeObject(field.getTypeString());
}
- boolean oldmode = setBlockDataMode (true);
- annotateClass (osc.forClass ());
- setBlockDataMode (oldmode);
- realOutput.writeByte (TC_ENDBLOCKDATA);
+ boolean oldmode = setBlockDataMode(true);
+ annotateClass(osc.forClass());
+ setBlockDataMode(oldmode);
+ realOutput.writeByte(TC_ENDBLOCKDATA);
- if (osc.isSerializable()
- || osc.isExternalizable())
- writeObject (osc.getSuper ());
+ if (osc.isSerializable() || osc.isExternalizable())
+ writeObject(osc.getSuper());
else
- writeObject (null);
+ writeObject(null);
}
/**
- Writes the current objects non-transient, non-static fields from
- the current class to the underlying output stream.
-
- This method is intended to be called from within a object's
- <code>private void writeObject (ObjectOutputStream)</code>
- method.
-
- @exception NotActiveException This method was called from a
- context other than from the current object's and current class's
- <code>private void writeObject (ObjectOutputStream)</code>
- method.
-
- @exception IOException Exception from underlying
- <code>OutputStream</code>.
+ * Writes the current objects non-transient, non-static fields from
+ * the current class to the underlying output stream.
+ *
+ * This method is intended to be called from within a object's
+ * <code>private void writeObject (ObjectOutputStream)</code>
+ * method.
+ *
+ * @exception NotActiveException This method was called from a
+ * context other than from the current object's and current class's
+ * <code>private void writeObject (ObjectOutputStream)</code>
+ * method.
+ *
+ * @exception IOException Exception from underlying
+ * <code>OutputStream</code>.
*/
- public void defaultWriteObject ()
+ public void defaultWriteObject()
throws IOException, NotActiveException
{
- markFieldsWritten ();
- writeFields (currentObject, currentObjectStreamClass);
+ markFieldsWritten();
+ writeFields(currentObject, currentObjectStreamClass);
}
- private void markFieldsWritten () throws IOException
+ private void markFieldsWritten() throws IOException
{
if (currentObject == null || currentObjectStreamClass == null)
- throw new NotActiveException ("defaultWriteObject called by non-active class and/or object");
+ throw new NotActiveException
+ ("defaultWriteObject called by non-active class and/or object");
if (fieldsAlreadyWritten)
- throw new IOException ("Only one of writeFields and defaultWriteObject may be called, and it may only be called once");
+ throw new IOException
+ ("Only one of putFields and defaultWriteObject may be called, and it may only be called once");
fieldsAlreadyWritten = true;
}
@@ -449,145 +452,146 @@
fieldsAlreadyWritten = true;
}
-
/**
- Resets stream to state equivalent to the state just after it was
- constructed.
-
- Causes all objects previously written to the stream to be
- forgotten. A notification of this reset is also written to the
- underlying stream.
-
- @exception IOException Exception from underlying
- <code>OutputStream</code> or reset called while serialization is
- in progress.
+ * Resets stream to state equivalent to the state just after it was
+ * constructed.
+ *
+ * Causes all objects previously written to the stream to be
+ * forgotten. A notification of this reset is also written to the
+ * underlying stream.
+ *
+ * @exception IOException Exception from underlying
+ * <code>OutputStream</code> or reset called while serialization is
+ * in progress.
*/
- public void reset () throws IOException
+ public void reset() throws IOException
{
- reset (false);
+ reset(false);
}
- private void reset (boolean internal) throws IOException
+ private void reset(boolean internal) throws IOException
{
if (!internal)
{
if (isSerializing)
- throw new IOException ("Reset called while serialization in progress");
+ throw new IOException("Reset called while serialization in progress");
- realOutput.writeByte (TC_RESET);
+ realOutput.writeByte(TC_RESET);
}
- clearHandles ();
+ clearHandles();
}
/**
- Informs this <code>ObjectOutputStream</code> to write data
- according to the specified protocol. There are currently two
- different protocols, specified by <code>PROTOCOL_VERSION_1</code>
- and <code>PROTOCOL_VERSION_2</code>. This implementation writes
- data using <code>PROTOCOL_VERSION_2</code> by default, as is done
- by the JDK 1.2.
-
- A non-portable method, <code>setDefaultProtocolVersion (int
- version)</code> is provided to change the default protocol
- version.
-
- For an explination of the differences beween the two protocols
- see XXX: the Java ObjectSerialization Specification.
-
- @exception IOException if <code>version</code> is not a valid
- protocol
-
- @see #setDefaultProtocolVersion(int)
+ * Informs this <code>ObjectOutputStream</code> to write data
+ * according to the specified protocol. There are currently two
+ * different protocols, specified by <code>PROTOCOL_VERSION_1</code>
+ * and <code>PROTOCOL_VERSION_2</code>. This implementation writes
+ * data using <code>PROTOCOL_VERSION_2</code> by default, as is done
+ * by the JDK 1.2.
+ *
+ * A non-portable method, <code>setDefaultProtocolVersion (int
+ * version)</code> is provided to change the default protocol
+ * version.
+ *
+ * For an explination of the differences beween the two protocols
+ * see XXX: the Java ObjectSerialization Specification.
+ *
+ * @exception IOException if <code>version</code> is not a valid
+ * protocol
+ *
+ * @see #setDefaultProtocolVersion(int)
*/
- public void useProtocolVersion (int version) throws IOException
+ public void useProtocolVersion(int version) throws IOException
{
if (version != PROTOCOL_VERSION_1 && version != PROTOCOL_VERSION_2)
- throw new IOException ("Invalid protocol version requested.");
+ throw new IOException("Invalid protocol version requested.");
protocolVersion = version;
}
/**
- <em>GNU $classpath specific</em>
-
- Changes the default stream protocol used by all
- <code>ObjectOutputStream</code>s. There are currently two
- different protocols, specified by <code>PROTOCOL_VERSION_1</code>
- and <code>PROTOCOL_VERSION_2</code>. The default default is
- <code>PROTOCOL_VERSION_1</code>.
-
- @exception IOException if <code>version</code> is not a valid
- protocol
-
- @see #useProtocolVersion(int)
+ * <em>GNU $classpath specific</em>
+ *
+ * Changes the default stream protocol used by all
+ * <code>ObjectOutputStream</code>s. There are currently two
+ * different protocols, specified by <code>PROTOCOL_VERSION_1</code>
+ * and <code>PROTOCOL_VERSION_2</code>. The default default is
+ * <code>PROTOCOL_VERSION_1</code>.
+ *
+ * @exception IOException if <code>version</code> is not a valid
+ * protocol
+ *
+ * @see #useProtocolVersion(int)
*/
- public static void setDefaultProtocolVersion (int version)
+ public static void setDefaultProtocolVersion(int version)
throws IOException
{
if (version != PROTOCOL_VERSION_1 && version != PROTOCOL_VERSION_2)
- throw new IOException ("Invalid protocol version requested.");
+ throw new IOException("Invalid protocol version requested.");
defaultProtocolVersion = version;
}
/**
- An empty hook that allows subclasses to write extra information
- about classes to the stream. This method is called the first
- time each class is seen, and after all of the standard
- information about the class has been written.
-
- @exception IOException Exception from underlying
- <code>OutputStream</code>.
-
- @see ObjectInputStream#resolveClass(java.io.ObjectStreamClass)
+ * An empty hook that allows subclasses to write extra information
+ * about classes to the stream. This method is called the first
+ * time each class is seen, and after all of the standard
+ * information about the class has been written.
+ *
+ * @exception IOException Exception from underlying
+ * <code>OutputStream</code>.
+ *
+ * @see ObjectInputStream#resolveClass(java.io.ObjectStreamClass)
*/
- protected void annotateClass (Class cl) throws IOException
- {}
+ protected void annotateClass(Class cl) throws IOException
+ {
+ }
protected void annotateProxyClass(Class cl) throws IOException
- {}
+ {
+ }
/**
- Allows subclasses to replace objects that are written to the
- stream with other objects to be written in their place. This
- method is called the first time each object is encountered
- (modulo reseting of the stream).
-
- This method must be enabled before it will be called in the
- serialization process.
-
- @exception IOException Exception from underlying
- <code>OutputStream</code>.
-
- @see #enableReplaceObject(boolean)
+ * Allows subclasses to replace objects that are written to the
+ * stream with other objects to be written in their place. This
+ * method is called the first time each object is encountered
+ * (modulo reseting of the stream).
+ *
+ * This method must be enabled before it will be called in the
+ * serialization process.
+ *
+ * @exception IOException Exception from underlying
+ * <code>OutputStream</code>.
+ *
+ * @see #enableReplaceObject(boolean)
*/
- protected Object replaceObject (Object obj) throws IOException
+ protected Object replaceObject(Object obj) throws IOException
{
return obj;
}
/**
- If <code>enable</code> is <code>true</code> and this object is
- trusted, then <code>replaceObject (Object)</code> will be called
- in subsequent calls to <code>writeObject (Object)</code>.
- Otherwise, <code>replaceObject (Object)</code> will not be called.
-
- @exception SecurityException This class is not trusted.
+ * If <code>enable</code> is <code>true</code> and this object is
+ * trusted, then <code>replaceObject (Object)</code> will be called
+ * in subsequent calls to <code>writeObject (Object)</code>.
+ * Otherwise, <code>replaceObject (Object)</code> will not be called.
+ *
+ * @exception SecurityException This class is not trusted.
*/
- protected boolean enableReplaceObject (boolean enable)
+ protected boolean enableReplaceObject(boolean enable)
throws SecurityException
{
if (enable)
{
- SecurityManager sm = System.getSecurityManager ();
+ SecurityManager sm = System.getSecurityManager();
if (sm != null)
- sm.checkPermission (new SerializablePermission ("enableSubstitution"));
+ sm.checkPermission(new SerializablePermission("enableSubstitution"));
}
boolean old_val = replacementEnabled;
@@ -597,20 +601,18 @@
/**
- Writes stream magic and stream version information to the
- underlying stream.
-
- @exception IOException Exception from underlying
- <code>OutputStream</code>.
+ * Writes stream magic and stream version information to the
+ * underlying stream.
+ *
+ * @exception IOException Exception from underlying
+ * <code>OutputStream</code>.
*/
- protected void writeStreamHeader () throws IOException
+ protected void writeStreamHeader() throws IOException
{
- realOutput.writeShort (STREAM_MAGIC);
- realOutput.writeShort (STREAM_VERSION);
+ realOutput.writeShort(STREAM_MAGIC);
+ realOutput.writeShort(STREAM_VERSION);
}
-
-
/**
* Protected constructor that allows subclasses to override
* serialization. This constructor should be called by subclasses
@@ -622,11 +624,11 @@
*
* @see #writeObjectOverride(Object)
*/
- protected ObjectOutputStream () throws IOException, SecurityException
+ protected ObjectOutputStream() throws IOException, SecurityException
{
SecurityManager sec_man = System.getSecurityManager ();
if (sec_man != null)
- sec_man.checkPermission (SUBCLASS_IMPLEMENTATION_PERMISSION);
+ sec_man.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
useSubclassMethod = true;
}
@@ -643,10 +645,11 @@
* @exception NotActiveException Subclass has arranged for this
* method to be called, but did not implement this method.
*/
- protected void writeObjectOverride (Object obj) throws NotActiveException,
+ protected void writeObjectOverride(Object obj) throws NotActiveException,
IOException
{
- throw new NotActiveException ("Subclass of ObjectOutputStream must implement writeObjectOverride");
+ throw new NotActiveException
+ ("Subclass of ObjectOutputStream must implement writeObjectOverride");
}
@@ -658,48 +661,48 @@
if (writeDataAsBlocks)
{
if (blockDataCount == BUFFER_SIZE)
- drain ();
+ drain();
blockData[ blockDataCount++ ] = (byte)data;
}
else
- realOutput.write (data);
+ realOutput.write(data);
}
/**
* @see DataOutputStream#write(byte[])
*/
- public void write (byte[] b) throws IOException
+ public void write(byte[] b) throws IOException
{
- write (b, 0, b.length);
+ write(b, 0, b.length);
}
/**
* @see DataOutputStream#write(byte[],int,int)
*/
- public void write (byte[] b, int off, int len) throws IOException
+ public void write(byte[] b, int off, int len) throws IOException
{
if (writeDataAsBlocks)
{
if (len < 0)
- throw new IndexOutOfBoundsException ();
+ throw new IndexOutOfBoundsException();
if (blockDataCount + len < BUFFER_SIZE)
{
- System.arraycopy (b, off, blockData, blockDataCount, len);
+ System.arraycopy(b, off, blockData, blockDataCount, len);
blockDataCount += len;
}
else
{
- drain ();
- writeBlockDataHeader (len);
- realOutput.write (b, off, len);
+ drain();
+ writeBlockDataHeader(len);
+ realOutput.write(b, off, len);
}
}
else
- realOutput.write (b, off, len);
+ realOutput.write(b, off, len);
}
@@ -708,8 +711,8 @@
*/
public void flush () throws IOException
{
- drain ();
- realOutput.flush ();
+ drain();
+ realOutput.flush();
}
@@ -720,14 +723,14 @@
* @exception IOException Exception from underlying
* <code>OutputStream</code>.
*/
- protected void drain () throws IOException
+ protected void drain() throws IOException
{
if (blockDataCount == 0)
return;
if (writeDataAsBlocks)
- writeBlockDataHeader (blockDataCount);
- realOutput.write (blockData, 0, blockDataCount);
+ writeBlockDataHeader(blockDataCount);
+ realOutput.write(blockData, 0, blockDataCount);
blockDataCount = 0;
}
@@ -735,28 +738,28 @@
/**
* @see java.io.DataOutputStream#close ()
*/
- public void close () throws IOException
+ public void close() throws IOException
{
- flush ();
- realOutput.close ();
+ flush();
+ realOutput.close();
}
/**
* @see java.io.DataOutputStream#writeBoolean (boolean)
*/
- public void writeBoolean (boolean data) throws IOException
+ public void writeBoolean(boolean data) throws IOException
{
- blockDataOutput.writeBoolean (data);
+ blockDataOutput.writeBoolean(data);
}
/**
* @see java.io.DataOutputStream#writeByte (int)
*/
- public void writeByte (int data) throws IOException
+ public void writeByte(int data) throws IOException
{
- blockDataOutput.writeByte (data);
+ blockDataOutput.writeByte(data);
}
@@ -765,79 +768,79 @@
*/
public void writeShort (int data) throws IOException
{
- blockDataOutput.writeShort (data);
+ blockDataOutput.writeShort(data);
}
/**
* @see java.io.DataOutputStream#writeChar (int)
*/
- public void writeChar (int data) throws IOException
+ public void writeChar(int data) throws IOException
{
- blockDataOutput.writeChar (data);
+ blockDataOutput.writeChar(data);
}
/**
* @see java.io.DataOutputStream#writeInt (int)
*/
- public void writeInt (int data) throws IOException
+ public void writeInt(int data) throws IOException
{
- blockDataOutput.writeInt (data);
+ blockDataOutput.writeInt(data);
}
/**
* @see java.io.DataOutputStream#writeLong (long)
*/
- public void writeLong (long data) throws IOException
+ public void writeLong(long data) throws IOException
{
- blockDataOutput.writeLong (data);
+ blockDataOutput.writeLong(data);
}
/**
* @see java.io.DataOutputStream#writeFloat (float)
*/
- public void writeFloat (float data) throws IOException
+ public void writeFloat(float data) throws IOException
{
- blockDataOutput.writeFloat (data);
+ blockDataOutput.writeFloat(data);
}
/**
* @see java.io.DataOutputStream#writeDouble (double)
*/
- public void writeDouble (double data) throws IOException
+ public void writeDouble(double data) throws IOException
{
- blockDataOutput.writeDouble (data);
+ blockDataOutput.writeDouble(data);
}
/**
* @see java.io.DataOutputStream#writeBytes (java.lang.String)
*/
- public void writeBytes (String data) throws IOException
+ public void writeBytes(String data) throws IOException
{
- blockDataOutput.writeBytes (data);
+ blockDataOutput.writeBytes(data);
}
/**
* @see java.io.DataOutputStream#writeChars (java.lang.String)
*/
- public void writeChars (String data) throws IOException
+ public void writeChars(String data) throws IOException
{
- dataOutput.writeChars (data);
+ dataOutput.writeChars(data);
}
/**
* @see java.io.DataOutputStream#writeUTF (java.lang.String)
*/
- public void writeUTF (String data) throws IOException
+ public void writeUTF(String data) throws IOException
{
- dataOutput.writeUTF (data);
+ dataOutput.writeUTF(data);
}
@@ -865,7 +868,7 @@
public abstract void write (ObjectOutput out) throws IOException;
}
- public PutField putFields () throws IOException
+ public PutField putFields() throws IOException
{
if (currentPutField == null)
{
@@ -1008,183 +1011,184 @@
}
- public void writeFields () throws IOException
+ public void writeFields() throws IOException
{
if (currentPutField == null)
- throw new NotActiveException ("writeFields can only be called after putFields has been called");
+ throw new NotActiveException("writeFields can only be called after putFields has been called");
// putFields may be called more than once, but not writeFields.
markFieldsWritten();
- currentPutField.write (this);
+ currentPutField.write(this);
currentPutField = null;
}
// write out the block-data buffer, picking the correct header
// depending on the size of the buffer
- private void writeBlockDataHeader (int size) throws IOException
+ private void writeBlockDataHeader(int size) throws IOException
{
if (size < 256)
{
- realOutput.writeByte (TC_BLOCKDATA);
- realOutput.write (size);
+ realOutput.writeByte(TC_BLOCKDATA);
+ realOutput.write(size);
}
else
{
- realOutput.writeByte (TC_BLOCKDATALONG);
- realOutput.writeInt (size);
+ realOutput.writeByte(TC_BLOCKDATALONG);
+ realOutput.writeInt(size);
}
}
// lookup the handle for OBJ, return null if OBJ doesn't have a
// handle yet
- private Integer findHandle (Object obj)
+ private Integer findHandle(Object obj)
{
- return (Integer)OIDLookupTable.get (new ObjectIdentityWrapper (obj));
+ return (Integer)OIDLookupTable.get(new ObjectIdentityWrapper(obj));
}
// assigns the next availible handle to OBJ
- private int assignNewHandle (Object obj)
+ private int assignNewHandle(Object obj)
{
- OIDLookupTable.put (new ObjectIdentityWrapper (obj),
- new Integer (nextOID));
+ OIDLookupTable.put(new ObjectIdentityWrapper(obj),
+ new Integer(nextOID));
return nextOID++;
}
// resets mapping from objects to handles
- private void clearHandles ()
+ private void clearHandles()
{
nextOID = baseWireHandle;
- OIDLookupTable.clear ();
+ OIDLookupTable.clear();
}
// write out array size followed by each element of the array
- private void writeArraySizeAndElements (Object array, Class clazz)
+ private void writeArraySizeAndElements(Object array, Class clazz)
throws IOException
{
- int length = Array.getLength (array);
+ int length = Array.getLength(array);
- if (clazz.isPrimitive ())
+ if (clazz.isPrimitive())
{
if (clazz == Boolean.TYPE)
{
boolean[] cast_array = (boolean[])array;
realOutput.writeInt (length);
- for (int i=0; i < length; i++)
- realOutput.writeBoolean (cast_array[i]);
+ for (int i = 0; i < length; i++)
+ realOutput.writeBoolean(cast_array[i]);
return;
}
if (clazz == Byte.TYPE)
{
byte[] cast_array = (byte[])array;
- realOutput.writeInt (length);
+ realOutput.writeInt(length);
realOutput.write(cast_array, 0, length);
return;
}
if (clazz == Character.TYPE)
{
char[] cast_array = (char[])array;
- realOutput.writeInt (length);
- for (int i=0; i < length; i++)
- realOutput.writeChar (cast_array[i]);
+ realOutput.writeInt(length);
+ for (int i = 0; i < length; i++)
+ realOutput.writeChar(cast_array[i]);
return;
}
if (clazz == Double.TYPE)
{
double[] cast_array = (double[])array;
- realOutput.writeInt (length);
- for (int i=0; i < length; i++)
- realOutput.writeDouble (cast_array[i]);
+ realOutput.writeInt(length);
+ for (int i = 0; i < length; i++)
+ realOutput.writeDouble(cast_array[i]);
return;
}
if (clazz == Float.TYPE)
{
float[] cast_array = (float[])array;
- realOutput.writeInt (length);
- for (int i=0; i < length; i++)
- realOutput.writeFloat (cast_array[i]);
+ realOutput.writeInt(length);
+ for (int i = 0; i < length; i++)
+ realOutput.writeFloat(cast_array[i]);
return;
}
if (clazz == Integer.TYPE)
{
int[] cast_array = (int[])array;
- realOutput.writeInt (length);
- for (int i=0; i < length; i++)
- realOutput.writeInt (cast_array[i]);
+ realOutput.writeInt(length);
+ for (int i = 0; i < length; i++)
+ realOutput.writeInt(cast_array[i]);
return;
}
if (clazz == Long.TYPE)
{
long[] cast_array = (long[])array;
realOutput.writeInt (length);
- for (int i=0; i < length; i++)
- realOutput.writeLong (cast_array[i]);
+ for (int i = 0; i < length; i++)
+ realOutput.writeLong(cast_array[i]);
return;
}
if (clazz == Short.TYPE)
{
short[] cast_array = (short[])array;
realOutput.writeInt (length);
- for (int i=0; i < length; i++)
- realOutput.writeShort (cast_array[i]);
+ for (int i = 0; i < length; i++)
+ realOutput.writeShort(cast_array[i]);
return;
}
}
else
{
Object[] cast_array = (Object[])array;
- realOutput.writeInt (length);
- for (int i=0; i < length; i++)
- writeObject (cast_array[i]);
+ realOutput.writeInt(length);
+ for (int i = 0; i < length; i++)
+ writeObject(cast_array[i]);
}
}
// writes out FIELDS of OBJECT for the specified ObjectStreamClass.
// FIELDS are already in canonical order.
- private void writeFields (Object obj, ObjectStreamClass osc)
+ private void writeFields(Object obj, ObjectStreamClass osc)
throws IOException
{
ObjectStreamField[] fields = osc.fields;
- boolean oldmode = setBlockDataMode (false);
+ boolean oldmode = setBlockDataMode(false);
String field_name;
Class type;
- for (int i=0; i < fields.length; i++)
+
+ for (int i = 0; i < fields.length; i++)
{
- field_name = fields[i].getName ();
- type = fields[i].getType ();
+ field_name = fields[i].getName();
+ type = fields[i].getType();
if (type == Boolean.TYPE)
- realOutput.writeBoolean (getBooleanField (obj, osc.forClass(), field_name));
+ realOutput.writeBoolean(getBooleanField(obj, osc.forClass(), field_name));
else if (type == Byte.TYPE)
- realOutput.writeByte (getByteField (obj, osc.forClass(), field_name));
+ realOutput.writeByte(getByteField(obj, osc.forClass(), field_name));
else if (type == Character.TYPE)
- realOutput.writeChar (getCharField (obj, osc.forClass(), field_name));
+ realOutput.writeChar(getCharField(obj, osc.forClass(), field_name));
else if (type == Double.TYPE)
- realOutput.writeDouble (getDoubleField (obj, osc.forClass(), field_name));
+ realOutput.writeDouble(getDoubleField(obj, osc.forClass(), field_name));
else if (type == Float.TYPE)
- realOutput.writeFloat (getFloatField (obj, osc.forClass(), field_name));
+ realOutput.writeFloat(getFloatField(obj, osc.forClass(), field_name));
else if (type == Integer.TYPE)
- realOutput.writeInt (getIntField (obj, osc.forClass(), field_name));
+ realOutput.writeInt(getIntField(obj, osc.forClass(), field_name));
else if (type == Long.TYPE)
- realOutput.writeLong (getLongField (obj, osc.forClass(), field_name));
+ realOutput.writeLong(getLongField(obj, osc.forClass(), field_name));
else if (type == Short.TYPE)
- realOutput.writeShort (getShortField (obj, osc.forClass(), field_name));
+ realOutput.writeShort(getShortField(obj, osc.forClass(), field_name));
else
- writeObject (getObjectField (obj, osc.forClass(), field_name,
+ writeObject(getObjectField(obj, osc.forClass(), field_name,
fields[i].getTypeString ()));
}
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
}
// Toggles writing primitive data to block-data buffer.
- private boolean setBlockDataMode (boolean on) throws IOException
+ private boolean setBlockDataMode(boolean on) throws IOException
{
if (on == writeDataAsBlocks)
return on;
@@ -1202,16 +1206,16 @@
}
- private void callWriteMethod (Object obj, ObjectStreamClass osc)
+ private void callWriteMethod(Object obj, ObjectStreamClass osc)
throws IOException
{
Class klass = osc.forClass();
try
{
Class classArgs[] = {ObjectOutputStream.class};
- Method m = getMethod (klass, "writeObject", classArgs);
+ Method m = getMethod(klass, "writeObject", classArgs);
Object args[] = {this};
- m.invoke (obj, args);
+ m.invoke(obj, args);
}
catch (NoSuchMethodException nsme)
{
@@ -1227,7 +1231,7 @@
throw (IOException) exception;
IOException ioe
- = new IOException ("Exception thrown from writeObject() on " +
+ = new IOException("Exception thrown from writeObject() on " +
klass + ": " + exception.getClass().getName());
ioe.initCause(exception);
throw ioe;
@@ -1235,25 +1239,25 @@
catch (Exception x)
{
IOException ioe
- = new IOException ("Failure invoking writeObject() on " +
+ = new IOException("Failure invoking writeObject() on " +
klass + ": " + x.getClass().getName());
ioe.initCause(x);
throw ioe;
}
}
- private boolean getBooleanField (Object obj, Class klass, String field_name)
+ private boolean getBooleanField(Object obj, Class klass, String field_name)
throws IOException
{
try
{
- Field f = getField (klass, field_name);
- boolean b = f.getBoolean (obj);
+ Field f = getField(klass, field_name);
+ boolean b = f.getBoolean(obj);
return b;
}
catch (Exception _)
{
- throw new IOException ("Unexpected Exception "+_);
+ throw new IOException("Unexpected exception " + _);
}
}
@@ -1268,7 +1272,7 @@
}
catch (Exception _)
{
- throw new IOException ("Unexpected Exception "+_);
+ throw new IOException("Unexpected exception " + _);
}
}
@@ -1283,7 +1287,7 @@
}
catch (Exception _)
{
- throw new IOException ("Unexpected Exception "+_);
+ throw new IOException("Unexpected exception " + _);
}
}
@@ -1298,7 +1302,7 @@
}
catch (Exception _)
{
- throw new IOException ("Unexpected Exception "+_);
+ throw new IOException("Unexpected exception " + _);
}
}
@@ -1313,7 +1317,7 @@
}
catch (Exception _)
{
- throw new IOException ("Unexpected Exception "+_);
+ throw new IOException("Unexpected exception " + _);
}
}
@@ -1328,7 +1332,7 @@
}
catch (Exception _)
{
- throw new IOException ("Unexpected Exception "+_);
+ throw new IOException("Unexpected exception " + _);
}
}
@@ -1343,7 +1347,7 @@
}
catch (Exception _)
{
- throw new IOException ("Unexpected Exception "+_);
+ throw new IOException("Unexpected exception " + _);
}
}
@@ -1358,7 +1362,7 @@
}
catch (Exception _)
{
- throw new IOException ("Unexpected Exception "+_);
+ throw new IOException("Unexpected exception " + _);
}
}
@@ -1372,9 +1376,9 @@
// FIXME: We should check the type_code here
return o;
}
- catch (Exception _)
+ catch (Exception e)
{
- throw new IOException ("Unexpected Exception "+_);
+ throw new IOException ();
}
}
@@ -1434,7 +1438,7 @@
{
if (Configuration.INIT_LOAD_LIBRARY)
{
- System.loadLibrary ("javaio");
+ System.loadLibrary("javaio");
}
}
}
Index: java/io/ObjectStreamClass.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/ObjectStreamClass.java,v
retrieving revision 1.17
diff -u -b -B -r1.17 ObjectStreamClass.java
--- java/io/ObjectStreamClass.java 23 Dec 2003 22:06:01 -0000 1.17
+++ java/io/ObjectStreamClass.java 30 Dec 2003 15:49:35 -0000
@@ -2,39 +2,39 @@
about serialized objects.
Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
-This file is part of GNU Classpath.
+ This file is part of GNU Classpath.
-GNU Classpath is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-GNU Classpath is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU Classpath; see the file COPYING. If not, write to the
-Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-02111-1307 USA.
-
-Linking this library statically or dynamically with other modules is
-making a combined work based on this library. Thus, the terms and
-conditions of the GNU General Public License cover the whole
-combination.
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent
-modules, and to copy and distribute the resulting executable under
-terms of your choice, provided that you also meet, for each linked
-independent module, the terms and conditions of the license of that
-module. An independent module is a module which is not derived from
-or based on this library. If you modify this library, you may extend
-this exception to your version of the library, but you are not
-obligated to do so. If you do not wish to do so, delete this
-exception statement from your version. */
+ GNU Classpath is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ GNU Classpath is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNU Classpath; see the file COPYING. If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library. Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module. An independent module is a module which is not derived from
+ or based on this library. If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so. If you do not wish to do so, delete this
+ exception statement from your version. */
package java.io;
@@ -61,23 +61,23 @@
public class ObjectStreamClass implements Serializable
{
/**
- Returns the <code>ObjectStreamClass</code> for <code>cl</code>.
- If <code>cl</code> is null, or is not <code>Serializable</code>,
- null is returned. <code>ObjectStreamClass</code>'s are memorized;
- later calls to this method with the same class will return the
- same <code>ObjectStreamClass</code> object and no recalculation
- will be done.
-
- @see java.io.Serializable
+ * Returns the <code>ObjectStreamClass</code> for <code>cl</code>.
+ * If <code>cl</code> is null, or is not <code>Serializable</code>,
+ * null is returned. <code>ObjectStreamClass</code>'s are memorized;
+ * later calls to this method with the same class will return the
+ * same <code>ObjectStreamClass</code> object and no recalculation
+ * will be done.
+ *
+ * @see java.io.Serializable
*/
- public static ObjectStreamClass lookup (Class cl)
+ public static ObjectStreamClass lookup(Class cl)
{
if (cl == null)
return null;
- if (! (Serializable.class).isAssignableFrom (cl))
+ if (! (Serializable.class).isAssignableFrom(cl))
return null;
- return lookupForClassObject (cl);
+ return lookupForClassObject(cl);
}
/**
@@ -85,57 +85,57 @@
* we have a java.lang.Class object C for class A, though A is not
* serializable, but it's okay to serialize C.
*/
- static ObjectStreamClass lookupForClassObject (Class cl)
+ static ObjectStreamClass lookupForClassObject(Class cl)
{
if (cl == null)
return null;
- ObjectStreamClass osc = (ObjectStreamClass)classLookupTable.get (cl);
+ ObjectStreamClass osc = (ObjectStreamClass) classLookupTable.get(cl);
if (osc != null)
return osc;
else
{
- osc = new ObjectStreamClass (cl);
- classLookupTable.put (cl, osc);
+ osc = new ObjectStreamClass(cl);
+ classLookupTable.put(cl, osc);
return osc;
}
}
/**
- Returns the name of the class that this
- <code>ObjectStreamClass</code> represents.
+ * Returns the name of the class that this
+ * <code>ObjectStreamClass</code> represents.
*/
- public String getName ()
+ public String getName()
{
return name;
}
/**
- Returns the class that this <code>ObjectStreamClass</code>
- represents. Null could be returned if this
- <code>ObjectStreamClass</code> was read from an
- <code>ObjectInputStream</code> and the class it represents cannot
- be found or loaded.
-
- @see java.io.ObjectInputStream
+ * Returns the class that this <code>ObjectStreamClass</code>
+ * represents. Null could be returned if this
+ * <code>ObjectStreamClass</code> was read from an
+ * <code>ObjectInputStream</code> and the class it represents cannot
+ * be found or loaded.
+ *
+ * @see java.io.ObjectInputStream
*/
- public Class forClass ()
+ public Class forClass()
{
return clazz;
}
/**
- Returns the serial version stream-unique identifier for the class
- represented by this <code>ObjectStreamClass</code>. This SUID is
- either defined by the class as <code>static final long
- serialVersionUID</code> or is calculated as specified in
- Javasoft's "Object Serialization Specification" XXX: add reference
+ * Returns the serial version stream-unique identifier for the class
+ * represented by this <code>ObjectStreamClass</code>. This SUID is
+ * either defined by the class as <code>static final long
+ * serialVersionUID</code> or is calculated as specified in
+ * Javasoft's "Object Serialization Specification" XXX: add reference
*/
- public long getSerialVersionUID ()
+ public long getSerialVersionUID()
{
return uid;
}
@@ -145,10 +145,10 @@
// of the class represented by this ObjectStreamClass. The Fields
// are sorted by name.
// XXX doc
- public ObjectStreamField[] getFields ()
+ public ObjectStreamField[] getFields()
{
ObjectStreamField[] copy = new ObjectStreamField[ fields.length ];
- System.arraycopy (fields, 0, copy, 0, fields.length);
+ System.arraycopy(fields, 0, copy, 0, fields.length);
return copy;
}
@@ -158,8 +158,8 @@
// primitiveness.
public ObjectStreamField getField (String name)
{
- for (int i=0; i < fields.length; i++)
- if (fields[i].getName ().equals (name))
+ for (int i = 0; i < fields.length; i++)
+ if (fields[i].getName().equals(name))
return fields[i];
return null;
}
@@ -174,7 +174,7 @@
* @see #getSerialVersionUID()
* @see #getName()
*/
- public String toString ()
+ public String toString()
{
return "java.io.ObjectStreamClass< " + name + ", " + uid + " >";
}
@@ -187,7 +187,7 @@
//
// This method is used by the class to override default
// serialization behavior.
- boolean hasWriteMethod ()
+ boolean hasWriteMethod()
{
return (flags & ObjectStreamConstants.SC_WRITE_METHOD) != 0;
}
@@ -200,12 +200,12 @@
//
// This method is used by the class to override default
// serialization behavior.
- boolean hasReadMethod ()
+ boolean hasReadMethod()
{
try
{
Class[] readObjectParams = { ObjectInputStream.class };
- forClass ().getDeclaredMethod ("readObject", readObjectParams);
+ forClass().getDeclaredMethod("readObject", readObjectParams);
return true;
}
catch (NoSuchMethodException e)
@@ -217,7 +217,7 @@
// Returns true iff the class that this ObjectStreamClass represents
// implements Serializable but does *not* implement Externalizable.
- boolean isSerializable ()
+ boolean isSerializable()
{
return (flags & ObjectStreamConstants.SC_SERIALIZABLE) != 0;
}
@@ -225,7 +225,7 @@
// Returns true iff the class that this ObjectStreamClass represents
// implements Externalizable.
- boolean isExternalizable ()
+ boolean isExternalizable()
{
return (flags & ObjectStreamConstants.SC_EXTERNALIZABLE) != 0;
}
@@ -235,7 +235,7 @@
// class that is the superclass of the class this
// <code>ObjectStreamClass</code> represents. If the superclass is
// not Serializable, null is returned.
- ObjectStreamClass getSuper ()
+ ObjectStreamClass getSuper()
{
return superClass;
}
@@ -245,27 +245,27 @@
// classes of CLAZZ and CLAZZ itself in order from most super to
// CLAZZ. ObjectStreamClass[0] is the highest superclass of CLAZZ
// that is serializable.
- static ObjectStreamClass[] getObjectStreamClasses (Class clazz)
+ static ObjectStreamClass[] getObjectStreamClasses(Class clazz)
{
- ObjectStreamClass osc = ObjectStreamClass.lookup (clazz);
+ ObjectStreamClass osc = ObjectStreamClass.lookup(clazz);
if (osc == null)
return new ObjectStreamClass[0];
else
{
- Vector oscs = new Vector ();
+ Vector oscs = new Vector();
while (osc != null)
{
oscs.addElement (osc);
- osc = osc.getSuper ();
+ osc = osc.getSuper();
}
- int count = oscs.size ();
+ int count = oscs.size();
ObjectStreamClass[] sorted_oscs = new ObjectStreamClass[ count ];
for (int i = count - 1; i >= 0; i--)
- sorted_oscs[ count - i - 1 ] = (ObjectStreamClass)oscs.elementAt (i);
+ sorted_oscs[ count - i - 1 ] = (ObjectStreamClass) oscs.elementAt(i);
return sorted_oscs;
}
@@ -276,13 +276,13 @@
// properties of the class represented by this ObjectStreamClass.
// The bit-flags that could be present are those defined in
// ObjectStreamConstants that begin with `SC_'
- int getFlags ()
+ int getFlags()
{
return flags;
}
- ObjectStreamClass (String name, long uid, byte flags,
+ ObjectStreamClass(String name, long uid, byte flags,
ObjectStreamField[] fields)
{
this.name = name;
@@ -302,11 +302,11 @@
* @throws InvalidClassException if an incompatibility between computed UID and
* already set UID is found.
*/
- void setClass (Class cl, ObjectStreamClass superClass) throws InvalidClassException
+ void setClass(Class cl, ObjectStreamClass superClass) throws InvalidClassException
{
this.clazz = cl;
- long class_uid = getClassUID (cl);
+ long class_uid = getClassUID(cl);
if (uid == 0)
uid = class_uid;
else
@@ -322,9 +322,9 @@
}
}
- isProxyClass = clazz != null && Proxy.isProxyClass (clazz);
+ isProxyClass = clazz != null && Proxy.isProxyClass(clazz);
this.superClass = superClass;
- calculateOffsets ();
+ calculateOffsets();
try
{
@@ -346,7 +346,8 @@
i = 0; j = 0; k = 0;
while (i < fields.length && j < exportedFields.length)
{
- int comp = fields[i].getName().compareTo (exportedFields[j].getName());
+ int comp = fields[i].getName().compareTo(exportedFields[j].getName());
+
if (comp < 0)
{
newFieldList[k] = fields[i];
@@ -366,8 +367,9 @@
}
else
{
- if (!fields[i].getType().equals (exportedFields[j].getType()))
- throw new InvalidClassException ("serialPersistentFields must be compatible with" +
+ if (!fields[i].getType().equals(exportedFields[j].getType()))
+ throw new InvalidClassException
+ ("serialPersistentFields must be compatible with" +
" imported fields (about " + fields[i].getName() + ")");
newFieldList[k] = fields[i];
fields[i].setPersistent(true);
@@ -378,7 +380,7 @@
}
if (i < fields.length)
- for (; i < fields.length; i++, k++)
+ for (;i<fields.length;i++,k++)
{
fields[i].setPersistent(false);
fields[i].setToSet(false);
@@ -386,7 +388,7 @@
}
else
if (j < exportedFields.length)
- for (; j < exportedFields.length; j++, k++)
+ for (;j<exportedFields.length;j++,k++)
{
exportedFields[j].setPersistent(true);
exportedFields[j].setToSet(false);
@@ -394,7 +396,7 @@
}
fields = new ObjectStreamField[k];
- System.arraycopy (newFieldList, 0, fields, 0, k);
+ System.arraycopy(newFieldList, 0, fields, 0, k);
}
catch (NoSuchFieldException ignore)
{
@@ -411,8 +413,7 @@
superClass = osc;
}
-
- void calculateOffsets ()
+ void calculateOffsets()
{
int i;
ObjectStreamField field;
@@ -422,11 +423,11 @@
{
field = fields[i];
- if (! field.isPrimitive ())
+ if (! field.isPrimitive())
break;
- field.setOffset (primFieldSize);
- switch (field.getTypeCode ())
+ field.setOffset(primFieldSize);
+ switch (field.getTypeCode())
{
case 'B':
case 'Z':
@@ -448,57 +449,58 @@
}
for (objectFieldCount = 0; i < fcount; ++ i)
- fields[i].setOffset (objectFieldCount++);
+ fields[i].setOffset(objectFieldCount++);
}
- private ObjectStreamClass (Class cl)
+ private ObjectStreamClass(Class cl)
{
uid = 0;
flags = 0;
- isProxyClass = Proxy.isProxyClass (cl);
+ isProxyClass = Proxy.isProxyClass(cl);
clazz = cl;
- name = cl.getName ();
- setFlags (cl);
- setFields (cl);
+ name = cl.getName();
+ setFlags(cl);
+ setFields(cl);
// to those class nonserializable, its uid field is 0
- if ( (Serializable.class).isAssignableFrom (cl) && !isProxyClass)
- uid = getClassUID (cl);
- superClass = lookup (cl.getSuperclass ());
+ if ( (Serializable.class).isAssignableFrom(cl) && !isProxyClass)
+ uid = getClassUID(cl);
+ superClass = lookup(cl.getSuperclass());
}
// Sets bits in flags according to features of CL.
- private void setFlags (Class cl)
+ private void setFlags(Class cl)
{
- if ((java.io.Externalizable.class).isAssignableFrom (cl))
+ if ((java.io.Externalizable.class).isAssignableFrom(cl))
flags |= ObjectStreamConstants.SC_EXTERNALIZABLE;
- else if ((java.io.Serializable.class).isAssignableFrom (cl))
+ else if ((java.io.Serializable.class).isAssignableFrom(cl))
// only set this bit if CL is NOT Externalizable
flags |= ObjectStreamConstants.SC_SERIALIZABLE;
try
{
- Method writeMethod = cl.getDeclaredMethod ("writeObject",
+ Method writeMethod = cl.getDeclaredMethod("writeObject",
writeMethodArgTypes);
- int modifiers = writeMethod.getModifiers ();
+ int modifiers = writeMethod.getModifiers();
- if (writeMethod.getReturnType () == Void.TYPE
- && Modifier.isPrivate (modifiers)
- && !Modifier.isStatic (modifiers))
+ if (writeMethod.getReturnType() == Void.TYPE
+ && Modifier.isPrivate(modifiers)
+ && !Modifier.isStatic(modifiers))
flags |= ObjectStreamConstants.SC_WRITE_METHOD;
}
- catch (NoSuchMethodException oh_well)
- {}
+ catch(NoSuchMethodException oh_well)
+ {
+ }
}
// Sets fields to be a sorted array of the serializable fields of
// clazz.
- private void setFields (Class cl)
+ private void setFields(Class cl)
{
- if (! isSerializable () || isExternalizable ())
+ if (!isSerializable() || isExternalizable())
{
fields = NO_FIELDS;
return;
@@ -506,40 +508,41 @@
try
{
- Field serialPersistentFields
- = cl.getDeclaredField ("serialPersistentFields");
+ Field serialPersistentFields =
+ cl.getDeclaredField("serialPersistentFields");
serialPersistentFields.setAccessible(true);
- int modifiers = serialPersistentFields.getModifiers ();
+ int modifiers = serialPersistentFields.getModifiers();
- if (Modifier.isStatic (modifiers)
- && Modifier.isFinal (modifiers)
- && Modifier.isPrivate (modifiers))
+ if (Modifier.isStatic(modifiers)
+ && Modifier.isFinal(modifiers)
+ && Modifier.isPrivate(modifiers))
{
- fields = getSerialPersistentFields (cl);
+ fields = getSerialPersistentFields(cl);
if (fields != null)
{
- Arrays.sort(fields);
+ Arrays.sort (fields);
calculateOffsets();
return;
}
}
}
catch (NoSuchFieldException ignore)
- {}
+ {
+ }
catch (IllegalAccessException ignore)
{
}
int num_good_fields = 0;
- Field[] all_fields = cl.getDeclaredFields ();
+ Field[] all_fields = cl.getDeclaredFields();
int modifiers;
// set non-serializable fields to null in all_fields
- for (int i=0; i < all_fields.length; i++)
+ for (int i = 0; i < all_fields.length; i++)
{
- modifiers = all_fields[i].getModifiers ();
- if (Modifier.isTransient (modifiers)
- || Modifier.isStatic (modifiers))
+ modifiers = all_fields[i].getModifiers();
+ if (Modifier.isTransient(modifiers)
+ || Modifier.isStatic(modifiers))
all_fields[i] = null;
else
num_good_fields++;
@@ -547,40 +550,42 @@
// make a copy of serializable (non-null) fields
fields = new ObjectStreamField[ num_good_fields ];
- for (int from=0, to=0; from < all_fields.length; from++)
+ for (int from = 0, to = 0; from < all_fields.length; from++)
if (all_fields[from] != null)
{
Field f = all_fields[from];
- fields[to] = new ObjectStreamField (f.getName (), f.getType ());
+ fields[to] = new ObjectStreamField(f.getName(), f.getType());
to++;
}
- Arrays.sort (fields);
- calculateOffsets ();
+ Arrays.sort(fields);
+ calculateOffsets();
}
// Returns the serial version UID defined by class, or if that
// isn't present, calculates value of serial version UID.
- private long getClassUID (Class cl)
+ private long getClassUID(Class cl)
{
try
{
// Use getDeclaredField rather than getField, since serialVersionUID
// may not be public AND we only want the serialVersionUID of this
// class, not a superclass or interface.
- Field suid = cl.getDeclaredField ("serialVersionUID");
+ Field suid = cl.getDeclaredField("serialVersionUID");
suid.setAccessible(true);
- int modifiers = suid.getModifiers ();
+ int modifiers = suid.getModifiers();
- if (Modifier.isStatic (modifiers)
- && Modifier.isFinal (modifiers)
+ if (Modifier.isStatic(modifiers)
+ && Modifier.isFinal(modifiers)
&& suid.getType() == Long.TYPE)
- return suid.getLong (null);
+ return suid.getLong(null);
}
catch (NoSuchFieldException ignore)
- {}
+ {
+ }
catch (IllegalAccessException ignore)
- {}
+ {
+ }
// cl didn't define serialVersionUID, so we have to compute it
try
@@ -588,118 +593,119 @@
MessageDigest md;
try
{
- md = MessageDigest.getInstance ("SHA");
+ md = MessageDigest.getInstance("SHA");
}
catch (NoSuchAlgorithmException e)
{
// If a provider already provides SHA, use it; otherwise, use this.
Gnu gnuProvider = new Gnu();
Security.addProvider(gnuProvider);
- md = MessageDigest.getInstance ("SHA");
+ md = MessageDigest.getInstance("SHA");
}
DigestOutputStream digest_out =
- new DigestOutputStream (nullOutputStream, md);
- DataOutputStream data_out = new DataOutputStream (digest_out);
+ new DigestOutputStream(nullOutputStream, md);
+ DataOutputStream data_out = new DataOutputStream(digest_out);
- data_out.writeUTF (cl.getName ());
+ data_out.writeUTF(cl.getName());
- int modifiers = cl.getModifiers ();
+ int modifiers = cl.getModifiers();
// just look at interesting bits
modifiers = modifiers & (Modifier.ABSTRACT | Modifier.FINAL
| Modifier.INTERFACE | Modifier.PUBLIC);
- data_out.writeInt (modifiers);
+ data_out.writeInt(modifiers);
// Pretend that an array has no interfaces, because when array
// serialization was defined (JDK 1.1), arrays didn't have it.
- if (! cl.isArray ())
+ if (! cl.isArray())
{
- Class[] interfaces = cl.getInterfaces ();
- Arrays.sort (interfaces, interfaceComparator);
- for (int i=0; i < interfaces.length; i++)
- data_out.writeUTF (interfaces[i].getName ());
+ Class[] interfaces = cl.getInterfaces();
+ Arrays.sort(interfaces, interfaceComparator);
+ for (int i = 0; i < interfaces.length; i++)
+ data_out.writeUTF(interfaces[i].getName());
}
Field field;
- Field[] fields = cl.getDeclaredFields ();
- Arrays.sort (fields, memberComparator);
- for (int i=0; i < fields.length; i++)
+ Field[] fields = cl.getDeclaredFields();
+ Arrays.sort(fields, memberComparator);
+ for (int i = 0; i < fields.length; i++)
{
field = fields[i];
- modifiers = field.getModifiers ();
- if (Modifier.isPrivate (modifiers)
- && (Modifier.isStatic (modifiers)
- || Modifier.isTransient (modifiers)))
+ modifiers = field.getModifiers();
+ if (Modifier.isPrivate(modifiers)
+ && (Modifier.isStatic(modifiers)
+ || Modifier.isTransient(modifiers)))
continue;
- data_out.writeUTF (field.getName ());
- data_out.writeInt (modifiers);
- data_out.writeUTF (TypeSignature.getEncodingOfClass (field.getType ()));
+ data_out.writeUTF(field.getName());
+ data_out.writeInt(modifiers);
+ data_out.writeUTF(TypeSignature.getEncodingOfClass (field.getType()));
}
// write class initializer method if present
- if (VMObjectStreamClass.hasClassInitializer (cl))
+ if (VMObjectStreamClass.hasClassInitializer(cl))
{
- data_out.writeUTF ("<clinit>");
- data_out.writeInt (Modifier.STATIC);
- data_out.writeUTF ("()V");
+ data_out.writeUTF("<clinit>");
+ data_out.writeInt(Modifier.STATIC);
+ data_out.writeUTF("()V");
}
Constructor constructor;
- Constructor[] constructors = cl.getDeclaredConstructors ();
+ Constructor[] constructors = cl.getDeclaredConstructors();
Arrays.sort (constructors, memberComparator);
- for (int i=0; i < constructors.length; i++)
+ for (int i = 0; i < constructors.length; i++)
{
constructor = constructors[i];
- modifiers = constructor.getModifiers ();
- if (Modifier.isPrivate (modifiers))
+ modifiers = constructor.getModifiers();
+ if (Modifier.isPrivate(modifiers))
continue;
- data_out.writeUTF ("<init>");
- data_out.writeInt (modifiers);
+ data_out.writeUTF("<init>");
+ data_out.writeInt(modifiers);
// the replacement of '/' with '.' was needed to make computed
// SUID's agree with those computed by JDK
- data_out.writeUTF (
- TypeSignature.getEncodingOfConstructor (constructor).replace ('/','.'));
+ data_out.writeUTF
+ (TypeSignature.getEncodingOfConstructor(constructor).replace('/','.'));
}
Method method;
- Method[] methods = cl.getDeclaredMethods ();
- Arrays.sort (methods, memberComparator);
- for (int i=0; i < methods.length; i++)
+ Method[] methods = cl.getDeclaredMethods();
+ Arrays.sort(methods, memberComparator);
+ for (int i = 0; i < methods.length; i++)
{
method = methods[i];
- modifiers = method.getModifiers ();
- if (Modifier.isPrivate (modifiers))
+ modifiers = method.getModifiers();
+ if (Modifier.isPrivate(modifiers))
continue;
- data_out.writeUTF (method.getName ());
- data_out.writeInt (modifiers);
+ data_out.writeUTF(method.getName());
+ data_out.writeInt(modifiers);
// the replacement of '/' with '.' was needed to make computed
// SUID's agree with those computed by JDK
- data_out.writeUTF (
- TypeSignature.getEncodingOfMethod (method).replace ('/', '.'));
+ data_out.writeUTF
+ (TypeSignature.getEncodingOfMethod(method).replace('/', '.'));
}
- data_out.close ();
- byte[] sha = md.digest ();
+ data_out.close();
+ byte[] sha = md.digest();
long result = 0;
int len = sha.length < 8 ? sha.length : 8;
- for (int i=0; i < len; i++)
- result += (long)(sha[i] & 0xFF) << (8 * i);
+ for (int i = 0; i < len; i++)
+ result += (long) (sha[i] & 0xFF) << (8 * i);
return result;
}
catch (NoSuchAlgorithmException e)
{
- throw new RuntimeException ("The SHA algorithm was not found to use in computing the Serial Version UID for class "
- + cl.getName (), e);
+ throw new RuntimeException
+ ("The SHA algorithm was not found to use in computing the Serial Version UID for class "
+ + cl.getName(), e);
}
catch (IOException ioe)
{
- throw new RuntimeException (ioe);
+ throw new RuntimeException(ioe);
}
}
@@ -712,7 +718,7 @@
* @param clazz Class to retrieve 'serialPersistentFields' from.
* @return The content of 'serialPersistentFields'.
*/
- private ObjectStreamField[] getSerialPersistentFields (Class clazz)
+ private ObjectStreamField[] getSerialPersistentFields(Class clazz)
throws NoSuchFieldException, IllegalAccessException
{
ObjectStreamField[] fieldsArray = null;
@@ -724,9 +730,9 @@
f.setAccessible(true);
int modifiers = f.getModifiers();
- if (!(Modifier.isStatic(modifiers)
- && Modifier.isFinal(modifiers)
- && Modifier.isPrivate(modifiers)))
+ if (!(Modifier.isStatic(modifiers) &&
+ Modifier.isFinal(modifiers) &&
+ Modifier.isPrivate(modifiers)))
return null;
o = (ObjectStreamField[]) f.get(null);
@@ -734,7 +740,7 @@
if (o == null)
return null;
- fieldsArray = new ObjectStreamField[o.length];
+ fieldsArray = new ObjectStreamField[ o.length ];
System.arraycopy(o, 0, fieldsArray, 0, o.length);
return fieldsArray;
@@ -742,10 +748,10 @@
public static final ObjectStreamField[] NO_FIELDS = {};
- private static Hashtable classLookupTable = new Hashtable ();
- private static final NullOutputStream nullOutputStream = new NullOutputStream ();
- private static final Comparator interfaceComparator = new InterfaceComparator ();
- private static final Comparator memberComparator = new MemberComparator ();
+ private static Hashtable classLookupTable = new Hashtable();
+ private static final NullOutputStream nullOutputStream = new NullOutputStream();
+ private static final Comparator interfaceComparator = new InterfaceComparator();
+ private static final Comparator memberComparator = new MemberComparator();
private static final
Class[] writeMethodArgTypes = { java.io.ObjectOutputStream.class };
@@ -775,9 +781,9 @@
// interfaces are compared only by name
class InterfaceComparator implements Comparator
{
- public int compare (Object o1, Object o2)
+ public int compare(Object o1, Object o2)
{
- return ((Class)o1).getName ().compareTo (((Class)o2).getName ());
+ return ((Class) o1).getName().compareTo(((Class) o2).getName());
}
}
@@ -786,16 +792,16 @@
// conflicts are resolved by comparing type signatures
class MemberComparator implements Comparator
{
- public int compare (Object o1, Object o2)
+ public int compare(Object o1, Object o2)
{
- Member m1 = (Member)o1;
- Member m2 = (Member)o2;
+ Member m1 = (Member) o1;
+ Member m2 = (Member) o2;
- int comp = m1.getName ().compareTo (m2.getName ());
+ int comp = m1.getName().compareTo(m2.getName());
if (comp == 0)
- return TypeSignature.getEncodingOfMember (m1).
- compareTo (TypeSignature.getEncodingOfMember (m2));
+ return TypeSignature.getEncodingOfMember(m1).
+ compareTo(TypeSignature.getEncodingOfMember(m2));
else
return comp;
}