+2003-02-14 Jeroen Frijters <jeroen@sumatra.nl>
+
+ * java/io/ObjectInputStream.java (readObject): Cleaned up the class
+ hierarchy loop.
+ (readFields(Object,ObjectStreamField[],boolean)): Changed argument
+ list to Object,ObjectStreamClass, moved callReadMethod code up into
+ readObject and added Class argument to all setXxxField calls.
+ (callReadMethod): Changed Class argument to ObjectStreamClass to be
+ consistent with ObjectOutputStream and to facilitate caching the
+ Method in the future.
+ (setBooleanField): Added Class argument.
+ (setByteField): Likewise.
+ (setCharField): Likewise.
+ (setDoubleField): Likewise.
+ (setFloatField): Likewise.
+ (setIntField): Likewise.
+ (setLongField): Likewise.
+ (setShortField): Likewise.
+ (setObjectField): Likewise.
+ * java/io/ObjectOutputStream.java (writeObject): Cleaned up the
+ class hierarchy loop.
+ (defaultWriteObject): Call writeFields with new argument list.
+ (writeFields(Object,ObjectStreamField[],boolean): Changed argument
+ list to Object,ObjectStreamClass, moved callWriteMethod up into
+ writeObject and added Class argument to all getXxxField calls.
+ (callWriteMethod): Added ObjectStreamClass argument to be able to
+ get the proper class to call getMethod on (each class can have (or
+ not have) its own writeObject method).
+ (getBooleanField): Added Class argument.
+ (getByteField): Likewise.
+ (getCharField): Likewise.
+ (getDoubleField): Likewise.
+ (getFloatField): Likewise.
+ (getIntField): Likewise.
+ (getLongField): Likewise.
+ (getShortField): Likewise.
+ (getObjectField): Likewise.
+ * java/io/ObjectStreamClass.java (hasReadMethod): Added method to
+ facilitate caching the Method object in the future.
+
2003-03-12 Andreas Schwab <schwab@suse.de>
* configure.in: Avoid trailing /. in toolexeclibdir.
ObjectStreamClass[] hierarchy =
ObjectStreamClass.getObjectStreamClasses (clazz);
- boolean has_read;
for (int i=0; i < hierarchy.length; i++)
{
this.currentObjectStreamClass = hierarchy[i];
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
{
dumpElementln ("no, got IOException");
}
}
+ else
+ {
+ readFields (obj, currentObjectStreamClass);
+ }
}
this.currentObject = null;
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;
}
- 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
{
- if (call_read_method)
- {
- 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;
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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);
}
}
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};
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);
}
}
- 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);
}
}
- 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);
}
}
- 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);
}
}
- 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);
}
}
- 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);
}
- 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);
}
- 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);
}
- 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
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 (currentObjectStreamClass.hasWriteMethod ())
+ {
+ setBlockDataMode (true);
+ callWriteMethod (obj, currentObjectStreamClass);
+ setBlockDataMode (false);
+ realOutput.writeByte (TC_ENDBLOCKDATA);
+ }
+ else
+ writeFields (obj, currentObjectStreamClass);
}
currentObject = null;
throws IOException, NotActiveException
{
markFieldsWritten ();
- writeFields (currentObject, currentObjectStreamClass.fields, false);
+ writeFields (currentObject, currentObjectStreamClass);
}
}
- // 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;
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);
}
- 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};
}
}
- private boolean getBooleanField (Object obj, String field_name)
+ 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;
}
}
- 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;
}
}
- 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;
}
}
- private double getDoubleField (Object obj, String field_name)
+ 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;
}
}
- private float getFloatField (Object obj, String field_name)
+ 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;
}
}
- 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;
}
}
- 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;
}
}
- private short getShortField (Object obj, String field_name)
+ 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;
}
}
- 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
}
+ // 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 ()
projects / gcc.git / commitdiff