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
is_consumed = true;
break;
}
-
+
case TC_BLOCKDATA:
case TC_BLOCKDATALONG:
{
- if (marker == TC_BLOCKDATALONG)
+ if (marker == TC_BLOCKDATALONG)
dumpElementln ("BLOCKDATALONG");
else
dumpElementln ("BLOCKDATA");
ret_val = null;
break;
}
-
+
case TC_REFERENCE:
{
dumpElement ("REFERENCE ");
this.objectLookupTable.get (oid)).object;
break;
}
-
+
case TC_CLASS:
{
dumpElementln ("CLASS");
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);
ret_val = osc;
break;
}
-
+
case TC_STRING:
case TC_LONGSTRING:
{
|| Modifier.isAbstract (first_nonserial.getModifiers ()))
first_nonserial = first_nonserial.getSuperclass ();
- // DEBUGln ("Using " + first_nonserial
- // + " as starting point for constructing " + clazz);
-
Object obj = null;
obj = newObject (clazz, first_nonserial);
ObjectStreamClass[] hierarchy =
ObjectStreamClass.getObjectStreamClasses (clazz);
- // DEBUGln ("Got class hierarchy of depth " + hierarchy.length);
-
boolean has_read;
for (int i=0; i < hierarchy.length; i++)
{
ret_val = processResolution (obj, handle);
break;
}
-
+
case TC_RESET:
dumpElementln ("RESET");
clearHandles ();
ret_val = readObject ();
break;
-
+
case TC_EXCEPTION:
{
dumpElement ("EXCEPTION=");
clearHandles ();
throw new WriteAbortedException ("Exception thrown during writing of stream", e);
}
-
+
default:
throw new IOException ("Unknown marker on stream: " + marker);
-
}
}
finally
return ret_val;
}
-
/**
Reads the current objects non-transient, non-static fields from
public int read () throws IOException
{
if (this.readDataFromBlock)
- {
- if (this.blockDataPosition >= this.blockDataBytes)
- readNextBlock ();
- return (this.blockData[this.blockDataPosition++] & 0xff);
- }
+ {
+ if (this.blockDataPosition >= this.blockDataBytes)
+ readNextBlock ();
+ return (this.blockData[this.blockDataPosition++] & 0xff);
+ }
else
return this.realInputStream.read ();
}
public int read (byte[] data, int offset, int length) throws IOException
{
if (this.readDataFromBlock)
- {
- if (this.blockDataPosition + length > this.blockDataBytes)
- {
- int remain = this.blockDataBytes - this.blockDataPosition;
- if (remain != 0)
- {
- System.arraycopy (this.blockData, this.blockDataPosition,
- data, offset, remain);
- offset += remain;
- length -= remain;
- }
- readNextBlock ();
- }
+ {
+ if (this.blockDataPosition + length > this.blockDataBytes)
+ {
+ int remain = this.blockDataBytes - this.blockDataPosition;
+ if (remain != 0)
+ {
+ System.arraycopy (this.blockData, this.blockDataPosition,
+ data, offset, remain);
+ offset += remain;
+ length -= remain;
+ }
+ readNextBlock ();
+ }
- System.arraycopy (this.blockData, this.blockDataPosition,
- data, offset, length);
- blockDataPosition += length;
+ System.arraycopy (this.blockData, this.blockDataPosition,
+ data, offset, length);
+ this.blockDataPosition += length;
- return length;
- }
+ return length;
+ }
else
return this.realInputStream.read (data, offset, length);
}
public int available () throws IOException
{
if (this.readDataFromBlock)
- {
- if (this.blockDataPosition >= this.blockDataBytes)
- readNextBlock ();
+ {
+ if (this.blockDataPosition >= this.blockDataBytes)
+ readNextBlock ();
- return this.blockDataBytes - this.blockDataPosition;
- }
+ return this.blockDataBytes - this.blockDataPosition;
+ }
else
return this.realInputStream.available ();
}
setBlockDataMode (oldmode);
return new GetField ()
- {
- public ObjectStreamClass getObjectStreamClass ()
{
- return clazz;
- }
+ public ObjectStreamClass getObjectStreamClass ()
+ {
+ return clazz;
+ }
- public boolean defaulted (String name)
- throws IOException, IllegalArgumentException
- {
- return clazz.getField (name) == null;
- }
+ public boolean defaulted (String name)
+ throws IOException, IllegalArgumentException
+ {
+ return clazz.getField (name) == null;
+ }
- public boolean get (String name, boolean defvalue)
- throws IOException, IllegalArgumentException
- {
- ObjectStreamField field = getField (name, Boolean.TYPE);
+ public boolean get (String name, boolean defvalue)
+ throws IOException, IllegalArgumentException
+ {
+ ObjectStreamField field = getField (name, Boolean.TYPE);
- if (field == null)
- return defvalue;
+ 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)
- throws IOException, IllegalArgumentException
- {
- ObjectStreamField field = getField (name, Character.TYPE);
+ public char get (String name, char defvalue)
+ throws IOException, IllegalArgumentException
+ {
+ ObjectStreamField field = getField (name, Character.TYPE);
- if (field == null)
- return defvalue;
+ 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));
- }
+ return (char)(((prim_field_data[off++] & 0xFF) << 8)
+ | (prim_field_data[off] & 0xFF));
+ }
- public byte get (String name, byte defvalue)
- throws IOException, IllegalArgumentException
- {
- ObjectStreamField field = getField (name, Byte.TYPE);
+ public byte get (String name, byte defvalue)
+ throws IOException, IllegalArgumentException
+ {
+ ObjectStreamField field = getField (name, Byte.TYPE);
- if (field == null)
- return defvalue;
+ if (field == null)
+ return defvalue;
- return prim_field_data[field.getOffset ()];
- }
+ return prim_field_data[field.getOffset ()];
+ }
- public short get (String name, short defvalue)
- throws IOException, IllegalArgumentException
- {
- ObjectStreamField field = getField (name, Short.TYPE);
+ public short get (String name, short defvalue)
+ throws IOException, IllegalArgumentException
+ {
+ ObjectStreamField field = getField (name, Short.TYPE);
- if (field == null)
- return defvalue;
+ 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));
- }
+ return (short)(((prim_field_data[off++] & 0xFF) << 8)
+ | (prim_field_data[off] & 0xFF));
+ }
- public int get (String name, int defvalue)
- throws IOException, IllegalArgumentException
- {
- ObjectStreamField field = getField (name, Integer.TYPE);
+ public int get (String name, int defvalue)
+ throws IOException, IllegalArgumentException
+ {
+ ObjectStreamField field = getField (name, Integer.TYPE);
- if (field == null)
- return defvalue;
+ 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)
- | ((prim_field_data[off++] & 0xFF) << 8)
- | (prim_field_data[off] & 0xFF);
- }
+ return ((prim_field_data[off++] & 0xFF) << 24)
+ | ((prim_field_data[off++] & 0xFF) << 16)
+ | ((prim_field_data[off++] & 0xFF) << 8)
+ | (prim_field_data[off] & 0xFF);
+ }
- public long get (String name, long defvalue)
- throws IOException, IllegalArgumentException
- {
- ObjectStreamField field = getField (name, Long.TYPE);
+ public long get (String name, long defvalue)
+ throws IOException, IllegalArgumentException
+ {
+ ObjectStreamField field = getField (name, Long.TYPE);
+
+ if (field == null)
+ return defvalue;
- 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)
+ | ((prim_field_data[off++] & 0xFF) << 40)
+ | ((prim_field_data[off++] & 0xFF) << 32)
+ | ((prim_field_data[off++] & 0xFF) << 24)
+ | ((prim_field_data[off++] & 0xFF) << 16)
+ | ((prim_field_data[off++] & 0xFF) << 8)
+ | (prim_field_data[off] & 0xFF));
+ }
+
+ public float get (String name, float defvalue)
+ throws IOException, IllegalArgumentException
+ {
+ ObjectStreamField field = getField (name, Float.TYPE);
+
+ if (field == null)
+ return defvalue;
+
+ 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));
+ }
+
+ public double get (String name, double defvalue)
+ throws IOException, IllegalArgumentException
+ {
+ ObjectStreamField field = getField (name, Double.TYPE);
+
+ if (field == null)
+ return defvalue;
- return (long)(((prim_field_data[off++] & 0xFF) << 56)
+ int off = field.getOffset ();
+
+ return Double.longBitsToDouble
+ ( (long) (((prim_field_data[off++] & 0xFF) << 56)
| ((prim_field_data[off++] & 0xFF) << 48)
| ((prim_field_data[off++] & 0xFF) << 40)
| ((prim_field_data[off++] & 0xFF) << 32)
| ((prim_field_data[off++] & 0xFF) << 24)
| ((prim_field_data[off++] & 0xFF) << 16)
| ((prim_field_data[off++] & 0xFF) << 8)
- | (prim_field_data[off] & 0xFF));
- }
-
- public float get (String name, float defvalue)
- throws IOException, IllegalArgumentException
- {
- ObjectStreamField field = getField (name, Float.TYPE);
-
- if (field == null)
- return defvalue;
-
- 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));
- }
-
- public double get (String name, double defvalue)
- throws IOException, IllegalArgumentException
- {
- ObjectStreamField field = getField (name, Double.TYPE);
-
- if (field == null)
- return defvalue;
-
- int off = field.getOffset ();
-
- return Double.longBitsToDouble (
- (long)(((prim_field_data[off++] & 0xFF) << 56)
- | ((prim_field_data[off++] & 0xFF) << 48)
- | ((prim_field_data[off++] & 0xFF) << 40)
- | ((prim_field_data[off++] & 0xFF) << 32)
- | ((prim_field_data[off++] & 0xFF) << 24)
- | ((prim_field_data[off++] & 0xFF) << 16)
- | ((prim_field_data[off++] & 0xFF) << 8)
- | (prim_field_data[off] & 0xFF)));
- }
+ | (prim_field_data[off] & 0xFF)));
+ }
- public Object get (String name, Object defvalue)
- throws IOException, IllegalArgumentException
- {
- ObjectStreamField field =
- getField (name, defvalue == null ? null : defvalue.getClass ());
+ public Object get (String name, Object defvalue)
+ throws IOException, IllegalArgumentException
+ {
+ ObjectStreamField field =
+ getField (name, defvalue == null ? null : defvalue.getClass ());
- if (field == null)
- return defvalue;
+ if (field == null)
+ return defvalue;
- return objs[field.getOffset ()];
- }
+ return objs[field.getOffset ()];
+ }
- private ObjectStreamField getField (String name, Class type)
- throws IllegalArgumentException
- {
- ObjectStreamField field = clazz.getField (name);
+ private ObjectStreamField getField (String name, Class type)
+ throws IllegalArgumentException
+ {
+ ObjectStreamField field = clazz.getField (name);
- if (field == null)
- return null;
+ if (field == null)
+ return null;
- Class field_type = field.getType ();
+ Class field_type = field.getType ();
- if (type == field_type ||
- (type == null && ! field_type.isPrimitive ()))
- return field;
+ if (type == field_type ||
+ (type == null && ! field_type.isPrimitive ()))
+ return field;
- throw new IllegalArgumentException ("Field requested is of type "
- + field_type.getName ()
- + ", but requested type was "
- + (type == null ?
- "Object" : type.getName ()));
- }
- };
+ throw new IllegalArgumentException ("Field requested is of type "
+ + field_type.getName ()
+ + ", but requested type was "
+ + (type == null ?
+ "Object" : type.getName ()));
+ }
+ };
}
private int assignNewHandle (Object obj)
{
this.objectLookupTable.put (new Integer (this.nextOID),
- new ObjectIdentityWrapper (obj));
-
-// try
-// {
-// DEBUG ("Assigning handle " + this.nextOID);
-// DEBUGln (" to " + obj);
-// }
-// catch (Throwable t) {}
-
+ new ObjectIdentityWrapper (obj));
return this.nextOID++;
}
{
Method m = null;
try
- {
- Class classArgs[] = {};
- m = obj.getClass ().getDeclaredMethod ("readResolve", classArgs);
- // 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[] {});
- }
+ {
+ Class classArgs[] = {};
+ m = obj.getClass ().getDeclaredMethod ("readResolve", classArgs);
+ // 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[] {});
+ }
catch (NoSuchMethodException ignore)
- {
- }
+ {
+ }
catch (IllegalAccessException ignore)
- {
- }
+ {
+ }
catch (InvocationTargetException ignore)
- {
- }
+ {
+ }
}
if (this.resolveEnabled)
private void readNextBlock () throws IOException
{
-// DEBUGln ("In readNextBlock ");
readNextBlock (this.realInputStream.readByte ());
}
private void readNextBlock (byte marker) throws IOException
{
if (marker == TC_BLOCKDATA)
- {
- dumpElement ("BLOCK DATA SIZE=");
- this.blockDataBytes = this.realInputStream.readUnsignedByte ();
- dumpElementln (Integer.toString(this.blockDataBytes));
- }
+ {
+ 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 ();
- dumpElementln (Integer.toString(this.blockDataBytes));
- }
+ {
+ 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)
this.blockData = new byte[this.blockDataBytes];
throws ClassNotFoundException, IOException
{
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 ();
- 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 ();
- 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 ();
- 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 ();
- 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 ();
- 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 ();
- 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 ();
- return;
+ if (clazz == Boolean.TYPE)
+ {
+ boolean[] cast_array = (boolean[])array;
+ for (int i=0; i < cast_array.length; i++)
+ 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 ();
+ 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 ();
+ 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 ();
+ 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 ();
+ 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 ();
+ 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 ();
+ 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 ();
+ return;
+ }
}
- if (clazz == Short.TYPE)
+ else
{
- short[] cast_array = (short[])array;
+ Object[] cast_array = (Object[])array;
for (int i=0; i < cast_array.length; i++)
- cast_array[i] = this.realInputStream.readShort ();
- return;
- }
- }
- else
- {
- Object[] cast_array = (Object[])array;
- for (int i=0; i < cast_array.length; i++)
cast_array[i] = readObject ();
- }
+ }
}
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;
- }
+ {
+ fieldsAlreadyRead = false;
+ boolean oldmode = setBlockDataMode (true);
+ callReadMethod (obj, stream_osc.forClass ());
+ setBlockDataMode (oldmode);
+ return;
+ }
ObjectStreamField[] real_fields =
ObjectStreamClass.lookup (stream_osc.forClass ()).fields;
while (stream_idx < stream_fields.length
&& real_idx < real_fields.length)
- {
- default_initialize = false;
- set_value = true;
-
- if (stream_idx == stream_fields.length)
- default_initialize = true;
- else
- {
- stream_field = stream_fields[stream_idx];
- type = stream_field.getType ();
- }
-
- if (real_idx == real_fields.length)
- set_value = false;
- else
{
- real_field = real_fields[real_idx];
- type = real_field.getType ();
- field_name = real_field.getName ();
- }
+ default_initialize = false;
+ set_value = true;
- if (set_value && !default_initialize)
- {
- int comp_val =
- real_field.compareTo (stream_field);
-
- if (comp_val < 0)
- {
+ if (stream_idx == stream_fields.length)
default_initialize = true;
- real_idx++;
- }
- else if (comp_val > 0)
- {
+ else
+ {
+ stream_field = stream_fields[stream_idx];
+ type = stream_field.getType ();
+ }
+
+ if (real_idx == real_fields.length)
set_value = false;
- stream_idx++;
- }
else
- {
- real_idx++;
- stream_idx++;
- }
- }
+ {
+ real_field = real_fields[real_idx];
+ type = real_field.getType ();
+ field_name = real_field.getName ();
+ }
- try
- {
- if (type == Boolean.TYPE)
- {
- boolean value =
- default_initialize ? false : this.realInputStream.readBoolean ();
- if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
- if (set_value)
- setBooleanField (obj, field_name, value);
- }
- else if (type == Byte.TYPE)
- {
- byte value =
- default_initialize ? 0 : this.realInputStream.readByte ();
- if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
- if (set_value)
- setByteField (obj, field_name, value);
- }
- else if (type == Character.TYPE)
- {
- char value =
- default_initialize ? (char)0 : this.realInputStream.readChar ();
- if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
- if (set_value)
- setCharField (obj, field_name, value);
- }
- else if (type == Double.TYPE)
- {
- double value =
- default_initialize ? 0 : this.realInputStream.readDouble ();
- if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
- if (set_value)
- setDoubleField (obj, field_name, value);
- }
- else if (type == Float.TYPE)
- {
- float value =
- default_initialize ? 0 : this.realInputStream.readFloat ();
- if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
- if (set_value)
- setFloatField (obj, field_name, value);
- }
- else if (type == Integer.TYPE)
- {
- int value =
- default_initialize ? 0 : this.realInputStream.readInt ();
- if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
- if (set_value)
- setIntField (obj, field_name, value);
- }
- else if (type == Long.TYPE)
- {
- long value =
- default_initialize ? 0 : this.realInputStream.readLong ();
- if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
- if (set_value)
- setLongField (obj, field_name, value);
- }
- else if (type == Short.TYPE)
- {
- short value =
- default_initialize ? (short)0 : this.realInputStream.readShort ();
- if (!default_initialize && set_value)
- dumpElementln (" " + field_name + ": " + value);
- if (set_value)
- setShortField (obj, field_name, value);
- }
- else
- {
- Object value =
- default_initialize ? null : readObject ();
- if (set_value)
- setObjectField (obj, field_name,
- real_field.getTypeString (), value);
- }
- }
- catch (NoSuchFieldError e)
- {
- dumpElementln("XXXX " + field_name + " does not exist.");
- }
- }
- }
+ if (set_value && !default_initialize)
+ {
+ int comp_val =
+ real_field.compareTo (stream_field);
+
+ if (comp_val < 0)
+ {
+ default_initialize = true;
+ real_idx++;
+ }
+ else if (comp_val > 0)
+ {
+ set_value = false;
+ stream_idx++;
+ }
+ else
+ {
+ real_idx++;
+ stream_idx++;
+ }
+ }
+ try
+ {
+ if (type == Boolean.TYPE)
+ {
+ boolean value =
+ default_initialize ? false : this.realInputStream.readBoolean ();
+ if (!default_initialize && set_value)
+ dumpElementln (" " + field_name + ": " + value);
+ if (set_value)
+ setBooleanField (obj, field_name, value);
+ }
+ else if (type == Byte.TYPE)
+ {
+ byte value =
+ default_initialize ? 0 : this.realInputStream.readByte ();
+ if (!default_initialize && set_value)
+ dumpElementln (" " + field_name + ": " + value);
+ if (set_value)
+ setByteField (obj, field_name, value);
+ }
+ else if (type == Character.TYPE)
+ {
+ char value =
+ default_initialize ? (char)0 : this.realInputStream.readChar ();
+ if (!default_initialize && set_value)
+ dumpElementln (" " + field_name + ": " + value);
+ if (set_value)
+ setCharField (obj, field_name, value);
+ }
+ else if (type == Double.TYPE)
+ {
+ double value =
+ default_initialize ? 0 : this.realInputStream.readDouble ();
+ if (!default_initialize && set_value)
+ dumpElementln (" " + field_name + ": " + value);
+ if (set_value)
+ setDoubleField (obj, field_name, value);
+ }
+ else if (type == Float.TYPE)
+ {
+ float value =
+ default_initialize ? 0 : this.realInputStream.readFloat ();
+ if (!default_initialize && set_value)
+ dumpElementln (" " + field_name + ": " + value);
+ if (set_value)
+ setFloatField (obj, field_name, value);
+ }
+ else if (type == Integer.TYPE)
+ {
+ int value =
+ default_initialize ? 0 : this.realInputStream.readInt ();
+ if (!default_initialize && set_value)
+ dumpElementln (" " + field_name + ": " + value);
+ if (set_value)
+ setIntField (obj, field_name, value);
+ }
+ else if (type == Long.TYPE)
+ {
+ long value =
+ default_initialize ? 0 : this.realInputStream.readLong ();
+ if (!default_initialize && set_value)
+ dumpElementln (" " + field_name + ": " + value);
+ if (set_value)
+ setLongField (obj, field_name, value);
+ }
+ else if (type == Short.TYPE)
+ {
+ short value =
+ default_initialize ? (short)0 : this.realInputStream.readShort ();
+ if (!default_initialize && set_value)
+ dumpElementln (" " + field_name + ": " + value);
+ if (set_value)
+ setShortField (obj, field_name, value);
+ }
+ else
+ {
+ Object value =
+ default_initialize ? null : readObject ();
+ if (set_value)
+ setObjectField (obj, field_name,
+ real_field.getTypeString (), value);
+ }
+ }
+ catch (NoSuchFieldError e)
+ {
+ dumpElementln("XXXX " + field_name + " does not exist.");
+ }
+ }
+ }
// Toggles writing primitive data to block-data buffer.
private boolean setBlockDataMode (boolean on)
{
-// DEBUGln ("Setting block data mode to " + on);
boolean oldmode = this.readDataFromBlock;
this.readDataFromBlock = on;
private Object newObject (Class real_class, Class constructor_class)
{
try
- {
- Object obj = allocateObject (real_class);
- callConstructor (constructor_class, obj);
- return obj;
- }
+ {
+ Object obj = allocateObject (real_class);
+ callConstructor (constructor_class, obj);
+ return obj;
+ }
catch (InstantiationException e)
- {
- return null;
- }
+ {
+ return null;
+ }
}
Arrays.sort (validators);
try
- {
- for (int i=0; i < validators.length; i++)
- ((ObjectInputValidation)validators[i]).validateObject ();
- }
+ {
+ for (int i=0; i < validators.length; i++)
+ ((ObjectInputValidation)validators[i]).validateObject ();
+ }
finally
- {
- this.validators.removeAllElements ();
- }
+ {
+ this.validators.removeAllElements ();
+ }
}
{
return klass.getDeclaredField(name);
}
-
+
private static Method getMethod (Class klass, String name, Class args[])
throws java.lang.NoSuchMethodException
{
return klass.getDeclaredMethod(name, args);
}
-
+
private void callReadMethod (Object obj, Class klass) throws IOException
{
try
}
private void setByteField (Object obj, String field_name,
- byte val)
+ byte val)
{
try
{
}
private void setIntField (Object obj, String field_name,
- int val)
+ int val)
{
try
{
private void setLongField (Object obj, String field_name,
- long val)
+ long val)
{
try
{
private boolean fieldsAlreadyRead;
private Vector validators;
- private static boolean dump;
+ private static boolean dump;
private void dumpElement (String msg)
{
}
static
- {
- if (Configuration.INIT_LOAD_LIBRARY)
- {
- System.loadLibrary ("javaio");
- }
- }
+ {
+ if (Configuration.INIT_LOAD_LIBRARY)
+ {
+ System.loadLibrary ("javaio");
+ }
+ }
}
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
in a graph lost.
Example usage:
- Hashtable map = new Hashtable ();
- map.put ("one", new Integer (1));
- map.put ("two", new Integer (2));
+ <pre>
+ Hashtable map = new Hashtable ();
+ map.put ("one", new Integer (1));
+ map.put ("two", new Integer (2));
- ObjectOutputStream oos =
- new ObjectOutputStream (new FileOutputStream ("numbers"));
- oos.writeObject (map);
- oos.close ();
+ ObjectOutputStream oos =
+ new ObjectOutputStream (new FileOutputStream ("numbers"));
+ oos.writeObject (map);
+ oos.close ();
- ObjectInputStream ois =
- new ObjectInputStream (new FileInputStream ("numbers"));
- Hashtable newmap = (Hashtable)ois.readObject ();
+ ObjectInputStream ois =
+ new ObjectInputStream (new FileInputStream ("numbers"));
+ Hashtable newmap = (Hashtable)ois.readObject ();
- System.out.println (newmap);
- </pre>
+ System.out.println (newmap);
+ </pre>
The default serialization can be overriden in two ways.
realOutput.writeByte (TC_NULL);
break;
}
-
+
Integer handle = findHandle (obj);
if (handle != null)
{
realOutput.writeInt (handle.intValue ());
break;
}
-
+
if (obj instanceof Class)
{
Class cl = (Class)obj;
- ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject(cl);
+ ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject (cl);
assignNewHandle (obj);
realOutput.writeByte (TC_CLASS);
if (!osc.isProxyClass)
{
- writeObject(osc);
+ writeObject (osc);
}
else
{
}
break;
}
-
+
if (obj instanceof ObjectStreamClass)
{
ObjectStreamClass osc = (ObjectStreamClass)obj;
realOutput.writeUTF (osc.getName ());
realOutput.writeLong (osc.getSerialVersionUID ());
assignNewHandle (obj);
-
+
int flags = osc.getFlags ();
-
+
if (protocolVersion == PROTOCOL_VERSION_2
&& osc.isExternalizable ())
flags |= SC_BLOCK_DATA;
-
+
realOutput.writeByte (flags);
-
+
ObjectStreamField[] fields = osc.fields;
realOutput.writeShort (fields.length);
-
+
ObjectStreamField field;
for (int i=0; i < fields.length; i++)
{
field = fields[i];
realOutput.writeByte (field.getTypeCode ());
realOutput.writeUTF (field.getName ());
-
+
if (! field.isPrimitive ())
writeObject (field.getTypeString ());
}
-
+
boolean oldmode = setBlockDataMode (true);
annotateClass (osc.forClass ());
setBlockDataMode (oldmode);
realOutput.writeByte (TC_ENDBLOCKDATA);
-
+
if (osc.isSerializable ())
writeObject (osc.getSuper ());
else
writeObject (null);
break;
}
-
+
if ((replacementEnabled || obj instanceof Serializable)
&& ! replaceDone)
{
replacedObject = obj;
-
+
if (obj instanceof Serializable)
{
Method m = null;
{
}
}
-
+
if (replacementEnabled)
obj = replaceObject (obj);
-
+
replaceDone = true;
continue;
}
-
+
if (obj instanceof String)
{
realOutput.writeByte (TC_STRING);
realOutput.writeUTF ((String)obj);
break;
}
-
+
Class clazz = obj.getClass ();
ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject (clazz);
if (osc == null)
throw new NotSerializableException (clazz.getName ());
-
+
if (clazz.isArray ())
{
realOutput.writeByte (TC_ARRAY);
writeArraySizeAndElements (obj, clazz.getComponentType ());
break;
}
-
+
realOutput.writeByte (TC_OBJECT);
writeObject (osc);
-
+
if (replaceDone)
assignNewHandle (replacedObject);
else
assignNewHandle (obj);
-
+
if (obj instanceof Externalizable)
{
if (protocolVersion == PROTOCOL_VERSION_2)
setBlockDataMode (true);
-
+
((Externalizable)obj).writeExternal (this);
-
+
if (protocolVersion == PROTOCOL_VERSION_2)
{
setBlockDataMode (false);
realOutput.writeByte (TC_ENDBLOCKDATA);
}
-
+
break;
}
-
+
if (obj instanceof Serializable)
{
currentObject = obj;
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);
-
}
-
+
currentObject = null;
currentObjectStreamClass = null;
currentPutField = null;
break;
}
-
+
throw new NotSerializableException (clazz.getName ());
} // end pseudo-loop
}
{
throw new StreamCorruptedException ("Exception " + ioe + " thrown while exception was being written to stream.");
}
-
+
reset (true);
}
finally
{
isSerializing = was_serializing;
-
setBlockDataMode (old_mode);
}
}
-
/**
Writes the current objects non-transient, non-static fields from
the current class to the underlying output stream.
private void reset (boolean internal) throws IOException
{
if (!internal)
- {
- if (isSerializing)
- throw new IOException ("Reset called while serialization in progress");
+ {
+ if (isSerializing)
+ throw new IOException ("Reset called while serialization in progress");
- realOutput.writeByte (TC_RESET);
- }
+ realOutput.writeByte (TC_RESET);
+ }
clearHandles ();
}
public void write (int data) throws IOException
{
if (writeDataAsBlocks)
- {
- if (blockDataCount == BUFFER_SIZE)
- drain ();
+ {
+ if (blockDataCount == BUFFER_SIZE)
+ drain ();
- blockData[ blockDataCount++ ] = (byte)data;
- }
+ blockData[ blockDataCount++ ] = (byte)data;
+ }
else
realOutput.write (data);
}
public void write (byte[] b, int off, int len) throws IOException
{
if (writeDataAsBlocks)
- {
- if (len < 0)
- throw new IndexOutOfBoundsException ();
-
- if (blockDataCount + len < BUFFER_SIZE)
- {
- System.arraycopy (b, off, blockData, blockDataCount, len);
- blockDataCount += len;
- }
- else
{
- drain ();
- writeBlockDataHeader (len);
- realOutput.write (b, off, len);
+ if (len < 0)
+ throw new IndexOutOfBoundsException ();
+
+ if (blockDataCount + len < BUFFER_SIZE)
+ {
+ System.arraycopy (b, off, blockData, blockDataCount, len);
+ blockDataCount += len;
+ }
+ else
+ {
+ drain ();
+ writeBlockDataHeader (len);
+ realOutput.write (b, off, len);
+ }
}
- }
else
realOutput.write (b, off, len);
}
currentPutField = new PutField ()
{
private byte[] prim_field_data
- = new byte[currentObjectStreamClass.primFieldSize];
+ = new byte[currentObjectStreamClass.primFieldSize];
private Object[] objs
- = new Object[currentObjectStreamClass.objectFieldCount];
+ = new Object[currentObjectStreamClass.objectFieldCount];
public void put (String name, boolean value)
throws IOException, IllegalArgumentException
- {
- ObjectStreamField field
- = currentObjectStreamClass.getField (name);
- checkType (field, 'Z');
- prim_field_data[field.getOffset ()] = (byte)(value ? 1 : 0);
- }
+ {
+ ObjectStreamField field
+ = currentObjectStreamClass.getField (name);
+ checkType (field, 'Z');
+ prim_field_data[field.getOffset ()] = (byte)(value ? 1 : 0);
+ }
public void put (String name, byte value)
throws IOException, IllegalArgumentException
- {
- ObjectStreamField field
- = currentObjectStreamClass.getField (name);
- checkType (field, 'B');
- prim_field_data[field.getOffset ()] = value;
- }
+ {
+ ObjectStreamField field
+ = currentObjectStreamClass.getField (name);
+ checkType (field, 'B');
+ prim_field_data[field.getOffset ()] = value;
+ }
public void put (String name, char value)
throws IOException, IllegalArgumentException
- {
- ObjectStreamField field
- = currentObjectStreamClass.getField (name);
- checkType (field, 'C');
- int off = field.getOffset ();
- prim_field_data[off++] = (byte)(value >>> 8);
- prim_field_data[off] = (byte)value;
- }
+ {
+ ObjectStreamField field
+ = currentObjectStreamClass.getField (name);
+ checkType (field, 'C');
+ int off = field.getOffset ();
+ prim_field_data[off++] = (byte)(value >>> 8);
+ prim_field_data[off] = (byte)value;
+ }
public void put (String name, double value)
throws IOException, IllegalArgumentException
- {
- ObjectStreamField field
- = currentObjectStreamClass.getField (name);
- checkType (field, 'D');
- int off = field.getOffset ();
- long l_value = Double.doubleToLongBits (value);
- prim_field_data[off++] = (byte)(l_value >>> 52);
- prim_field_data[off++] = (byte)(l_value >>> 48);
- prim_field_data[off++] = (byte)(l_value >>> 40);
- prim_field_data[off++] = (byte)(l_value >>> 32);
- prim_field_data[off++] = (byte)(l_value >>> 24);
- prim_field_data[off++] = (byte)(l_value >>> 16);
- prim_field_data[off++] = (byte)(l_value >>> 8);
- prim_field_data[off] = (byte)l_value;
- }
+ {
+ ObjectStreamField field
+ = currentObjectStreamClass.getField (name);
+ checkType (field, 'D');
+ int off = field.getOffset ();
+ long l_value = Double.doubleToLongBits (value);
+ prim_field_data[off++] = (byte)(l_value >>> 52);
+ prim_field_data[off++] = (byte)(l_value >>> 48);
+ prim_field_data[off++] = (byte)(l_value >>> 40);
+ prim_field_data[off++] = (byte)(l_value >>> 32);
+ prim_field_data[off++] = (byte)(l_value >>> 24);
+ prim_field_data[off++] = (byte)(l_value >>> 16);
+ prim_field_data[off++] = (byte)(l_value >>> 8);
+ prim_field_data[off] = (byte)l_value;
+ }
public void put (String name, float value)
throws IOException, IllegalArgumentException
- {
- ObjectStreamField field
- = currentObjectStreamClass.getField (name);
- checkType (field, 'F');
- int off = field.getOffset ();
- int i_value = Float.floatToIntBits (value);
- prim_field_data[off++] = (byte)(i_value >>> 24);
- prim_field_data[off++] = (byte)(i_value >>> 16);
- prim_field_data[off++] = (byte)(i_value >>> 8);
- prim_field_data[off] = (byte)i_value;
- }
+ {
+ ObjectStreamField field
+ = currentObjectStreamClass.getField (name);
+ checkType (field, 'F');
+ int off = field.getOffset ();
+ int i_value = Float.floatToIntBits (value);
+ prim_field_data[off++] = (byte)(i_value >>> 24);
+ prim_field_data[off++] = (byte)(i_value >>> 16);
+ prim_field_data[off++] = (byte)(i_value >>> 8);
+ prim_field_data[off] = (byte)i_value;
+ }
public void put (String name, int value)
throws IOException, IllegalArgumentException
- {
- ObjectStreamField field
- = currentObjectStreamClass.getField (name);
- checkType (field, 'I');
- int off = field.getOffset ();
- prim_field_data[off++] = (byte)(value >>> 24);
- prim_field_data[off++] = (byte)(value >>> 16);
- prim_field_data[off++] = (byte)(value >>> 8);
- prim_field_data[off] = (byte)value;
- }
+ {
+ ObjectStreamField field
+ = currentObjectStreamClass.getField (name);
+ checkType (field, 'I');
+ int off = field.getOffset ();
+ prim_field_data[off++] = (byte)(value >>> 24);
+ prim_field_data[off++] = (byte)(value >>> 16);
+ prim_field_data[off++] = (byte)(value >>> 8);
+ prim_field_data[off] = (byte)value;
+ }
public void put (String name, long value)
throws IOException, IllegalArgumentException
- {
- ObjectStreamField field
- = currentObjectStreamClass.getField (name);
- checkType (field, 'J');
- int off = field.getOffset ();
- prim_field_data[off++] = (byte)(value >>> 52);
- prim_field_data[off++] = (byte)(value >>> 48);
- prim_field_data[off++] = (byte)(value >>> 40);
- prim_field_data[off++] = (byte)(value >>> 32);
- prim_field_data[off++] = (byte)(value >>> 24);
- prim_field_data[off++] = (byte)(value >>> 16);
- prim_field_data[off++] = (byte)(value >>> 8);
- prim_field_data[off] = (byte)value;
- }
+ {
+ ObjectStreamField field
+ = currentObjectStreamClass.getField (name);
+ checkType (field, 'J');
+ int off = field.getOffset ();
+ prim_field_data[off++] = (byte)(value >>> 52);
+ prim_field_data[off++] = (byte)(value >>> 48);
+ prim_field_data[off++] = (byte)(value >>> 40);
+ prim_field_data[off++] = (byte)(value >>> 32);
+ prim_field_data[off++] = (byte)(value >>> 24);
+ prim_field_data[off++] = (byte)(value >>> 16);
+ prim_field_data[off++] = (byte)(value >>> 8);
+ prim_field_data[off] = (byte)value;
+ }
public void put (String name, short value)
throws IOException, IllegalArgumentException
- {
- ObjectStreamField field
- = currentObjectStreamClass.getField (name);
- checkType (field, 'S');
- int off = field.getOffset ();
- prim_field_data[off++] = (byte)(value >>> 8);
- prim_field_data[off] = (byte)value;
- }
+ {
+ ObjectStreamField field
+ = currentObjectStreamClass.getField (name);
+ checkType (field, 'S');
+ int off = field.getOffset ();
+ prim_field_data[off++] = (byte)(value >>> 8);
+ prim_field_data[off] = (byte)value;
+ }
public void put (String name, Object value)
throws IOException, IllegalArgumentException
- {
- ObjectStreamField field
- = currentObjectStreamClass.getField (name);
- if (field == null)
- throw new IllegalArgumentException ();
- if (value != null &&
- ! field.getType ().isAssignableFrom (value.getClass ()))
- throw new IllegalArgumentException ();
- objs[field.getOffset ()] = value;
- }
+ {
+ ObjectStreamField field
+ = currentObjectStreamClass.getField (name);
+ if (field == null)
+ throw new IllegalArgumentException ();
+ if (value != null &&
+ ! field.getType ().isAssignableFrom (value.getClass ()))
+ throw new IllegalArgumentException ();
+ objs[field.getOffset ()] = value;
+ }
public void write (ObjectOutput out) throws IOException
- {
- // Apparently Block data is not used with PutField as per
- // empirical evidence against JDK 1.2. Also see Mauve test
- // java.io.ObjectInputOutput.Test.GetPutField.
- boolean oldmode = setBlockDataMode (false);
- out.write (prim_field_data);
- for (int i = 0; i < objs.length; ++ i)
- out.writeObject (objs[i]);
- setBlockDataMode (oldmode);
- }
+ {
+ // Apparently Block data is not used with PutField as per
+ // empirical evidence against JDK 1.2. Also see Mauve test
+ // java.io.ObjectInputOutput.Test.GetPutField.
+ boolean oldmode = setBlockDataMode (false);
+ out.write (prim_field_data);
+ for (int i = 0; i < objs.length; ++ i)
+ out.writeObject (objs[i]);
+ setBlockDataMode (oldmode);
+ }
private void checkType (ObjectStreamField field, char type)
throws IllegalArgumentException
- {
- if (TypeSignature.getEncodingOfClass (field.getType ()).charAt (0) != type)
- throw new IllegalArgumentException ();
- }
+ {
+ if (TypeSignature.getEncodingOfClass (field.getType ()).charAt (0) != type)
+ throw new IllegalArgumentException ();
+ }
};
// end PutFieldImpl
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);
+ }
}
int length = Array.getLength (array);
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]);
- return;
- }
- if (clazz == Byte.TYPE)
- {
- byte[] cast_array = (byte[])array;
- 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]);
- 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]);
- 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]);
- 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]);
- 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]);
- return;
+ if (clazz == Boolean.TYPE)
+ {
+ boolean[] cast_array = (boolean[])array;
+ realOutput.writeInt (length);
+ 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.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]);
+ 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]);
+ 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]);
+ 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]);
+ 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]);
+ 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]);
+ return;
+ }
}
- if (clazz == Short.TYPE)
+ else
{
- short[] cast_array = (short[])array;
+ Object[] cast_array = (Object[])array;
realOutput.writeInt (length);
for (int i=0; i < length; i++)
- realOutput.writeShort (cast_array[i]);
- return;
+ writeObject (cast_array[i]);
}
- }
- else
- {
- Object[] cast_array = (Object[])array;
- realOutput.writeInt (length);
- for (int i=0; i < length; i++)
- writeObject (cast_array[i]);
- }
}
boolean call_write_method) throws IOException
{
if (call_write_method)
- {
- setBlockDataMode (true);
- callWriteMethod (obj);
- setBlockDataMode (false);
- realOutput.writeByte (TC_ENDBLOCKDATA);
- return;
- }
+ {
+ setBlockDataMode (true);
+ callWriteMethod (obj);
+ setBlockDataMode (false);
+ realOutput.writeByte (TC_ENDBLOCKDATA);
+ return;
+ }
boolean oldmode = setBlockDataMode (false);
String field_name;
Class type;
for (int i=0; i < fields.length; i++)
- {
- field_name = fields[i].getName ();
- type = fields[i].getType ();
-
- if (type == Boolean.TYPE)
- realOutput.writeBoolean (getBooleanField (obj, field_name));
- else if (type == Byte.TYPE)
- realOutput.writeByte (getByteField (obj, field_name));
- else if (type == Character.TYPE)
- realOutput.writeChar (getCharField (obj, field_name));
- else if (type == Double.TYPE)
- realOutput.writeDouble (getDoubleField (obj, field_name));
- else if (type == Float.TYPE)
- realOutput.writeFloat (getFloatField (obj, field_name));
- else if (type == Integer.TYPE)
- realOutput.writeInt (getIntField (obj, field_name));
- else if (type == Long.TYPE)
- realOutput.writeLong (getLongField (obj, field_name));
- else if (type == Short.TYPE)
- realOutput.writeShort (getShortField (obj, field_name));
- else
- writeObject (getObjectField (obj, field_name,
- fields[i].getTypeString ()));
- }
- setBlockDataMode(oldmode);
+ {
+ field_name = fields[i].getName ();
+ type = fields[i].getType ();
+
+ if (type == Boolean.TYPE)
+ realOutput.writeBoolean (getBooleanField (obj, field_name));
+ else if (type == Byte.TYPE)
+ realOutput.writeByte (getByteField (obj, field_name));
+ else if (type == Character.TYPE)
+ realOutput.writeChar (getCharField (obj, field_name));
+ else if (type == Double.TYPE)
+ realOutput.writeDouble (getDoubleField (obj, field_name));
+ else if (type == Float.TYPE)
+ realOutput.writeFloat (getFloatField (obj, field_name));
+ else if (type == Integer.TYPE)
+ realOutput.writeInt (getIntField (obj, field_name));
+ else if (type == Long.TYPE)
+ realOutput.writeLong (getLongField (obj, field_name));
+ else if (type == Short.TYPE)
+ realOutput.writeShort (getShortField (obj, field_name));
+ else
+ writeObject (getObjectField (obj, field_name,
+ fields[i].getTypeString ()));
+ }
+ setBlockDataMode (oldmode);
}
}
}
- private boolean getBooleanField (Object obj, String field_name) throws IOException
+ private boolean getBooleanField (Object obj, String field_name)
+ throws IOException
{
try
{
}
}
- private double getDoubleField (Object obj, String field_name) throws IOException
+ private double getDoubleField (Object obj, String field_name)
+ throws IOException
{
try
{
}
}
- private float getFloatField (Object obj, String field_name) throws IOException
+ private float getFloatField (Object obj, String field_name)
+ throws IOException
{
try
{
}
}
- private short getShortField (Object obj, String field_name) throws IOException
+ private short getShortField (Object obj, String field_name)
+ throws IOException
{
try
{
{
return klass.getDeclaredField(name);
}
-
+
private static Method getMethod (Class klass, String name, Class[] args)
throws java.lang.NoSuchMethodException
{
return klass.getDeclaredMethod(name, args);
}
-
+
// this value comes from 1.2 spec, but is used in 1.1 as well
private final static int BUFFER_SIZE = 1024;
OSDN Git Service
