From 8392bd24eac3664e528e820b3456c5bb05f9db85 Mon Sep 17 00:00:00 2001 From: mkoch Date: Tue, 30 Dec 2003 15:51:15 +0000 Subject: [PATCH] 2003-12-30 Michael Koch * java/io/ObjectInputStream.java, java/io/ObjectOutputStream.java, java/io/ObjectStreamClass.java: Reformated, no functional code changes. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@75236 138bc75d-0d04-0410-961f-82ee72b054a4 --- libjava/ChangeLog | 7 + libjava/java/io/ObjectInputStream.java | 772 +++++++++++++++--------------- libjava/java/io/ObjectOutputStream.java | 680 +++++++++++++------------- libjava/java/io/ObjectStreamClass.java | 818 ++++++++++++++++---------------- 4 files changed, 1151 insertions(+), 1126 deletions(-) diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 639b936..9211c7c 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,5 +1,12 @@ 2003-12-30 Michael Koch + * java/io/ObjectInputStream.java, + java/io/ObjectOutputStream.java, + java/io/ObjectStreamClass.java: + Reformated, no functional code changes. + +2003-12-30 Michael Koch + * gnu/java/net/protocol/http/Connection.java (outputStream): New field. (bufferedOutputStream): New field. diff --git a/libjava/java/io/ObjectInputStream.java b/libjava/java/io/ObjectInputStream.java index de13939..c2ddbe0 100644 --- a/libjava/java/io/ObjectInputStream.java +++ b/libjava/java/io/ObjectInputStream.java @@ -73,7 +73,7 @@ public class ObjectInputStream extends InputStream * * @see #readStreamHeader() */ - public ObjectInputStream (InputStream in) + public ObjectInputStream(InputStream in) throws IOException, StreamCorruptedException { if (Configuration.DEBUG) @@ -96,14 +96,14 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream * @exception IOException Exception from underlying * InputStream. */ - 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream 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 - + " could not be created because zero-argument constructor is not defined"); + 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream * @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, - flags, fields); - assignNewHandle (osc); + ObjectStreamClass osc = new ObjectStreamClass(name, uid, + flags, fields); + 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 @@ public class ObjectInputStream extends InputStream // 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,11 +498,11 @@ public class ObjectInputStream extends InputStream } } - 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 @@ public class ObjectInputStream extends InputStream * @exception IOException Exception from underlying * OutputStream. */ - public void defaultReadObject () + public void defaultReadObject() throws ClassNotFoundException, IOException, NotActiveException { if (this.currentObject == null || this.currentObjectStreamClass == null) @@ -535,7 +538,7 @@ public class ObjectInputStream extends InputStream + "defaultReadObject or readFields)"); boolean oldmode = setBlockDataMode(false); - readFields (this.currentObject, this.currentObjectStreamClass); + readFields(this.currentObject, this.currentObjectStreamClass); setBlockDataMode(oldmode); fieldsAlreadyRead = true; @@ -560,20 +563,20 @@ public class ObjectInputStream extends InputStream * validator outside of the readObject method of the * object currently being deserialized */ - public void registerValidation (ObjectInputValidation validator, - int priority) + 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, - priority)); + this.validators.addElement(new ValidatorAndPriority (validator, + priority)); } @@ -593,7 +596,7 @@ public class ObjectInputStream extends InputStream * * @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 @@ public class ObjectInputStream extends InputStream */ private ClassLoader currentLoader() { - SecurityManager sm = System.getSecurityManager (); + SecurityManager sm = System.getSecurityManager(); if (sm == null) sm = new SecurityManager () {}; @@ -627,13 +630,13 @@ public class ObjectInputStream extends InputStream * @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 @@ public class ObjectInputStream extends InputStream * @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,36 +694,40 @@ public class ObjectInputStream extends InputStream * * @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){ - for (int i = 0; i < intfs.length; i++) - clss[i] = Class.forName(intfs[i]); - cl = ClassLoader.getSystemClassLoader(); - } + if(cl == null) + { + for (int i = 0; i < intfs.length; i++) + clss[i] = Class.forName(intfs[i]); + cl = ClassLoader.getSystemClassLoader(); + } else for (int i = 0; i < intfs.length; i++) clss[i] = cl.loadClass(intfs[i]); - try { - return Proxy.getProxyClass(cl, clss); - } catch (IllegalArgumentException e) { - throw new ClassNotFoundException(null, e); - } + try + { + return Proxy.getProxyClass(cl, clss); + } + catch (IllegalArgumentException e) + { + throw new ClassNotFoundException(null, e); + } } /** @@ -736,9 +743,9 @@ public class ObjectInputStream extends InputStream { 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 @@ public class ObjectInputStream extends InputStream * @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,25 +795,25 @@ public class ObjectInputStream extends InputStream int remain = this.blockDataBytes - this.blockDataPosition; if (remain != 0) { - System.arraycopy (this.blockData, this.blockDataPosition, - data, offset, remain); + System.arraycopy(this.blockData, this.blockDataPosition, + data, offset, remain); offset += remain; length -= remain; } readNextBlock (); } - System.arraycopy (this.blockData, this.blockDataPosition, - data, offset, length); + 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream 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 class ObjectInputStream extends InputStream */ 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,18 +1055,18 @@ public class ObjectInputStream extends InputStream * @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" - + " stream (by defaultReadObject or readFields)"); + throw new NotActiveException("readFields called but fields already read from" + + " stream (by defaultReadObject or readFields)"); final ObjectStreamClass clazz = this.currentObjectStreamClass; final byte[] prim_field_data = new byte[clazz.primFieldSize]; @@ -1068,20 +1075,20 @@ public class ObjectInputStream extends InputStream // 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 @@ public class ObjectInputStream extends InputStream } 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 @@ public class ObjectInputStream extends InputStream | (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 @@ public class ObjectInputStream extends InputStream | (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) - | ((prim_field_data[off++] & 0xFF) << 16) - | ((prim_field_data[off++] & 0xFF) << 8) - | (prim_field_data[off] & 0xFF)); + 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 @@ public class ObjectInputStream extends InputStream | (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 @@ public class ObjectInputStream extends InputStream */ 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 @@ public class ObjectInputStream extends InputStream * * @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 @@ public class ObjectInputStream extends InputStream * * @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 @@ public class ObjectInputStream extends InputStream * @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 @@ public class ObjectInputStream extends InputStream { 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 @@ public class ObjectInputStream extends InputStream } 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream { 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream // 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream 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 @@ public class ObjectInputStream extends InputStream * @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 @@ public class ObjectInputStream extends InputStream * @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 @@ public class ObjectInputStream extends InputStream * @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 @@ public class ObjectInputStream extends InputStream * @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 @@ public class ObjectInputStream extends InputStream * @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 @@ public class ObjectInputStream extends InputStream * @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 @@ public class ObjectInputStream extends InputStream * @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 @@ public class ObjectInputStream extends InputStream * @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 @@ public class ObjectInputStream extends InputStream * @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; diff --git a/libjava/java/io/ObjectOutputStream.java b/libjava/java/io/ObjectOutputStream.java index 0244e2d..8f991f0 100644 --- a/libjava/java/io/ObjectOutputStream.java +++ b/libjava/java/io/ObjectOutputStream.java @@ -132,18 +132,18 @@ public class ObjectOutputStream extends OutputStream */ 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 @@ public class ObjectOutputStream extends OutputStream * @exception IOException Exception from underlying * OutputStream. */ - 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 @@ public class ObjectOutputStream extends OutputStream { 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; } @@ -235,7 +235,7 @@ public class ObjectOutputStream extends OutputStream && ! replaceDone) { replacedObject = obj; - + if (obj instanceof Serializable) { Method m = null; @@ -247,7 +247,7 @@ public class ObjectOutputStream extends OutputStream // 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) { @@ -259,55 +259,55 @@ public class ObjectOutputStream extends OutputStream { } } - + if (replacementEnabled) - obj = replaceObject (obj); - + obj = replaceObject(obj); + replaceDone = true; continue; } 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); - - ((Externalizable)obj).writeExternal (this); - + setBlockDataMode(true); + + ((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 @@ public class ObjectOutputStream extends OutputStream { currentObject = obj; ObjectStreamClass[] hierarchy = - ObjectStreamClass.getObjectStreamClasses (clazz); - - for (int i=0; i < hierarchy.length; i++) + ObjectStreamClass.getObjectStreamClasses(clazz); + + 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 @@ public class ObjectOutputStream extends OutputStream break; } - throw new NotSerializableException (clazz.getName ()); + throw new NotSerializableException(clazz.getName ()); } // end pseudo-loop } catch (ObjectStreamException ose) @@ -351,243 +351,247 @@ public class ObjectOutputStream extends OutputStream } 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 - private void writeObject (ObjectOutputStream) - method. - - @exception NotActiveException This method was called from a - context other than from the current object's and current class's - private void writeObject (ObjectOutputStream) - method. - - @exception IOException Exception from underlying - OutputStream. - */ - public void defaultWriteObject () + * 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 + * private void writeObject (ObjectOutputStream) + * method. + * + * @exception NotActiveException This method was called from a + * context other than from the current object's and current class's + * private void writeObject (ObjectOutputStream) + * method. + * + * @exception IOException Exception from underlying + * OutputStream. + */ + 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; } - /** - 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 - OutputStream or reset called while serialization is - in progress. - */ - public void reset () throws IOException + * 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 + * OutputStream or reset called while serialization is + * in progress. + */ + 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 ObjectOutputStream to write data - according to the specified protocol. There are currently two - different protocols, specified by PROTOCOL_VERSION_1 - and PROTOCOL_VERSION_2. This implementation writes - data using PROTOCOL_VERSION_2 by default, as is done - by the JDK 1.2. - - A non-portable method, setDefaultProtocolVersion (int - version) 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 version is not a valid - protocol - - @see #setDefaultProtocolVersion(int) - */ - public void useProtocolVersion (int version) throws IOException + * Informs this ObjectOutputStream to write data + * according to the specified protocol. There are currently two + * different protocols, specified by PROTOCOL_VERSION_1 + * and PROTOCOL_VERSION_2. This implementation writes + * data using PROTOCOL_VERSION_2 by default, as is done + * by the JDK 1.2. + * + * A non-portable method, setDefaultProtocolVersion (int + * version) 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 version is not a valid + * protocol + * + * @see #setDefaultProtocolVersion(int) + */ + 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; } /** - GNU $classpath specific - - Changes the default stream protocol used by all - ObjectOutputStreams. There are currently two - different protocols, specified by PROTOCOL_VERSION_1 - and PROTOCOL_VERSION_2. The default default is - PROTOCOL_VERSION_1. - - @exception IOException if version is not a valid - protocol - - @see #useProtocolVersion(int) - */ - public static void setDefaultProtocolVersion (int version) + * GNU $classpath specific + * + * Changes the default stream protocol used by all + * ObjectOutputStreams. There are currently two + * different protocols, specified by PROTOCOL_VERSION_1 + * and PROTOCOL_VERSION_2. The default default is + * PROTOCOL_VERSION_1. + * + * @exception IOException if version is not a valid + * protocol + * + * @see #useProtocolVersion(int) + */ + 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 - OutputStream. - - @see ObjectInputStream#resolveClass(java.io.ObjectStreamClass) - */ - protected void annotateClass (Class cl) throws IOException - {} + * 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 + * OutputStream. + * + * @see ObjectInputStream#resolveClass(java.io.ObjectStreamClass) + */ + 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 - OutputStream. - - @see #enableReplaceObject(boolean) - */ - protected Object replaceObject (Object obj) 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 + * OutputStream. + * + * @see #enableReplaceObject(boolean) + */ + protected Object replaceObject(Object obj) throws IOException { return obj; } /** - If enable is true and this object is - trusted, then replaceObject (Object) will be called - in subsequent calls to writeObject (Object). - Otherwise, replaceObject (Object) will not be called. - - @exception SecurityException This class is not trusted. - */ - protected boolean enableReplaceObject (boolean enable) + * If enable is true and this object is + * trusted, then replaceObject (Object) will be called + * in subsequent calls to writeObject (Object). + * Otherwise, replaceObject (Object) will not be called. + * + * @exception SecurityException This class is not trusted. + */ + 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 @@ public class ObjectOutputStream extends OutputStream /** - Writes stream magic and stream version information to the - underlying stream. - - @exception IOException Exception from underlying - OutputStream. - */ - protected void writeStreamHeader () throws IOException + * Writes stream magic and stream version information to the + * underlying stream. + * + * @exception IOException Exception from underlying + * OutputStream. + */ + 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 @@ public class ObjectOutputStream extends OutputStream * * @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 @@ public class ObjectOutputStream extends OutputStream * @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 @@ public class ObjectOutputStream extends OutputStream 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 class ObjectOutputStream extends OutputStream */ public void flush () throws IOException { - drain (); - realOutput.flush (); + drain(); + realOutput.flush(); } @@ -720,14 +723,14 @@ public class ObjectOutputStream extends OutputStream * @exception IOException Exception from underlying * OutputStream. */ - 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 @@ public class ObjectOutputStream extends OutputStream /** * @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 class ObjectOutputStream extends OutputStream */ 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 class ObjectOutputStream extends OutputStream 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 class ObjectOutputStream extends OutputStream } - 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, - fields[i].getTypeString ())); + 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 @@ public class ObjectOutputStream extends OutputStream } - 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,34 +1231,34 @@ public class ObjectOutputStream extends OutputStream throw (IOException) exception; IOException ioe - = new IOException ("Exception thrown from writeObject() on " + - klass + ": " + exception.getClass().getName()); + = new IOException("Exception thrown from writeObject() on " + + klass + ": " + exception.getClass().getName()); ioe.initCause(exception); throw ioe; } catch (Exception x) { IOException ioe - = new IOException ("Failure invoking writeObject() on " + - klass + ": " + x.getClass().getName()); + = 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 " + _); + } } private byte getByteField (Object obj, Class klass, String field_name) @@ -1268,7 +1272,7 @@ public class ObjectOutputStream extends OutputStream } catch (Exception _) { - throw new IOException ("Unexpected Exception "+_); + throw new IOException("Unexpected exception " + _); } } @@ -1283,7 +1287,7 @@ public class ObjectOutputStream extends OutputStream } catch (Exception _) { - throw new IOException ("Unexpected Exception "+_); + throw new IOException("Unexpected exception " + _); } } @@ -1298,7 +1302,7 @@ public class ObjectOutputStream extends OutputStream } catch (Exception _) { - throw new IOException ("Unexpected Exception "+_); + throw new IOException("Unexpected exception " + _); } } @@ -1313,8 +1317,8 @@ public class ObjectOutputStream extends OutputStream } catch (Exception _) { - throw new IOException ("Unexpected Exception "+_); - } + throw new IOException("Unexpected exception " + _); + } } private int getIntField (Object obj, Class klass, String field_name) @@ -1328,8 +1332,8 @@ public class ObjectOutputStream extends OutputStream } catch (Exception _) { - throw new IOException ("Unexpected Exception "+_); - } + throw new IOException("Unexpected exception " + _); + } } private long getLongField (Object obj, Class klass, String field_name) @@ -1343,7 +1347,7 @@ public class ObjectOutputStream extends OutputStream } catch (Exception _) { - throw new IOException ("Unexpected Exception "+_); + throw new IOException("Unexpected exception " + _); } } @@ -1358,8 +1362,8 @@ public class ObjectOutputStream extends OutputStream } catch (Exception _) { - throw new IOException ("Unexpected Exception "+_); - } + throw new IOException("Unexpected exception " + _); + } } private Object getObjectField (Object obj, Class klass, String field_name, @@ -1372,9 +1376,9 @@ public class ObjectOutputStream extends OutputStream // 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 @@ public class ObjectOutputStream extends OutputStream { if (Configuration.INIT_LOAD_LIBRARY) { - System.loadLibrary ("javaio"); + System.loadLibrary("javaio"); } } } diff --git a/libjava/java/io/ObjectStreamClass.java b/libjava/java/io/ObjectStreamClass.java index 9d9d99d..5bd0e68 100644 --- a/libjava/java/io/ObjectStreamClass.java +++ b/libjava/java/io/ObjectStreamClass.java @@ -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 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 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 @@ import gnu.java.security.provider.Gnu; public class ObjectStreamClass implements Serializable { /** - Returns the ObjectStreamClass for cl. - If cl is null, or is not Serializable, - null is returned. ObjectStreamClass's are memorized; - later calls to this method with the same class will return the - same ObjectStreamClass object and no recalculation - will be done. - - @see java.io.Serializable - */ - public static ObjectStreamClass lookup (Class cl) + * Returns the ObjectStreamClass for cl. + * If cl is null, or is not Serializable, + * null is returned. ObjectStreamClass's are memorized; + * later calls to this method with the same class will return the + * same ObjectStreamClass object and no recalculation + * will be done. + * + * @see java.io.Serializable + */ + 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 @@ public class ObjectStreamClass implements Serializable * 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); - return osc; - } + { + osc = new ObjectStreamClass(cl); + classLookupTable.put(cl, osc); + return osc; + } } /** - Returns the name of the class that this - ObjectStreamClass represents. - */ - public String getName () + * Returns the name of the class that this + * ObjectStreamClass represents. + */ + public String getName() { return name; } /** - Returns the class that this ObjectStreamClass - represents. Null could be returned if this - ObjectStreamClass was read from an - ObjectInputStream and the class it represents cannot - be found or loaded. - - @see java.io.ObjectInputStream - */ - public Class forClass () + * Returns the class that this ObjectStreamClass + * represents. Null could be returned if this + * ObjectStreamClass was read from an + * ObjectInputStream and the class it represents cannot + * be found or loaded. + * + * @see java.io.ObjectInputStream + */ + public Class forClass() { return clazz; } /** - Returns the serial version stream-unique identifier for the class - represented by this ObjectStreamClass. This SUID is - either defined by the class as static final long - serialVersionUID or is calculated as specified in - Javasoft's "Object Serialization Specification" XXX: add reference - */ - public long getSerialVersionUID () + * Returns the serial version stream-unique identifier for the class + * represented by this ObjectStreamClass. This SUID is + * either defined by the class as static final long + * serialVersionUID or is calculated as specified in + * Javasoft's "Object Serialization Specification" XXX: add reference + */ + public long getSerialVersionUID() { return uid; } @@ -145,10 +145,10 @@ public class ObjectStreamClass implements Serializable // 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 @@ public class ObjectStreamClass implements Serializable // 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 @@ public class ObjectStreamClass implements Serializable * @see #getSerialVersionUID() * @see #getName() */ - public String toString () + public String toString() { return "java.io.ObjectStreamClass< " + name + ", " + uid + " >"; } @@ -187,7 +187,7 @@ public class ObjectStreamClass implements Serializable // // This method is used by the class to override default // serialization behavior. - boolean hasWriteMethod () + boolean hasWriteMethod() { return (flags & ObjectStreamConstants.SC_WRITE_METHOD) != 0; } @@ -200,24 +200,24 @@ public class ObjectStreamClass implements Serializable // // This method is used by the class to override default // serialization behavior. - boolean hasReadMethod () + boolean hasReadMethod() { - try + try { - Class[] readObjectParams = { ObjectInputStream.class }; - forClass ().getDeclaredMethod ("readObject", readObjectParams); - return true; + Class[] readObjectParams = { ObjectInputStream.class }; + forClass().getDeclaredMethod("readObject", readObjectParams); + return true; } - catch (NoSuchMethodException e) + catch (NoSuchMethodException e) { - return false; + return false; } } // 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 @@ public class ObjectStreamClass implements Serializable // 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 @@ public class ObjectStreamClass implements Serializable // class that is the superclass of the class this // ObjectStreamClass represents. If the superclass is // not Serializable, null is returned. - ObjectStreamClass getSuper () + ObjectStreamClass getSuper() { return superClass; } @@ -245,30 +245,30 @@ public class ObjectStreamClass implements Serializable // 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 (); - - while (osc != null) { - oscs.addElement (osc); - osc = osc.getSuper (); - } + Vector oscs = new Vector(); - int count = oscs.size (); - ObjectStreamClass[] sorted_oscs = new ObjectStreamClass[ count ]; + while (osc != null) + { + oscs.addElement (osc); + osc = osc.getSuper(); + } + + 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); + for (int i = count - 1; i >= 0; i--) + sorted_oscs[ count - i - 1 ] = (ObjectStreamClass) oscs.elementAt(i); - return sorted_oscs; - } + return sorted_oscs; + } } @@ -276,14 +276,14 @@ public class ObjectStreamClass implements Serializable // 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, - ObjectStreamField[] fields) + ObjectStreamClass(String name, long uid, byte flags, + ObjectStreamField[] fields) { this.name = name; this.uid = uid; @@ -302,11 +302,11 @@ public class ObjectStreamClass implements Serializable * @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,87 +322,89 @@ public class ObjectStreamClass implements Serializable } } - isProxyClass = clazz != null && Proxy.isProxyClass (clazz); + isProxyClass = clazz != null && Proxy.isProxyClass(clazz); this.superClass = superClass; - calculateOffsets (); - + calculateOffsets(); + try { - ObjectStreamField[] exportedFields = getSerialPersistentFields (clazz); - - if (exportedFields == null) - return; - - ObjectStreamField[] newFieldList = new ObjectStreamField[exportedFields.length + fields.length]; - int i, j, k; - - /* We now check the import fields against the exported fields. - * There should not be contradiction (e.g. int x and String x) - * but extra virtual fields can be added to the class. - */ - - Arrays.sort(exportedFields); - - i = 0; j = 0; k = 0; - while (i < fields.length && j < exportedFields.length) - { - int comp = fields[i].getName().compareTo (exportedFields[j].getName()); - if (comp < 0) - { - newFieldList[k] = fields[i]; - fields[i].setPersistent(false); - fields[i].setToSet(false); - i++; - } - else if (comp > 0) - { - /* field not found in imported fields. We add it - * in the list of supported fields. - */ - newFieldList[k] = exportedFields[j]; - newFieldList[k].setPersistent(true); - newFieldList[k].setToSet(false); - j++; - } - else - { - 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); - i++; - j++; - } - k++; - } - - if (i < fields.length) - for (; i < fields.length; i++, k++) - { - fields[i].setPersistent(false); - fields[i].setToSet(false); - newFieldList[k] = fields[i]; - } - else - if (j < exportedFields.length) - for (; j < exportedFields.length; j++, k++) - { - exportedFields[j].setPersistent(true); - exportedFields[j].setToSet(false); - newFieldList[k] = exportedFields[j]; - } - - fields = new ObjectStreamField[k]; - System.arraycopy (newFieldList, 0, fields, 0, k); + ObjectStreamField[] exportedFields = getSerialPersistentFields (clazz); + + if (exportedFields == null) + return; + + ObjectStreamField[] newFieldList = new ObjectStreamField[exportedFields.length + fields.length]; + int i, j, k; + + /* We now check the import fields against the exported fields. + * There should not be contradiction (e.g. int x and String x) + * but extra virtual fields can be added to the class. + */ + + Arrays.sort(exportedFields); + + i = 0; j = 0; k = 0; + while (i < fields.length && j < exportedFields.length) + { + int comp = fields[i].getName().compareTo(exportedFields[j].getName()); + + if (comp < 0) + { + newFieldList[k] = fields[i]; + fields[i].setPersistent(false); + fields[i].setToSet(false); + i++; + } + else if (comp > 0) + { + /* field not found in imported fields. We add it + * in the list of supported fields. + */ + newFieldList[k] = exportedFields[j]; + newFieldList[k].setPersistent(true); + newFieldList[k].setToSet(false); + j++; + } + else + { + 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); + i++; + j++; + } + k++; + } + + if (i < fields.length) + for (;i"); - data_out.writeInt (Modifier.STATIC); - data_out.writeUTF ("()V"); - } + // write class initializer method if present + if (VMObjectStreamClass.hasClassInitializer(cl)) + { + data_out.writeUTF(""); + data_out.writeInt(Modifier.STATIC); + data_out.writeUTF("()V"); + } - Constructor constructor; - Constructor[] constructors = cl.getDeclaredConstructors (); - Arrays.sort (constructors, memberComparator); - for (int i=0; i < constructors.length; i++) - { - constructor = constructors[i]; - modifiers = constructor.getModifiers (); - if (Modifier.isPrivate (modifiers)) - continue; - - data_out.writeUTF (""); - 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 ('/','.')); - } + Constructor constructor; + Constructor[] constructors = cl.getDeclaredConstructors(); + Arrays.sort (constructors, memberComparator); + for (int i = 0; i < constructors.length; i++) + { + constructor = constructors[i]; + modifiers = constructor.getModifiers(); + if (Modifier.isPrivate(modifiers)) + continue; + + data_out.writeUTF(""); + 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('/','.')); + } - Method method; - 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)) - continue; - - 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 ('/', '.')); - } + Method method; + 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)) + continue; + + 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.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); + 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); - return result; - } + 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 @@ public class ObjectStreamClass implements Serializable * @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 @@ public class ObjectStreamClass implements Serializable 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 @@ public class ObjectStreamClass implements Serializable 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 class ObjectStreamClass implements Serializable 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 @@ public class ObjectStreamClass implements Serializable // 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 @@ class InterfaceComparator implements Comparator // 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; } -- 2.7.4