Index: ObjectInputStream.java =================================================================== RCS file: /cvsroot/classpath/classpath/java/io/ObjectInputStream.java,v retrieving revision 1.26 diff -u -r1.26 ObjectInputStream.java --- ObjectInputStream.java 19 Jan 2003 18:38:39 -0000 1.26 +++ ObjectInputStream.java 13 Feb 2003 10:50:01 -0000 @@ -374,7 +374,6 @@ // DEBUGln ("Got class hierarchy of depth " + hierarchy.length); - boolean has_read; for (int i=0; i < hierarchy.length; i++) { this.currentObjectStreamClass = hierarchy[i]; @@ -382,27 +381,17 @@ dumpElementln ("Reading fields of " + this.currentObjectStreamClass.getName ()); - has_read = true; - - try - { - this.currentObjectStreamClass.forClass (). - getDeclaredMethod ("readObject", readObjectParams); - } - catch (NoSuchMethodException e) - { - has_read = false; - } - // XXX: should initialize fields in classes in the hierarchy // that aren't in the stream // should skip over classes in the stream that aren't in the // real classes hierarchy - readFields (obj, this.currentObjectStreamClass.fields, - has_read, this.currentObjectStreamClass); - if (has_read) + if (this.currentObjectStreamClass.hasReadMethod()) { + fieldsAlreadyRead = false; + boolean oldmode = setBlockDataMode (true); + callReadMethod (obj, this.currentObjectStreamClass); + setBlockDataMode (oldmode); dumpElement ("ENDBLOCKDATA? "); try { @@ -421,6 +410,10 @@ dumpElementln ("no, got IOException"); } } + else + { + readFields (obj, currentObjectStreamClass); + } } this.currentObject = null; @@ -501,9 +494,7 @@ throw new NotActiveException ("defaultReadObject called but fields already read from stream (by defaultReadObject or readFields)"); boolean oldmode = setBlockDataMode(false); - readFields (this.currentObject, - this.currentObjectStreamClass.fields, - false, this.currentObjectStreamClass); + readFields (this.currentObject, this.currentObjectStreamClass); setBlockDataMode(oldmode); fieldsAlreadyRead = true; @@ -1340,22 +1331,11 @@ } - private void readFields (Object obj, ObjectStreamField[] stream_fields, - boolean call_read_method, - ObjectStreamClass stream_osc) + private void readFields (Object obj, ObjectStreamClass stream_osc) throws ClassNotFoundException, IOException { // DEBUGln ("In readFields"); - if (call_read_method) - { - // DEBUGln (" call_read_method is true"); - fieldsAlreadyRead = false; - boolean oldmode = setBlockDataMode (true); - callReadMethod (obj, stream_osc.forClass ()); - setBlockDataMode (oldmode); - return; - } - + ObjectStreamField[] stream_fields = stream_osc.fields; ObjectStreamField[] real_fields = ObjectStreamClass.lookup (stream_osc.forClass ()).fields; @@ -1421,7 +1401,7 @@ if (!default_initialize && set_value) dumpElementln (" " + field_name + ": " + value); if (set_value) - setBooleanField (obj, field_name, value); + setBooleanField (obj, stream_osc.forClass (), field_name, value); } else if (type == Byte.TYPE) { @@ -1430,7 +1410,7 @@ if (!default_initialize && set_value) dumpElementln (" " + field_name + ": " + value); if (set_value) - setByteField (obj, field_name, value); + setByteField (obj, stream_osc.forClass (), field_name, value); } else if (type == Character.TYPE) { @@ -1439,7 +1419,7 @@ if (!default_initialize && set_value) dumpElementln (" " + field_name + ": " + value); if (set_value) - setCharField (obj, field_name, value); + setCharField (obj, stream_osc.forClass (), field_name, value); } else if (type == Double.TYPE) { @@ -1448,7 +1428,7 @@ if (!default_initialize && set_value) dumpElementln (" " + field_name + ": " + value); if (set_value) - setDoubleField (obj, field_name, value); + setDoubleField (obj, stream_osc.forClass (), field_name, value); } else if (type == Float.TYPE) { @@ -1457,7 +1437,7 @@ if (!default_initialize && set_value) dumpElementln (" " + field_name + ": " + value); if (set_value) - setFloatField (obj, field_name, value); + setFloatField (obj, stream_osc.forClass (), field_name, value); } else if (type == Integer.TYPE) { @@ -1466,7 +1446,7 @@ if (!default_initialize && set_value) dumpElementln (" " + field_name + ": " + value); if (set_value) - setIntField (obj, field_name, value); + setIntField (obj, stream_osc.forClass (), field_name, value); } else if (type == Long.TYPE) { @@ -1475,7 +1455,7 @@ if (!default_initialize && set_value) dumpElementln (" " + field_name + ": " + value); if (set_value) - setLongField (obj, field_name, value); + setLongField (obj, stream_osc.forClass (), field_name, value); } else if (type == Short.TYPE) { @@ -1484,14 +1464,14 @@ if (!default_initialize && set_value) dumpElementln (" " + field_name + ": " + value); if (set_value) - setShortField (obj, field_name, value); + setShortField (obj, stream_osc.forClass (), field_name, value); } else { Object value = default_initialize ? null : readObject (); if (set_value) - setObjectField (obj, field_name, + setObjectField (obj, stream_osc.forClass (), field_name, real_field.getTypeString (), value); } } @@ -1570,8 +1550,9 @@ return klass.getDeclaredMethod(name, args); } - private void callReadMethod (Object obj, Class klass) throws IOException + private void callReadMethod (Object obj, ObjectStreamClass osc) throws IOException { + Class klass = osc.forClass(); try { Class classArgs[] = {ObjectInputStream.class}; @@ -1605,12 +1586,11 @@ private native void callConstructor (Class clazz, Object obj); - private void setBooleanField (Object obj, String field_name, + private void setBooleanField (Object obj, Class klass, String field_name, boolean val) { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); f.setAccessible(true); f.setBoolean (obj, val); @@ -1620,12 +1600,11 @@ } } - private void setByteField (Object obj, String field_name, + private void setByteField (Object obj, Class klass, String field_name, byte val) { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); f.setAccessible(true); f.setByte (obj, val); @@ -1635,12 +1614,11 @@ } } - private void setCharField (Object obj, String field_name, + private void setCharField (Object obj, Class klass, String field_name, char val) { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); f.setAccessible(true); f.setChar (obj, val); @@ -1650,12 +1628,11 @@ } } - private void setDoubleField (Object obj, String field_name, + private void setDoubleField (Object obj, Class klass, String field_name, double val) { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); f.setAccessible(true); f.setDouble (obj, val); @@ -1665,12 +1642,11 @@ } } - private void setFloatField (Object obj, String field_name, + private void setFloatField (Object obj, Class klass, String field_name, float val) { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); f.setAccessible(true); f.setFloat (obj, val); @@ -1680,12 +1656,11 @@ } } - private void setIntField (Object obj, String field_name, + private void setIntField (Object obj, Class klass, String field_name, int val) { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); f.setAccessible(true); f.setInt (obj, val); @@ -1696,12 +1671,11 @@ } - private void setLongField (Object obj, String field_name, + private void setLongField (Object obj, Class klass, String field_name, long val) { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); f.setAccessible(true); f.setLong (obj, val); @@ -1712,12 +1686,11 @@ } - private void setShortField (Object obj, String field_name, + private void setShortField (Object obj, Class klass, String field_name, short val) { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); f.setAccessible(true); f.setShort (obj, val); @@ -1728,12 +1701,11 @@ } - private void setObjectField (Object obj, String field_name, String type_code, + private void setObjectField (Object obj, Class klass, String field_name, String type_code, Object val) { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); f.setAccessible(true); // FIXME: We should check the type_code here Index: ObjectOutputStream.java =================================================================== RCS file: /cvsroot/classpath/classpath/java/io/ObjectOutputStream.java,v retrieving revision 1.26 diff -u -r1.26 ObjectOutputStream.java --- ObjectOutputStream.java 6 Feb 2003 17:30:54 -0000 1.26 +++ ObjectOutputStream.java 13 Feb 2003 10:48:05 -0000 @@ -355,22 +355,23 @@ ObjectStreamClass[] hierarchy = ObjectStreamClass.getObjectStreamClasses (clazz); - boolean has_write; for (int i=0; i < hierarchy.length; i++) { currentObjectStreamClass = hierarchy[i]; fieldsAlreadyWritten = false; - has_write = currentObjectStreamClass.hasWriteMethod (); - writeFields (obj, currentObjectStreamClass.fields, - has_write); - - // if (has_write) - // { - // drain (); - // realOutput.writeByte (TC_ENDBLOCKDATA); - // } + if (currentObjectStreamClass.hasWriteMethod ()) + { + setBlockDataMode (true); + callWriteMethod (obj, currentObjectStreamClass); + setBlockDataMode (false); + realOutput.writeByte (TC_ENDBLOCKDATA); + } + else + { + writeFields (obj, currentObjectStreamClass); + } } currentObject = null; @@ -433,7 +434,7 @@ throws IOException, NotActiveException { markFieldsWritten (); - writeFields (currentObject, currentObjectStreamClass.fields, false); + writeFields (currentObject, currentObjectStreamClass); } @@ -1154,22 +1155,12 @@ } - // writes out FIELDS of OBJECT. If CALL_WRITE_METHOD is true, use - // object's writeObject (ObjectOutputStream), otherwise use default - // serialization. FIELDS are already in canonical order. - private void writeFields (Object obj, - ObjectStreamField[] fields, - boolean call_write_method) throws IOException + // writes out FIELDS of OBJECT for the specified ObjectStreamClass. + // FIELDS are already in canonical order. + private void writeFields (Object obj, ObjectStreamClass osc) + throws IOException { - if (call_write_method) - { - setBlockDataMode (true); - callWriteMethod (obj); - setBlockDataMode (false); - realOutput.writeByte (TC_ENDBLOCKDATA); - return; - } - + ObjectStreamField[] fields = osc.fields; boolean oldmode = setBlockDataMode (false); //?? String field_name; Class type; @@ -1179,23 +1170,23 @@ type = fields[i].getType (); if (type == Boolean.TYPE) - realOutput.writeBoolean (getBooleanField (obj, field_name)); + realOutput.writeBoolean (getBooleanField (obj, osc.forClass(), field_name)); else if (type == Byte.TYPE) - realOutput.writeByte (getByteField (obj, field_name)); + realOutput.writeByte (getByteField (obj, osc.forClass(), field_name)); else if (type == Character.TYPE) - realOutput.writeChar (getCharField (obj, field_name)); + realOutput.writeChar (getCharField (obj, osc.forClass(), field_name)); else if (type == Double.TYPE) - realOutput.writeDouble (getDoubleField (obj, field_name)); + realOutput.writeDouble (getDoubleField (obj, osc.forClass(), field_name)); else if (type == Float.TYPE) - realOutput.writeFloat (getFloatField (obj, field_name)); + realOutput.writeFloat (getFloatField (obj, osc.forClass(), field_name)); else if (type == Integer.TYPE) - realOutput.writeInt (getIntField (obj, field_name)); + realOutput.writeInt (getIntField (obj, osc.forClass(), field_name)); else if (type == Long.TYPE) - realOutput.writeLong (getLongField (obj, field_name)); + realOutput.writeLong (getLongField (obj, osc.forClass(), field_name)); else if (type == Short.TYPE) - realOutput.writeShort (getShortField (obj, field_name)); + realOutput.writeShort (getShortField (obj, osc.forClass(), field_name)); else - writeObject (getObjectField (obj, field_name, + writeObject (getObjectField (obj, osc.forClass(), field_name, fields[i].getTypeString ())); } setBlockDataMode (oldmode); // ?? @@ -1221,9 +1212,9 @@ } - private void callWriteMethod (Object obj) throws IOException + private void callWriteMethod (Object obj, ObjectStreamClass osc) throws IOException { - Class klass = obj.getClass (); + Class klass = osc.forClass(); try { Class classArgs[] = {ObjectOutputStream.class}; @@ -1252,11 +1243,10 @@ } } - private boolean getBooleanField (Object obj, String field_name) throws IOException + private boolean getBooleanField (Object obj, Class klass, String field_name) throws IOException { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); boolean b = f.getBoolean (obj); return b; @@ -1267,11 +1257,10 @@ } } - private byte getByteField (Object obj, String field_name) throws IOException + private byte getByteField (Object obj, Class klass, String field_name) throws IOException { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); byte b = f.getByte (obj); return b; @@ -1282,11 +1271,10 @@ } } - private char getCharField (Object obj, String field_name) throws IOException + private char getCharField (Object obj, Class klass, String field_name) throws IOException { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); char b = f.getChar (obj); return b; @@ -1297,11 +1285,10 @@ } } - private double getDoubleField (Object obj, String field_name) throws IOException + private double getDoubleField (Object obj, Class klass, String field_name) throws IOException { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); double b = f.getDouble (obj); return b; @@ -1312,11 +1299,10 @@ } } - private float getFloatField (Object obj, String field_name) throws IOException + private float getFloatField (Object obj, Class klass, String field_name) throws IOException { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); float b = f.getFloat (obj); return b; @@ -1327,11 +1313,10 @@ } } - private int getIntField (Object obj, String field_name) throws IOException + private int getIntField (Object obj, Class klass, String field_name) throws IOException { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); int b = f.getInt (obj); return b; @@ -1342,11 +1327,10 @@ } } - private long getLongField (Object obj, String field_name) throws IOException + private long getLongField (Object obj, Class klass, String field_name) throws IOException { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); long b = f.getLong (obj); return b; @@ -1357,11 +1341,10 @@ } } - private short getShortField (Object obj, String field_name) throws IOException + private short getShortField (Object obj, Class klass, String field_name) throws IOException { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); short b = f.getShort (obj); return b; @@ -1372,12 +1355,11 @@ } } - private Object getObjectField (Object obj, String field_name, + private Object getObjectField (Object obj, Class klass, String field_name, String type_code) throws IOException { try { - Class klass = obj.getClass (); Field f = getField (klass, field_name); Object o = f.get (obj); // FIXME: We should check the type_code here Index: ObjectStreamClass.java =================================================================== RCS file: /cvsroot/classpath/classpath/java/io/ObjectStreamClass.java,v retrieving revision 1.20 diff -u -r1.20 ObjectStreamClass.java --- ObjectStreamClass.java 17 Jan 2003 16:45:28 -0000 1.20 +++ ObjectStreamClass.java 13 Feb 2003 10:49:21 -0000 @@ -194,6 +194,28 @@ // Returns true iff the class that this ObjectStreamClass represents + // has the following method: + // + // private void readObject (ObjectOutputStream) + // + // This method is used by the class to override default + // serialization behavior. + boolean hasReadMethod () + { + try + { + Class[] readObjectParams = { ObjectInputStream.class }; + forClass ().getDeclaredMethod ("readObject", readObjectParams); + return true; + } + catch (NoSuchMethodException e) + { + return false; + } + } + + + // Returns true iff the class that this ObjectStreamClass represents // implements Serializable but does *not* implement Externalizable. boolean isSerializable () {