PatchSet 4256
Date: 2004/01/01 10:29:04
Author: guilhem
Branch: HEAD
Tag: (none)
Log:
Merged some files from Classpath.
Members:
ChangeLog:1.1843->1.1844
libraries/javalib/java/io/ObjectOutputStream.java:1.19->1.20
libraries/javalib/java/util/Random.java:1.9->1.10
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.1843 kaffe/ChangeLog:1.1844
--- kaffe/ChangeLog:1.1843 Wed Dec 31 16:54:58 2003
+++ kaffe/ChangeLog Thu Jan 1 10:29:04 2004
@@ -1,3 +1,9 @@
+2004-01-01 Guilhem Lavaux <[EMAIL PROTECTED]>
+
+ * libraries/javalib/java/io/ObjectOutputStream.java,
+ libraries/javalib/java/util/Random.java: Merged from
+ Classpath.
+
2003-12-31 Guilhem Lavaux <[EMAIL PROTECTED]>
* libraries/javalib/java/math/BigDecimal.java
Index: kaffe/libraries/javalib/java/io/ObjectOutputStream.java
diff -u kaffe/libraries/javalib/java/io/ObjectOutputStream.java:1.19
kaffe/libraries/javalib/java/io/ObjectOutputStream.java:1.20
--- kaffe/libraries/javalib/java/io/ObjectOutputStream.java:1.19 Tue Dec 23
20:18:55 2003
+++ kaffe/libraries/javalib/java/io/ObjectOutputStream.java Thu Jan 1 10:29:06
2004
@@ -132,18 +132,18 @@
*/
public ObjectOutputStream (OutputStream out) throws IOException
{
- realOutput = new DataOutputStream (out);
+ realOutput = new DataOutputStream(out);
blockData = new byte[ BUFFER_SIZE ];
blockDataCount = 0;
- blockDataOutput = new DataOutputStream (this);
- setBlockDataMode (true);
+ blockDataOutput = new DataOutputStream(this);
+ setBlockDataMode(true);
replacementEnabled = false;
isSerializing = false;
nextOID = baseWireHandle;
- OIDLookupTable = new Hashtable ();
+ OIDLookupTable = new Hashtable();
protocolVersion = defaultProtocolVersion;
useSubclassMethod = false;
- writeStreamHeader ();
+ writeStreamHeader();
}
/**
@@ -168,16 +168,16 @@
* @exception IOException Exception from underlying
* <code>OutputStream</code>.
*/
- public final void writeObject (Object obj) throws IOException
+ public final void writeObject(Object obj) throws IOException
{
if (useSubclassMethod)
{
- writeObjectOverride (obj);
+ writeObjectOverride(obj);
return;
}
boolean was_serializing = isSerializing;
- boolean old_mode = setBlockDataMode (false);
+ boolean old_mode = setBlockDataMode(false);
try
{
isSerializing = true;
@@ -188,49 +188,49 @@
{
if (obj == null)
{
- realOutput.writeByte (TC_NULL);
+ realOutput.writeByte(TC_NULL);
break;
}
- Integer handle = findHandle (obj);
+ Integer handle = findHandle(obj);
if (handle != null)
{
- realOutput.writeByte (TC_REFERENCE);
- realOutput.writeInt (handle.intValue ());
+ realOutput.writeByte(TC_REFERENCE);
+ realOutput.writeInt(handle.intValue());
break;
}
if (obj instanceof Class)
{
Class cl = (Class)obj;
- ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject (cl);
- assignNewHandle (obj);
- realOutput.writeByte (TC_CLASS);
+ ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject(cl);
+ assignNewHandle(obj);
+ realOutput.writeByte(TC_CLASS);
if (!osc.isProxyClass)
{
writeObject (osc);
}
else
{
- realOutput.writeByte (TC_PROXYCLASSDESC);
+ realOutput.writeByte(TC_PROXYCLASSDESC);
Class[] intfs = cl.getInterfaces();
realOutput.writeInt(intfs.length);
for (int i = 0; i < intfs.length; i++)
realOutput.writeUTF(intfs[i].getName());
- boolean oldmode = setBlockDataMode (true);
+ boolean oldmode = setBlockDataMode(true);
annotateProxyClass(cl);
- setBlockDataMode (oldmode);
+ setBlockDataMode(oldmode);
realOutput.writeByte(TC_ENDBLOCKDATA);
- writeObject (osc.getSuper());
+ writeObject(osc.getSuper());
}
break;
}
if (obj instanceof ObjectStreamClass)
{
- writeClassDescriptor ((ObjectStreamClass) obj);
+ writeClassDescriptor((ObjectStreamClass) obj);
break;
}
@@ -238,7 +238,7 @@
&& ! replaceDone)
{
replacedObject = obj;
-
+
if (obj instanceof Serializable)
{
Method m = null;
@@ -250,7 +250,7 @@
// m can't be null by definition since an
// exception would have been thrown so a check
// for null is not needed.
- obj = m.invoke (obj, new Object[] {});
+ obj = m.invoke(obj, new Object[] {});
}
catch (NoSuchMethodException ignore)
{
@@ -262,55 +262,55 @@
{
}
}
-
+
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;
@@ -320,22 +320,22 @@
{
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;
@@ -344,7 +344,7 @@
break;
}
- throw new NotSerializableException (clazz.getName ());
+ throw new NotSerializableException(clazz.getName ());
} // end pseudo-loop
}
catch (ObjectStreamException ose)
@@ -354,17 +354,18 @@
}
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 was being written to stream.");
+ throw new StreamCorruptedException
+ ("Exception " + ioe + " thrown while exception was being written to
stream.");
}
reset (true);
@@ -373,224 +374,227 @@
finally
{
isSerializing = was_serializing;
- setBlockDataMode (old_mode);
+ setBlockDataMode(old_mode);
}
}
- protected void writeClassDescriptor (ObjectStreamClass osc) throws IOException
+ protected void writeClassDescriptor(ObjectStreamClass osc) throws IOException
{
- realOutput.writeByte (TC_CLASSDESC);
- realOutput.writeUTF (osc.getName ());
- realOutput.writeLong (osc.getSerialVersionUID ());
- assignNewHandle (osc);
+ realOutput.writeByte(TC_CLASSDESC);
+ realOutput.writeUTF(osc.getName());
+ realOutput.writeLong(osc.getSerialVersionUID());
+ assignNewHandle(osc);
- int flags = osc.getFlags ();
+ int flags = osc.getFlags();
if (protocolVersion == PROTOCOL_VERSION_2
- && osc.isExternalizable ())
+ && osc.isExternalizable())
flags |= SC_BLOCK_DATA;
- realOutput.writeByte (flags);
+ realOutput.writeByte(flags);
ObjectStreamField[] fields = osc.fields;
- realOutput.writeShort (fields.length);
+ realOutput.writeShort(fields.length);
ObjectStreamField field;
- for (int i=0; i < fields.length; i++)
+ for (int i = 0; i < fields.length; i++)
{
field = fields[i];
- realOutput.writeByte (field.getTypeCode ());
- realOutput.writeUTF (field.getName ());
+ realOutput.writeByte(field.getTypeCode ());
+ realOutput.writeUTF(field.getName ());
- if (! field.isPrimitive ())
- writeObject (field.getTypeString ());
+ if (! field.isPrimitive())
+ writeObject(field.getTypeString());
}
- boolean oldmode = setBlockDataMode (true);
- annotateClass (osc.forClass ());
- setBlockDataMode (oldmode);
- realOutput.writeByte (TC_ENDBLOCKDATA);
+ boolean oldmode = setBlockDataMode(true);
+ annotateClass(osc.forClass());
+ setBlockDataMode(oldmode);
+ realOutput.writeByte(TC_ENDBLOCKDATA);
- if (osc.isSerializable () || osc.isExternalizable())
- writeObject (osc.getSuper ());
+ if (osc.isSerializable() || osc.isExternalizable())
+ writeObject(osc.getSuper());
else
- writeObject (null);
+ writeObject(null);
}
/**
- Writes the current objects non-transient, non-static fields from
- the current class to the underlying output stream.
-
- This method is intended to be called from within a object's
- <code>private void writeObject (ObjectOutputStream)</code>
- method.
-
- @exception NotActiveException This method was called from a
- context other than from the current object's and current class's
- <code>private void writeObject (ObjectOutputStream)</code>
- method.
-
- @exception IOException Exception from underlying
- <code>OutputStream</code>.
- */
- 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
+ * <code>private void writeObject (ObjectOutputStream)</code>
+ * method.
+ *
+ * @exception NotActiveException This method was called from a
+ * context other than from the current object's and current class's
+ * <code>private void writeObject (ObjectOutputStream)</code>
+ * method.
+ *
+ * @exception IOException Exception from underlying
+ * <code>OutputStream</code>.
+ */
+ public void defaultWriteObject()
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 putFields and defaultWriteObject may be
called, and it may only be called once");
+ throw new IOException
+ ("Only one of writeFields 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
- <code>OutputStream</code> 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
+ * <code>OutputStream</code> 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 <code>ObjectOutputStream</code> to write data
- according to the specified protocol. There are currently two
- different protocols, specified by <code>PROTOCOL_VERSION_1</code>
- and <code>PROTOCOL_VERSION_2</code>. This implementation writes
- data using <code>PROTOCOL_VERSION_2</code> by default, as is done
- by the JDK 1.2.
-
- A non-portable method, <code>setDefaultProtocolVersion (int
- version)</code> is provided to change the default protocol
- version.
-
- For an explination of the differences beween the two protocols
- see XXX: the Java ObjectSerialization Specification.
-
- @exception IOException if <code>version</code> is not a valid
- protocol
-
- @see #setDefaultProtocolVersion(int)
- */
- public void useProtocolVersion (int version) throws IOException
+ * Informs this <code>ObjectOutputStream</code> to write data
+ * according to the specified protocol. There are currently two
+ * different protocols, specified by <code>PROTOCOL_VERSION_1</code>
+ * and <code>PROTOCOL_VERSION_2</code>. This implementation writes
+ * data using <code>PROTOCOL_VERSION_2</code> by default, as is done
+ * by the JDK 1.2.
+ *
+ * A non-portable method, <code>setDefaultProtocolVersion (int
+ * version)</code> is provided to change the default protocol
+ * version.
+ *
+ * For an explination of the differences beween the two protocols
+ * see XXX: the Java ObjectSerialization Specification.
+ *
+ * @exception IOException if <code>version</code> is not a valid
+ * protocol
+ *
+ * @see #setDefaultProtocolVersion(int)
+ */
+ public void useProtocolVersion(int version) throws IOException
{
if (version != PROTOCOL_VERSION_1 && version != PROTOCOL_VERSION_2)
- throw new IOException ("Invalid protocol version requested.");
-
+ throw new IOException("Invalid protocol version requested.");
+
protocolVersion = version;
}
/**
- <em>GNU $classpath specific</em>
-
- Changes the default stream protocol used by all
- <code>ObjectOutputStream</code>s. There are currently two
- different protocols, specified by <code>PROTOCOL_VERSION_1</code>
- and <code>PROTOCOL_VERSION_2</code>. The default default is
- <code>PROTOCOL_VERSION_1</code>.
-
- @exception IOException if <code>version</code> is not a valid
- protocol
-
- @see #useProtocolVersion(int)
- */
- public static void setDefaultProtocolVersion (int version)
+ * <em>GNU $classpath specific</em>
+ *
+ * Changes the default stream protocol used by all
+ * <code>ObjectOutputStream</code>s. There are currently two
+ * different protocols, specified by <code>PROTOCOL_VERSION_1</code>
+ * and <code>PROTOCOL_VERSION_2</code>. The default default is
+ * <code>PROTOCOL_VERSION_1</code>.
+ *
+ * @exception IOException if <code>version</code> is not a valid
+ * protocol
+ *
+ * @see #useProtocolVersion(int)
+ */
+ public static void setDefaultProtocolVersion(int version)
throws IOException
{
if (version != PROTOCOL_VERSION_1 && version != PROTOCOL_VERSION_2)
- throw new IOException ("Invalid protocol version requested.");
+ throw new IOException("Invalid protocol version requested.");
defaultProtocolVersion = version;
}
/**
- An empty hook that allows subclasses to write extra information
- about classes to the stream. This method is called the first
- time each class is seen, and after all of the standard
- information about the class has been written.
-
- @exception IOException Exception from underlying
- <code>OutputStream</code>.
-
- @see ObjectInputStream#resolveClass(java.io.ObjectStreamClass)
- */
- 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
+ * <code>OutputStream</code>.
+ *
+ * @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
- <code>OutputStream</code>.
-
- @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
+ * <code>OutputStream</code>.
+ *
+ * @see #enableReplaceObject(boolean)
+ */
+ protected Object replaceObject(Object obj) throws IOException
{
return obj;
}
/**
- If <code>enable</code> is <code>true</code> and this object is
- trusted, then <code>replaceObject (Object)</code> will be called
- in subsequent calls to <code>writeObject (Object)</code>.
- Otherwise, <code>replaceObject (Object)</code> will not be called.
-
- @exception SecurityException This class is not trusted.
- */
- protected boolean enableReplaceObject (boolean enable)
+ * If <code>enable</code> is <code>true</code> and this object is
+ * trusted, then <code>replaceObject (Object)</code> will be called
+ * in subsequent calls to <code>writeObject (Object)</code>.
+ * Otherwise, <code>replaceObject (Object)</code> will not be called.
+ *
+ * @exception SecurityException This class is not trusted.
+ */
+ protected boolean enableReplaceObject(boolean enable)
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;
@@ -600,20 +604,18 @@
/**
- Writes stream magic and stream version information to the
- underlying stream.
-
- @exception IOException Exception from underlying
- <code>OutputStream</code>.
- */
- protected void writeStreamHeader () throws IOException
+ * Writes stream magic and stream version information to the
+ * underlying stream.
+ *
+ * @exception IOException Exception from underlying
+ * <code>OutputStream</code>.
+ */
+ 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
@@ -625,11 +627,11 @@
*
* @see #writeObjectOverride(Object)
*/
- protected ObjectOutputStream () throws IOException, SecurityException
+ protected ObjectOutputStream() throws IOException, SecurityException
{
SecurityManager sec_man = System.getSecurityManager ();
if (sec_man != null)
- sec_man.checkPermission (SUBCLASS_IMPLEMENTATION_PERMISSION);
+ sec_man.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
useSubclassMethod = true;
}
@@ -646,10 +648,11 @@
* @exception NotActiveException Subclass has arranged for this
* method to be called, but did not implement this method.
*/
- protected void writeObjectOverride (Object obj) throws NotActiveException,
+ protected void writeObjectOverride(Object obj) throws NotActiveException,
IOException
{
- throw new NotActiveException ("Subclass of ObjectOutputStream must implement
writeObjectOverride");
+ throw new NotActiveException
+ ("Subclass of ObjectOutputStream must implement writeObjectOverride");
}
@@ -661,48 +664,48 @@
if (writeDataAsBlocks)
{
if (blockDataCount == BUFFER_SIZE)
- drain ();
+ drain();
blockData[ blockDataCount++ ] = (byte)data;
}
else
- realOutput.write (data);
+ realOutput.write(data);
}
/**
* @see DataOutputStream#write(byte[])
*/
- public void write (byte[] b) throws IOException
+ public void write(byte[] b) throws IOException
{
- write (b, 0, b.length);
+ write(b, 0, b.length);
}
/**
* @see DataOutputStream#write(byte[],int,int)
*/
- public void write (byte[] b, int off, int len) throws IOException
+ public void write(byte[] b, int off, int len) throws IOException
{
if (writeDataAsBlocks)
{
if (len < 0)
- throw new IndexOutOfBoundsException ();
+ throw new IndexOutOfBoundsException();
if (blockDataCount + len < BUFFER_SIZE)
{
- System.arraycopy (b, off, blockData, blockDataCount, len);
+ System.arraycopy(b, off, blockData, blockDataCount, len);
blockDataCount += len;
}
else
{
- drain ();
- writeBlockDataHeader (len);
- realOutput.write (b, off, len);
+ drain();
+ writeBlockDataHeader(len);
+ realOutput.write(b, off, len);
}
}
else
- realOutput.write (b, off, len);
+ realOutput.write(b, off, len);
}
@@ -711,8 +714,8 @@
*/
public void flush () throws IOException
{
- drain ();
- realOutput.flush ();
+ drain();
+ realOutput.flush();
}
@@ -723,14 +726,14 @@
* @exception IOException Exception from underlying
* <code>OutputStream</code>.
*/
- protected void drain () throws IOException
+ protected void drain() throws IOException
{
if (blockDataCount == 0)
return;
if (writeDataAsBlocks)
- writeBlockDataHeader (blockDataCount);
- realOutput.write (blockData, 0, blockDataCount);
+ writeBlockDataHeader(blockDataCount);
+ realOutput.write(blockData, 0, blockDataCount);
blockDataCount = 0;
}
@@ -738,28 +741,28 @@
/**
* @see java.io.DataOutputStream#close ()
*/
- public void close () throws IOException
+ public void close() throws IOException
{
- flush ();
- realOutput.close ();
+ flush();
+ realOutput.close();
}
/**
* @see java.io.DataOutputStream#writeBoolean (boolean)
*/
- public void writeBoolean (boolean data) throws IOException
+ public void writeBoolean(boolean data) throws IOException
{
- blockDataOutput.writeBoolean (data);
+ blockDataOutput.writeBoolean(data);
}
/**
* @see java.io.DataOutputStream#writeByte (int)
*/
- public void writeByte (int data) throws IOException
+ public void writeByte(int data) throws IOException
{
- blockDataOutput.writeByte (data);
+ blockDataOutput.writeByte(data);
}
@@ -768,79 +771,79 @@
*/
public void writeShort (int data) throws IOException
{
- blockDataOutput.writeShort (data);
+ blockDataOutput.writeShort(data);
}
/**
* @see java.io.DataOutputStream#writeChar (int)
*/
- public void writeChar (int data) throws IOException
+ public void writeChar(int data) throws IOException
{
- blockDataOutput.writeChar (data);
+ blockDataOutput.writeChar(data);
}
/**
* @see java.io.DataOutputStream#writeInt (int)
*/
- public void writeInt (int data) throws IOException
+ public void writeInt(int data) throws IOException
{
- blockDataOutput.writeInt (data);
+ blockDataOutput.writeInt(data);
}
/**
* @see java.io.DataOutputStream#writeLong (long)
*/
- public void writeLong (long data) throws IOException
+ public void writeLong(long data) throws IOException
{
- blockDataOutput.writeLong (data);
+ blockDataOutput.writeLong(data);
}
/**
* @see java.io.DataOutputStream#writeFloat (float)
*/
- public void writeFloat (float data) throws IOException
+ public void writeFloat(float data) throws IOException
{
- blockDataOutput.writeFloat (data);
+ blockDataOutput.writeFloat(data);
}
/**
* @see java.io.DataOutputStream#writeDouble (double)
*/
- public void writeDouble (double data) throws IOException
+ public void writeDouble(double data) throws IOException
{
- blockDataOutput.writeDouble (data);
+ blockDataOutput.writeDouble(data);
}
/**
* @see java.io.DataOutputStream#writeBytes (java.lang.String)
*/
- public void writeBytes (String data) throws IOException
+ public void writeBytes(String data) throws IOException
{
- blockDataOutput.writeBytes (data);
+ blockDataOutput.writeBytes(data);
}
/**
* @see java.io.DataOutputStream#writeChars (java.lang.String)
*/
- public void writeChars (String data) throws IOException
+ public void writeChars(String data) throws IOException
{
- dataOutput.writeChars (data);
+ dataOutput.writeChars(data);
}
/**
* @see java.io.DataOutputStream#writeUTF (java.lang.String)
*/
- public void writeUTF (String data) throws IOException
+ public void writeUTF(String data) throws IOException
{
- dataOutput.writeUTF (data);
+ dataOutput.writeUTF(data);
}
@@ -868,14 +871,12 @@
public abstract void write (ObjectOutput out) throws IOException;
}
- public PutField putFields () throws IOException
+ public PutField putFields() throws IOException
{
if (currentPutField != null)
return currentPutField;
- markFieldsWritten ();
-
- currentPutField = new PutField ()
+ currentPutField = new PutField()
{
private byte[] prim_field_data
= new byte[currentObjectStreamClass.primFieldSize];
@@ -885,46 +886,46 @@
private ObjectStreamField getField (String name)
{
ObjectStreamField field
- = currentObjectStreamClass.getField (name);
+ = currentObjectStreamClass.getField(name);
if (field == null)
throw new IllegalArgumentException("no such serializable field " + name);
return field;
}
-
- public void put (String name, boolean value)
+
+ public void put(String name, boolean value)
{
- ObjectStreamField field = getField (name);
+ ObjectStreamField field = getField(name);
- checkType (field, 'Z');
+ checkType(field, 'Z');
prim_field_data[field.getOffset ()] = (byte)(value ? 1 : 0);
}
- public void put (String name, byte value)
+ public void put(String name, byte value)
{
- ObjectStreamField field = getField (name);
+ ObjectStreamField field = getField(name);
- checkType (field, 'B');
- prim_field_data[field.getOffset ()] = value;
+ checkType(field, 'B');
+ prim_field_data[field.getOffset()] = value;
}
*** Patch too long, truncated ***
_______________________________________________
kaffe mailing list
[EMAIL PROTECTED]
http://kaffe.org/cgi-bin/mailman/listinfo/kaffe
