Skip to content

R
riscv-gcc-1
Commit fddab7dc by Michael Koch Committed by Michael Koch
Options

BufferedOutputStream.java, [...]: More merges from classpath. 

2003-03-18  Michael Koch  <konqueror@gmx.de>

	* java/io/BufferedOutputStream.java,
	java/io/DataInput.java,
	java/io/DataInputStream.java,
	java/io/DataOutput.java,
	java/io/Externalizable.java:
	More merges from classpath.

From-SVN: r64528
parent 71a15b15
Showing with 217 additions and 226 deletions
libjava/ChangeLog
2003-03-18 Michael Koch <konqueror@gmx.de>
* java/io/BufferedOutputStream.java,
java/io/DataInput.java,
java/io/DataInputStream.java,
java/io/DataOutput.java,
java/io/Externalizable.java:
More merges from classpath.
2003-03-18 Michael Koch <konqueror@gmx.de>
* configure.in: Fixed links to platform dependant java.net files.
* configure: Regenerated.
* java/net/natInetAddress.cc,
......
libjava/java/io/BufferedOutputStream.java
......@@ -46,65 +46,59 @@ package java.io;
* efficient mechanism for writing versus doing numerous small unbuffered
* writes.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class BufferedOutputStream extends FilterOutputStream
{
/*************************************************************************/
/*
/*
* Class Variables
*/
/**
/**
* This is the default buffer size
*/
private static final int DEFAULT_BUFFER_SIZE = 512;
private static final int DEFAULT_BUFFER_SIZE = 512;
/*************************************************************************/
/*************************************************************************/
/*
/*
* Instance Variables
*/
/**
/**
* This is the internal byte array used for buffering output before
* writing it.
*/
protected byte[] buf;
protected byte[] buf;
/**
/**
* This is the number of bytes that are currently in the buffer and
* are waiting to be written to the underlying stream. It always points to
* the index into the buffer where the next byte of data will be stored
*/
protected int count;
protected int count;
/*************************************************************************/
/*************************************************************************/
/*
/*
* Constructors
*/
/**
/**
* This method initializes a new <code>BufferedOutputStream</code> instance
* that will write to the specified subordinate <code>OutputStream</code>
* and which will use a default buffer size of 512 bytes.
*
* @param out The underlying <code>OutputStream</code> to write data to
*/
public
BufferedOutputStream(OutputStream out)
{
public BufferedOutputStream(OutputStream out)
{
this(out, DEFAULT_BUFFER_SIZE);
}
}
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method initializes a new <code>BufferedOutputStream</code> instance
* that will write to the specified subordinate <code>OutputStream</code>
* and which will use the specified buffer size
......@@ -112,71 +106,67 @@ BufferedOutputStream(OutputStream out)
* @param out The underlying <code>OutputStream</code> to write data to
* @param size The size of the internal buffer
*/
public
BufferedOutputStream(OutputStream out, int size)
{
public BufferedOutputStream(OutputStream out, int size)
{
super(out);
buf = new byte[size];
}
}
/*************************************************************************/
/*************************************************************************/
/*
/*
* Instance Methods
*/
/**
/**
* This method causes any currently buffered bytes to be immediately
* written to the underlying output stream.
*
* @exception IOException If an error occurs
*/
public synchronized void
flush() throws IOException
{
public synchronized void flush() throws IOException
{
if (count == 0)
return;
out.write(buf, 0, count);
count = 0;
out.flush();
}
}
/*************************************************************************/
/*************************************************************************/
/*
/*
* This method flushes any remaining buffered bytes then closes the
* underlying output stream. Any further attempts to write to this stream
* may throw an exception
*
public synchronized void
close() throws IOException
{
public synchronized void close() throws IOException
{
flush();
out.close();
}
*/
}
*/
/*************************************************************************/
/*************************************************************************/
/*
/*
* This method runs when the object is garbage collected. It is
* responsible for ensuring that all buffered bytes are written and
* for closing the underlying stream.
*
* @exception IOException If an error occurs (ignored by the Java runtime)
*
protected void
finalize() throws IOException
{
protected void finalize() throws IOException
{
close();
}
*/
}
*/
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a single byte of data. This will be written to the
* buffer instead of the underlying data source. However, if the buffer
* is filled as a result of this write request, it will be flushed to the
......@@ -186,19 +176,18 @@ finalize() throws IOException
*
* @exception IOException If an error occurs
*/
public synchronized void
write(int b) throws IOException
{
public synchronized void write(int b) throws IOException
{
if (count == buf.length)
flush();
buf[count] = (byte)(b & 0xFF);
++count;
}
}
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes <code>len</code> bytes from the byte array
* <code>buf</code> starting at position <code>offset</code> in the buffer.
* These bytes will be written to the internal buffer. However, if this
......@@ -211,9 +200,9 @@ write(int b) throws IOException
*
* @exception IOException If an error occurs
*/
public synchronized void
write(byte[] buf, int offset, int len) throws IOException
{
public synchronized void write(byte[] buf, int offset, int len)
throws IOException
{
// Buffer can hold everything. Note that the case where LEN < 0
// is automatically handled by the downstream write.
if (len < (this.buf.length - count))
......@@ -229,6 +218,7 @@ write(byte[] buf, int offset, int len) throws IOException
flush();
out.write (buf, offset, len);
}
}
}
} // class BufferedOutputStream
libjava/java/io/DataInput.java
/* DataInput.java -- Interface for reading data from a stream
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2001, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
......@@ -41,8 +41,7 @@ package java.io;
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct.
*/
* Status: Believed complete and correct. */
/**
* This interface is implemented by classes that can data from streams
......@@ -54,7 +53,7 @@ package java.io;
public interface DataInput
{
/**
/**
* This method reads a Java boolean value from an input stream. It does
* so by reading a single byte of data. If that byte is zero, then the
* value returned is <code>false</code>. If the byte is non-zero, then
......@@ -66,15 +65,15 @@ public interface DataInput
*
* @return The <code>boolean</code> value read
*
* @exception EOFException If end of file is reached before reading the boolean
* @exception EOFException If end of file is reached before
* reading the boolean
* @exception IOException If any other error occurs
*/
boolean
readBoolean() throws EOFException, IOException;
boolean readBoolean() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads a Java byte value from an input stream. The value
* is in the range of -128 to 127.
* <p>
......@@ -89,16 +88,16 @@ readBoolean() throws EOFException, IOException;
*
* @see DataOutput
*/
byte
readByte() throws EOFException, IOException;
byte readByte() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads 8 unsigned bits into a Java <code>int</code> value from
* the stream. The value returned is in the range of 0 to 255.
* <p>
* This method can read an unsigned byte written by an object implementing the
* This method can read an unsigned byte written by an object
* implementing the
* <code>writeUnsignedByte()</code> method in the <code>DataOutput</code>
* interface.
*
......@@ -109,12 +108,11 @@ readByte() throws EOFException, IOException;
*
* @see DataOutput
*/
int
readUnsignedByte() throws EOFException, IOException;
int readUnsignedByte() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads a Java <code>char</code> value from an input stream.
* It operates by reading two bytes from the stream and converting them to
* a single 16-bit Java <code>char</code>. The two bytes are stored most
......@@ -138,12 +136,11 @@ readUnsignedByte() throws EOFException, IOException;
*
* @see DataOutput
*/
char
readChar() throws EOFException, IOException;
char readChar() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads a signed 16-bit value into a Java in from the stream.
* It operates by reading two bytes from the stream and converting them to
* a single 16-bit Java <code>short</code>. The two bytes are stored most
......@@ -158,7 +155,8 @@ readChar() throws EOFException, IOException;
* <p>
* The value returned is in the range of -32768 to 32767.
* <p>
* This method can read a <code>short</code> written by an object implementing
* This method can read a <code>short</code> written by an object
* implementing
* the <code>writeShort()</code> method in the <code>DataOutput</code>
* interface.
*
......@@ -169,12 +167,11 @@ readChar() throws EOFException, IOException;
*
* @see DataOutput
*/
short
readShort() throws EOFException, IOException;
short readShort() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads 16 unsigned bits into a Java int value from the stream.
* It operates by reading two bytes from the stream and converting them to
* a single Java <code>int</code>. The two bytes are stored most
......@@ -190,20 +187,21 @@ readShort() throws EOFException, IOException;
* The value returned is in the range of 0 to 65535.
* <p>
* This method can read an unsigned short written by an object implementing
* the <code>writeUnsignedShort()</code> method in the <code>DataOutput</code>
* the <code>writeUnsignedShort()</code> method in the
* <code>DataOutput</code>
* interface.
*
* @return The unsigned short value read as a Java <code>int</code>.
*
* @exception EOFException If end of file is reached before reading the value
* @exception EOFException If end of file is reached before reading
* the value
* @exception IOException If any other error occurs
*/
int
readUnsignedShort() throws EOFException, IOException;
int readUnsignedShort() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads a Java <code>int</code> value from an input stream
* It operates by reading four bytes from the stream and converting them to
* a single Java <code>int</code>. The bytes are stored most
......@@ -216,10 +214,11 @@ readUnsignedShort() throws EOFException, IOException;
* <p>
* <code>(int)((byte1 << 24) + (byte2 << 16) + (byte3 << 8) + byte4))</code>
* <p>
The value returned is in the range of -2147483648 to 2147483647.
* The value returned is in the range of -2147483648 to 2147483647.
* <p>
* This method can read an <code>int</code> written by an object implementing
* the <code>writeInt()</code> method in the <code>DataOutput</code> interface.
* This method can read an <code>int</code> written by an object
* implementing the <code>writeInt()</code> method in the
* <code>DataOutput</code> interface.
*
* @return The <code>int</code> value read
*
......@@ -228,12 +227,11 @@ readUnsignedShort() throws EOFException, IOException;
*
* @see DataOutput
*/
int
readInt() throws EOFException, IOException;
int readInt() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads a Java <code>long</code> value from an input stream
* It operates by reading eight bytes from the stream and converting them to
* a single Java <code>long</code>. The bytes are stored most
......@@ -251,9 +249,9 @@ readInt() throws EOFException, IOException;
* The value returned is in the range of -9223372036854775808 to
* 9223372036854775807.
* <p>
* This method can read an <code>long</code> written by an object implementing
* the <code>writeLong()</code> method in the <code>DataOutput</code>
* interface.
* This method can read an <code>long</code> written by an object
* implementing the <code>writeLong()</code> method in the
* <code>DataOutput</code> interface.
*
* @return The <code>long</code> value read
*
......@@ -262,12 +260,11 @@ readInt() throws EOFException, IOException;
*
* @see DataOutput
*/
long
readLong() throws EOFException, IOException;
long readLong() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads a Java float value from an input stream. It operates
* by first reading an <code>int</code> value from the stream by calling the
* <code>readInt()</code> method in this interface, then converts that
......@@ -275,24 +272,25 @@ readLong() throws EOFException, IOException;
* <code>intBitsToFloat</code> method in the class
* <code>java.lang.Float</code>.
* <p>
* This method can read a <code>float</code> written by an object implementing
* This method can read a <code>float</code> written by an object
* implementing
* the <code>writeFloat()</code> method in the <code>DataOutput</code>
* interface.
*
* @return The <code>float</code> value read
*
* @exception EOFException If end of file is reached before reading the float
* @exception EOFException If end of file is reached before reading the
* float
* @exception IOException If any other error occurs
*
* @see java.lang.Float
* @see DataOutput
*/
float
readFloat() throws EOFException, IOException;
float readFloat() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads a Java double value from an input stream. It operates
* by first reading a <code>long</code> value from the stream by calling the
* <code>readLong()</code> method in this interface, then converts that
......@@ -306,26 +304,28 @@ readFloat() throws EOFException, IOException;
*
* @return The <code>double</code> value read
*
* @exception EOFException If end of file is reached before reading the double
* @exception EOFException If end of file is reached before reading the
* double
* @exception IOException If any other error occurs
*
* @see java.lang.Double
* @see DataOutput
*/
double
readDouble() throws EOFException, IOException;
double readDouble() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads the next line of text data from an input stream.
* It operates by reading bytes and converting those bytes to <code>char</code>
* It operates by reading bytes and converting those bytes to
* <code>char</code>
* values by treating the byte read as the low eight bits of the
* <code>char</code> and using 0 as the high eight bits. Because of this,
* it does not support the full 16-bit Unicode character set.
* <P>
* The reading of bytes ends when either the end of file or a line terminator
* is encountered. The bytes read are then returned as a <code>String</code>.
* is encountered. The bytes read are then returned as a
* <code>String</code>.
* A line terminator is a byte sequence consisting of either
* <code>\r</code>, <code>\n</code> or <code>\r\n</code>. These termination
* charaters are discarded and are not returned as part of the string.
......@@ -339,22 +339,22 @@ readDouble() throws EOFException, IOException;
*
* @see DataOutput
*/
String
readLine() throws IOException;
String readLine() throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads a <code>String</code> from an input stream that is
* encoded in a modified UTF-8 format. This format has a leading two byte
* sequence that contains the remaining number of bytes to read. This two byte
* sequence that contains the remaining number of bytes to read.
* This two byte
* sequence is read using the <code>readUnsignedShort()</code> method of this
* interface.
*
* After the number of remaining bytes have been determined, these bytes
* are read an transformed into <code>char</code> values. These
* <code>char</code> values are encoded in the stream using either a one, two,
* or three byte format.
* <code>char</code> values are encoded in the stream using either a one,
* two, or three byte format.
* The particular format in use can be determined by examining the first
* byte read.
* <p>
......@@ -398,27 +398,27 @@ readLine() throws IOException;
*
* Note that all characters are encoded in the method that requires the
* fewest number of bytes with the exception of the character with the
* value of <code>\<llll>u0000</code> which is encoded as two bytes. This is
* a modification of the UTF standard used to prevent C language style
* <code>NUL</code> values from appearing in the byte stream.
* value of <code>\<llll>u0000</code> which is encoded as two bytes.
* This is a modification of the UTF standard used to prevent C language
* style <code>NUL</code> values from appearing in the byte stream.
* <p>
* This method can read data that was written by an object implementing the
* <code>writeUTF()</code> method in <code>DataOutput</code>.
*
* @returns The <code>String</code> read
*
* @exception EOFException If end of file is reached before reading the String
* @exception EOFException If end of file is reached before reading the
* String
* @exception UTFDataFormatException If the data is not in UTF-8 format
* @exception IOException If any other error occurs
*
* @see DataOutput
*/
String
readUTF() throws EOFException, UTFDataFormatException, IOException;
String readUTF() throws EOFException, UTFDataFormatException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method reads raw bytes into the passed array until the array is
* full. Note that this method blocks until the data is available and
* throws an exception if there is not enough data left in the stream to
......@@ -426,17 +426,19 @@ readUTF() throws EOFException, UTFDataFormatException, IOException;
*
* @param buf The buffer into which to read the data
*
* @exception EOFException If end of file is reached before filling the buffer
* @exception EOFException If end of file is reached before filling the
* buffer
* @exception IOException If any other error occurs
*/
void
readFully(byte[] buf) throws EOFException, IOException;
void readFully(byte[] buf) throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
* This method reads raw bytes into the passed array <code>buf</code> starting
* <code>offset</code> bytes into the buffer. The number of bytes read will be
/**
* This method reads raw bytes into the passed array <code>buf</code>
* starting
* <code>offset</code> bytes into the buffer. The number of bytes read
* will be
* exactly <code>len</code>. Note that this method blocks until the data is
* available and * throws an exception if there is not enough data left in
* the stream to read <code>len</code> bytes.
......@@ -445,15 +447,16 @@ readFully(byte[] buf) throws EOFException, IOException;
* @param offset The offset into the buffer to start storing data
* @param len The number of bytes to read into the buffer
*
* @exception EOFException If end of file is reached before filling the buffer
* @exception EOFException If end of file is reached before filling the
* buffer
* @exception IOException If any other error occurs
*/
void
readFully(byte[] buf, int offset, int len) throws EOFException, IOException;
void readFully(byte[] buf, int offset, int len)
throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method skips and discards the specified number of bytes in an
* input stream
*
......@@ -466,7 +469,6 @@ readFully(byte[] buf, int offset, int len) throws EOFException, IOException;
* skipped
* @exception IOException If any other error occurs
*/
int
skipBytes(int n) throws EOFException, IOException;
int skipBytes(int n) throws EOFException, IOException;
} // interface DataInput
libjava/java/io/DataInputStream.java
/* DataInputStream.java -- FilteredInputStream that implements DataInput
Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation
This file is part of GNU Classpath.
......@@ -50,8 +50,6 @@ package java.io;
*
* @see DataInput
*
* @version 0.0
*
* @author Warren Levy <warrenl@cygnus.com>
* @author Aaron M. Renn (arenn@urbanophile.com)
* @date October 20, 1998.
......
libjava/java/io/DataOutput.java
......@@ -53,127 +53,117 @@ package java.io;
public interface DataOutput
{
/**
/**
* This method writes a Java boolean value to an output stream
*
* @param value The boolean value to write
*
* @exception IOException If an error occurs
*/
void
writeBoolean(boolean value) throws IOException;
void writeBoolean(boolean value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a Java byte value to an output stream
*
* @param value The int value to write
*
* @exception IOException If an error occurs
*/
void
writeByte(int value) throws IOException;
void writeByte(int value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a Java char value to an output stream
*
* @param value The char value to write
*
* @exception IOException If an error occurs
*/
void
writeChar(int value) throws IOException;
void writeChar(int value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a Java int value to an output stream as a 16 bit value
*
* @param value The int value to write as a 16-bit value
*
* @exception IOException If an error occurs
*/
void
writeShort(int value) throws IOException;
void writeShort(int value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a Java int value to an output stream
*
* @param value The int value to write
*
* @exception IOException If an error occurs
*/
void
writeInt(int value) throws IOException;
void writeInt(int value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a Java long value to an output stream
*
* @param value The long value to write
*
* @exception IOException If an error occurs
*/
void
writeLong(long value) throws IOException;
void writeLong(long value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a Java float value to an output stream
*
* @param value The float value to write
*
* @exception IOException If an error occurs
*/
void
writeFloat(float value) throws IOException;
void writeFloat(float value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a Java double value to an output stream
*
* @param value The double value to write
*
* @exception IOException If any other error occurs
*/
void
writeDouble(double value) throws IOException;
void writeDouble(double value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a String to an output stream as an array of bytes
*
* @param value The String to write
*
* @exception IOException If an error occurs
*/
void
writeBytes(String value) throws IOException;
void writeBytes(String value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a String to an output stream as an array of char's
*
* @param value The String to write
*
* @exception IOException If an error occurs
*/
void
writeChars(String value) throws IOException;
void writeChars(String value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes a String to an output stream encoded in
* UTF-8 format.
*
......@@ -181,12 +171,11 @@ writeChars(String value) throws IOException;
*
* @exception IOException If an error occurs
*/
void
writeUTF(String value) throws IOException;
void writeUTF(String value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes an 8-bit value (passed into the method as a Java
* int) to an output stream.
*
......@@ -194,35 +183,35 @@ writeUTF(String value) throws IOException;
*
* @exception IOException If an error occurs
*/
void
write(int value) throws IOException;
void write(int value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method writes the raw byte array passed in to the output stream.
*
* @param buf The byte array to write
*
* @exception IOException If an error occurs
*/
void
write(byte[] buf) throws IOException;
void write(byte[] buf) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
* This method writes raw bytes from the passed array <code>buf</code> starting
* <code>offset</code> bytes into the buffer. The number of bytes written will be
* exactly <code>len</code>.
/**
* This method writes raw bytes from the passed array <code>buf</code>
* starting
* <code>offset</code> bytes into the buffer. The number of bytes
* written will be * exactly <code>len</code>.
*
* @param buf The buffer from which to write the data
* @param offset The offset into the buffer to start writing data from
* @param len The number of bytes to write from the buffer to the output stream
* @param len The number of bytes to write from the buffer to the output
* stream
*
* @exception IOException If any other error occurs
*/
void
write(byte[] buf, int offset, int len) throws IOException;
void write(byte[] buf, int offset, int len) throws IOException;
} // interface DataOutput
libjava/java/io/Externalizable.java
......@@ -56,19 +56,19 @@ package java.io;
* created using the default no-argument constructor and the
* <code>readExternal</code> method is used to restore the state.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public interface Externalizable extends Serializable
{
static final long serialVersionUID = -282491828744381764L;
/**
/**
* This method restores an object's state by reading in the instance data
* for the object from the passed in stream. Note that this stream is not
* a subclass of <code>InputStream</code>, but rather is a class that implements
* the <code>ObjectInput</code> interface. That interface provides a mechanism for
* a subclass of <code>InputStream</code>, but rather is a class that
* implements
* the <code>ObjectInput</code> interface. That interface provides a
* mechanism for
* reading in Java data types from a stream.
* <p>
* Note that this method must be compatible with <code>writeExternal</code>.
......@@ -79,32 +79,35 @@ public interface Externalizable extends Serializable
* for that object must be found and loaded. If that operation fails,
* then this method throws a <code>ClassNotFoundException</code>
*
* @param in An <code>ObjectInput</code> instance for reading in the object state
* @param in An <code>ObjectInput</code> instance for reading in the object
* state
*
* @exception ClassNotFoundException If the class of an object being restored cannot be found
* @exception ClassNotFoundException If the class of an object being
* restored cannot be found
* @exception IOException If any other error occurs
*/
public abstract void
readExternal(ObjectInput in) throws ClassNotFoundException, IOException;
public abstract void readExternal(ObjectInput in)
throws ClassNotFoundException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/**
* This method is responsible for writing the instance data of an object
* to the passed in stream. Note that this stream is not a subclass of
* <code>OutputStream</code>, but rather is a class that implements the
* <code>ObjectOutput</code> interface. That interface provides a number of methods
* <code>ObjectOutput</code> interface. That interface provides a
* number of methods
* for writing Java data values to a stream.
* <p>
* Not that the implementation of this method must be coordinated with
* the implementation of <code>readExternal</code>.
*
* @param out An <code>ObjectOutput</code> instance for writing the object state
* @param out An <code>ObjectOutput</code> instance for writing the
* object state
*
* @exception IOException If an error occurs
*/
public abstract void
writeExternal(ObjectOutput out) throws IOException;
public abstract void writeExternal(ObjectOutput out) throws IOException;
} // interface Externalizable
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment