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 799 additions and 808 deletions
libjava/ChangeLog
2003-03-18 Michael Koch <konqueror@gmx.de> 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.in: Fixed links to platform dependant java.net files.
* configure: Regenerated. * configure: Regenerated.
* java/net/natInetAddress.cc, * java/net/natInetAddress.cc,
......
libjava/java/io/BufferedOutputStream.java
...@@ -46,189 +46,179 @@ package java.io; ...@@ -46,189 +46,179 @@ package java.io;
* efficient mechanism for writing versus doing numerous small unbuffered * efficient mechanism for writing versus doing numerous small unbuffered
* writes. * writes.
* *
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com) * @author Aaron M. Renn (arenn@urbanophile.com)
*/ */
public class BufferedOutputStream extends FilterOutputStream public class BufferedOutputStream extends FilterOutputStream
{ {
/*
/*************************************************************************/ * Class Variables
*/
/*
* Class Variables /**
*/ * This is the default buffer size
*/
/** private static final int DEFAULT_BUFFER_SIZE = 512;
* This is the default buffer size
*/ /*************************************************************************/
private static final int DEFAULT_BUFFER_SIZE = 512;
/*
/*************************************************************************/ * Instance Variables
*/
/*
* Instance Variables /**
*/ * This is the internal byte array used for buffering output before
* writing it.
/** */
* This is the internal byte array used for buffering output before protected byte[] buf;
* writing it.
*/ /**
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
* 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 protected int count;
* the index into the buffer where the next byte of data will be stored
*/ /*************************************************************************/
protected int count;
/*
/*************************************************************************/ * Constructors
*/
/*
* 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.
* This method initializes a new <code>BufferedOutputStream</code> instance *
* that will write to the specified subordinate <code>OutputStream</code> * @param out The underlying <code>OutputStream</code> to write data to
* and which will use a default buffer size of 512 bytes. */
* public BufferedOutputStream(OutputStream out)
* @param out The underlying <code>OutputStream</code> to write data to {
*/ this(out, DEFAULT_BUFFER_SIZE);
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
/** *
* This method initializes a new <code>BufferedOutputStream</code> instance * @param out The underlying <code>OutputStream</code> to write data to
* that will write to the specified subordinate <code>OutputStream</code> * @param size The size of the internal buffer
* and which will use the specified buffer size */
* public BufferedOutputStream(OutputStream out, int size)
* @param out The underlying <code>OutputStream</code> to write data to {
* @param size The size of the internal buffer super(out);
*/
public buf = new byte[size];
BufferedOutputStream(OutputStream out, int size) }
{
super(out); /*************************************************************************/
buf = new byte[size]; /*
} * Instance Methods
*/
/*************************************************************************/
/**
/* * This method causes any currently buffered bytes to be immediately
* Instance Methods * written to the underlying output stream.
*/ *
* @exception IOException If an error occurs
/** */
* This method causes any currently buffered bytes to be immediately public synchronized void flush() throws IOException
* written to the underlying output stream. {
* if (count == 0)
* @exception IOException If an error occurs 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
{
flush();
out.close();
}
*/ */
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
{
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
{
close();
}
*/
/*************************************************************************/ /*************************************************************************/
/** /*
* This method writes a single byte of data. This will be written to the * This method runs when the object is garbage collected. It is
* buffer instead of the underlying data source. However, if the buffer * responsible for ensuring that all buffered bytes are written and
* is filled as a result of this write request, it will be flushed to the * for closing the underlying stream.
* underlying output stream. *
* * @exception IOException If an error occurs (ignored by the Java runtime)
* @param b The byte of data to be written, passed as an int *
* protected void finalize() throws IOException
* @exception IOException If an error occurs {
close();
}
*/ */
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 * This method writes a single byte of data. This will be written to the
* write operation fills the buffer, the buffer will be flushed to the * buffer instead of the underlying data source. However, if the buffer
* underlying output stream. * is filled as a result of this write request, it will be flushed to the
* * underlying output stream.
* @param buf The array of bytes to write. *
* @param offset The index into the byte array to start writing from. * @param b The byte of data to be written, passed as an int
* @param len The number of bytes to write. *
* * @exception IOException If an error occurs
* @exception IOException If an error occurs */
*/ public synchronized void write(int b) throws IOException
public synchronized void {
write(byte[] buf, int offset, int len) throws IOException if (count == buf.length)
{
// Buffer can hold everything. Note that the case where LEN < 0
// is automatically handled by the downstream write.
if (len < (this.buf.length - count))
{
System.arraycopy(buf, offset, this.buf, count, len);
count += len;
}
else
{
// The write was too big. So flush the buffer and write the new
// bytes directly to the underlying stream, per the JDK 1.2
// docs.
flush(); flush();
out.write (buf, offset, len);
} 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
* write operation fills the buffer, the buffer will be flushed to the
* underlying output stream.
*
* @param buf The array of bytes to write.
* @param offset The index into the byte array to start writing from.
* @param len The number of bytes to write.
*
* @exception IOException If an error occurs
*/
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))
{
System.arraycopy(buf, offset, this.buf, count, len);
count += len;
}
else
{
// The write was too big. So flush the buffer and write the new
// bytes directly to the underlying stream, per the JDK 1.2
// docs.
flush();
out.write (buf, offset, len);
}
}
} // class BufferedOutputStream } // class BufferedOutputStream
libjava/java/io/DataInput.java
/* DataInput.java -- Interface for reading data from a stream /* 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. This file is part of GNU Classpath.
...@@ -40,9 +40,8 @@ package java.io; ...@@ -40,9 +40,8 @@ package java.io;
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1 * "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com. * 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 * This interface is implemented by classes that can data from streams
...@@ -54,419 +53,422 @@ package java.io; ...@@ -54,419 +53,422 @@ package java.io;
public interface DataInput public interface DataInput
{ {
/** /**
* This method reads a Java boolean value from an input stream. It does * 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 * 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 * value returned is <code>false</code>. If the byte is non-zero, then
* the value returned is <code>true</code>. * the value returned is <code>true</code>.
* <p> * <p>
* This method can read a <code>boolean</code> written by an object * This method can read a <code>boolean</code> written by an object
* implementing the <code>writeBoolean()</code> method in the * implementing the <code>writeBoolean()</code> method in the
* <code>DataOutput</code> interface. * <code>DataOutput</code> interface.
* *
* @return The <code>boolean</code> value read * @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
* @exception IOException If any other error occurs * 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 * This method reads a Java byte value from an input stream. The value
* is in the range of -128 to 127. * is in the range of -128 to 127.
* <p> * <p>
* This method can read a <code>byte</code> written by an object * This method can read a <code>byte</code> written by an object
* implementing the * implementing the
* <code>writeByte()</code> method in the <code>DataOutput</code> interface. * <code>writeByte()</code> method in the <code>DataOutput</code> interface.
* <p> * <p>
* @return The <code>byte</code> value read * @return The <code>byte</code> value read
* *
* @exception EOFException If end of file is reached before reading the byte * @exception EOFException If end of file is reached before reading the byte
* @exception IOException If any other error occurs * @exception IOException If any other error occurs
* *
* @see DataOutput * @see DataOutput
*/ */
byte byte readByte() throws EOFException, IOException;
readByte() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/** * This method reads 8 unsigned bits into a Java <code>int</code> value from
* 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.
* the stream. The value returned is in the range of 0 to 255. * <p>
* <p> * This method can read an unsigned byte written by an object
* This method can read an unsigned byte written by an object implementing the * implementing the
* <code>writeUnsignedByte()</code> method in the <code>DataOutput</code> * <code>writeUnsignedByte()</code> method in the <code>DataOutput</code>
* interface. * interface.
* *
* @return The unsigned bytes value read as a Java <code>int</code>. * @return The unsigned bytes 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 * @exception IOException If any other error occurs
* *
* @see DataOutput * @see DataOutput
*/ */
int int readUnsignedByte() throws EOFException, IOException;
readUnsignedByte() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/** * This method reads a Java <code>char</code> value from an input stream.
* 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
* 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
* a single 16-bit Java <code>char</code>. The two bytes are stored most * significant byte first (i.e., "big endian") regardless of the native
* significant byte first (i.e., "big endian") regardless of the native * host byte ordering.
* host byte ordering. * <p>
* <p> * As an example, if <code>byte1</code> and <code>byte2</code> represent the
* As an example, if <code>byte1</code> and <code>byte2</code> represent the * first and second byte read from the stream respectively, they will be
* first and second byte read from the stream respectively, they will be * transformed to a <code>char</code> in the following manner:
* transformed to a <code>char</code> in the following manner: * <p>
* <p> * <code>(char)((byte1 << 8) + byte2)</code>
* <code>(char)((byte1 << 8) + byte2)</code> * <p>
* <p> * This method can read a <code>char</code> written by an object implementing
* This method can read a <code>char</code> written by an object implementing * the
* the * <code>writeChar()</code> method in the <code>DataOutput</code> interface.
* <code>writeChar()</code> method in the <code>DataOutput</code> interface. *
* * @return The <code>char</code> value read
* @return The <code>char</code> value read *
* * @exception EOFException If end of file is reached before reading the char
* @exception EOFException If end of file is reached before reading the char * @exception IOException If any other error occurs
* @exception IOException If any other error occurs *
* * @see DataOutput
* @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
* This method reads a signed 16-bit value into a Java in from the stream. * a single 16-bit Java <code>short</code>. The two bytes are stored most
* It operates by reading two bytes from the stream and converting them to * significant byte first (i.e., "big endian") regardless of the native
* a single 16-bit Java <code>short</code>. The two bytes are stored most * host byte ordering.
* significant byte first (i.e., "big endian") regardless of the native * <p>
* host byte ordering. * As an example, if <code>byte1</code> and <code>byte2</code> represent the
* <p> * first and second byte read from the stream respectively, they will be
* As an example, if <code>byte1</code> and <code>byte2</code> represent the * transformed to a <code>short</code> in the following manner:
* first and second byte read from the stream respectively, they will be * <p>
* transformed to a <code>short</code> in the following manner: * <code>(short)((byte1 << 8) + byte2)</code>
* <p> * <p>
* <code>(short)((byte1 << 8) + byte2)</code> * The value returned is in the range of -32768 to 32767.
* <p> * <p>
* The value returned is in the range of -32768 to 32767. * This method can read a <code>short</code> written by an object
* <p> * implementing
* This method can read a <code>short</code> written by an object implementing * the <code>writeShort()</code> method in the <code>DataOutput</code>
* the <code>writeShort()</code> method in the <code>DataOutput</code> * interface.
* interface. *
* * @return The <code>short</code> value read
* @return The <code>short</code> value read *
* * @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
* @exception IOException If any other error occurs *
* * @see DataOutput
* @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
* This method reads 16 unsigned bits into a Java int value from the stream. * a single Java <code>int</code>. The two bytes are stored most
* It operates by reading two bytes from the stream and converting them to * significant byte first (i.e., "big endian") regardless of the native
* a single Java <code>int</code>. The two bytes are stored most * host byte ordering.
* significant byte first (i.e., "big endian") regardless of the native * <p>
* host byte ordering. * As an example, if <code>byte1</code> and <code>byte2</code> represent the
* <p> * first and second byte read from the stream respectively, they will be
* As an example, if <code>byte1</code> and <code>byte2</code> represent the * transformed to an <code>int</code> in the following manner:
* first and second byte read from the stream respectively, they will be * <p>
* transformed to an <code>int</code> in the following manner: * <code>(int)((byte1 << 8) + byte2)</code>
* <p> * <p>
* <code>(int)((byte1 << 8) + byte2)</code> * The value returned is in the range of 0 to 65535.
* <p> * <p>
* The value returned is in the range of 0 to 65535. * This method can read an unsigned short written by an object implementing
* <p> * the <code>writeUnsignedShort()</code> method in the
* This method can read an unsigned short written by an object implementing * <code>DataOutput</code>
* the <code>writeUnsignedShort()</code> method in the <code>DataOutput</code> * interface.
* interface. *
* * @return The unsigned short value read as a Java <code>int</code>.
* @return The unsigned short value read as a Java <code>int</code>. *
* * @exception EOFException If end of file is reached before reading
* @exception EOFException If end of file is reached before reading the value * the value
* @exception IOException If any other error occurs * @exception IOException If any other error occurs
*/ */
int int readUnsignedShort() throws EOFException, IOException;
readUnsignedShort() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/** * This method reads a Java <code>int</code> value from an input stream
* 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
* It operates by reading four bytes from the stream and converting them to * a single Java <code>int</code>. The bytes are stored most
* a single Java <code>int</code>. The bytes are stored most * significant byte first (i.e., "big endian") regardless of the native
* significant byte first (i.e., "big endian") regardless of the native * host byte ordering.
* host byte ordering. * <p>
* <p> * As an example, if <code>byte1</code> through <code>byte4</code> represent
* As an example, if <code>byte1</code> through <code>byte4</code> represent * the first four bytes read from the stream, they will be
* the first four bytes read from the stream, they will be * transformed to an <code>int</code> in the following manner:
* transformed to an <code>int</code> in the following manner: * <p>
* <p> * <code>(int)((byte1 << 24) + (byte2 << 16) + (byte3 << 8) + byte4))</code>
* <code>(int)((byte1 << 24) + (byte2 << 16) + (byte3 << 8) + byte4))</code> * <p>
* <p> * The value returned is in the range of -2147483648 to 2147483647.
The value returned is in the range of -2147483648 to 2147483647. * <p>
* <p> * This method can read an <code>int</code> written by an object
* This method can read an <code>int</code> written by an object implementing * implementing the <code>writeInt()</code> method in the
* the <code>writeInt()</code> method in the <code>DataOutput</code> interface. * <code>DataOutput</code> interface.
* *
* @return The <code>int</code> value read * @return The <code>int</code> value read
* *
* @exception EOFException If end of file is reached before reading the int * @exception EOFException If end of file is reached before reading the int
* @exception IOException If any other error occurs * @exception IOException If any other error occurs
* *
* @see DataOutput * @see DataOutput
*/ */
int int readInt() throws EOFException, IOException;
readInt() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/** * This method reads a Java <code>long</code> value from an input stream
* 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
* It operates by reading eight bytes from the stream and converting them to * a single Java <code>long</code>. The bytes are stored most
* a single Java <code>long</code>. The bytes are stored most * significant byte first (i.e., "big endian") regardless of the native
* significant byte first (i.e., "big endian") regardless of the native * host byte ordering.
* host byte ordering. * <p>
* <p> * As an example, if <code>byte1</code> through <code>byte8</code> represent
* As an example, if <code>byte1</code> through <code>byte8</code> represent * the first eight bytes read from the stream, they will be
* the first eight bytes read from the stream, they will be * transformed to an <code>long</code> in the following manner:
* transformed to an <code>long</code> in the following manner: * <p>
* <p> * <code>(long)((byte1 << 56) + (byte2 << 48) + (byte3 << 40) +
* <code>(long)((byte1 << 56) + (byte2 << 48) + (byte3 << 40) + * (byte4 << 32) + (byte5 << 24) + (byte6 << 16) + (byte7 << 8) + byte9))
* (byte4 << 32) + (byte5 << 24) + (byte6 << 16) + (byte7 << 8) + byte9)) * </code>
* </code> * <p>
* <p> * The value returned is in the range of -9223372036854775808 to
* The value returned is in the range of -9223372036854775808 to * 9223372036854775807.
* 9223372036854775807. * <p>
* <p> * This method can read an <code>long</code> written by an object
* This method can read an <code>long</code> written by an object implementing * implementing the <code>writeLong()</code> method in the
* the <code>writeLong()</code> method in the <code>DataOutput</code> * <code>DataOutput</code> interface.
* interface. *
* * @return The <code>long</code> value read
* @return The <code>long</code> value read *
* * @exception EOFException If end of file is reached before reading the long
* @exception EOFException If end of file is reached before reading the long * @exception IOException If any other error occurs
* @exception IOException If any other error occurs *
* * @see DataOutput
* @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
* This method reads a Java float value from an input stream. It operates * <code>readInt()</code> method in this interface, then converts that
* by first reading an <code>int</code> value from the stream by calling the * <code>int</code> to a <code>float</code> using the
* <code>readInt()</code> method in this interface, then converts that * <code>intBitsToFloat</code> method in the class
* <code>int</code> to a <code>float</code> using the * <code>java.lang.Float</code>.
* <code>intBitsToFloat</code> method in the class * <p>
* <code>java.lang.Float</code>. * This method can read a <code>float</code> written by an object
* <p> * implementing
* This method can read a <code>float</code> written by an object implementing * the <code>writeFloat()</code> method in the <code>DataOutput</code>
* the <code>writeFloat()</code> method in the <code>DataOutput</code> * interface.
* interface. *
* * @return The <code>float</code> value read
* @return The <code>float</code> value read *
* * @exception EOFException If end of file is reached before reading the
* @exception EOFException If end of file is reached before reading the float * float
* @exception IOException If any other error occurs * @exception IOException If any other error occurs
* *
* @see java.lang.Float * @see java.lang.Float
* @see DataOutput * @see DataOutput
*/ */
float float readFloat() throws EOFException, IOException;
readFloat() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/** * This method reads a Java double value from an input stream. It operates
* 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
* by first reading a <code>long</code> value from the stream by calling the * <code>readLong()</code> method in this interface, then converts that
* <code>readLong()</code> method in this interface, then converts that * <code>long</code> to a <code>double</code> using the
* <code>long</code> to a <code>double</code> using the * <code>longBitsToDouble</code> method in the class
* <code>longBitsToDouble</code> method in the class * <code>java.lang.Double</code>.
* <code>java.lang.Double</code>. * <p>
* <p> * This method can read a <code>double</code> written by an object
* This method can read a <code>double</code> written by an object * implementing the <code>writeDouble()</code> method in the
* implementing the <code>writeDouble()</code> method in the * <code>DataOutput</code> interface.
* <code>DataOutput</code> interface. *
* * @return The <code>double</code> value read
* @return The <code>double</code> value read *
* * @exception EOFException If end of file is reached before reading the
* @exception EOFException If end of file is reached before reading the double * double
* @exception IOException If any other error occurs * @exception IOException If any other error occurs
* *
* @see java.lang.Double * @see java.lang.Double
* @see DataOutput * @see DataOutput
*/ */
double double readDouble() throws EOFException, IOException;
readDouble() throws EOFException, IOException;
/*************************************************************************/
/*************************************************************************/
/**
/** * This method reads the next line of text data from an input stream.
* This method reads the next line of text data from an input stream. * It operates by reading bytes and converting those bytes to
* It operates by reading bytes and converting those bytes to <code>char</code> * <code>char</code>
* values by treating the byte read as the low eight bits of the * 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, * <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. * it does not support the full 16-bit Unicode character set.
* <P> * <P>
* The reading of bytes ends when either the end of file or a line terminator * 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
* A line terminator is a byte sequence consisting of either * <code>String</code>.
* <code>\r</code>, <code>\n</code> or <code>\r\n</code>. These termination * A line terminator is a byte sequence consisting of either
* charaters are discarded and are not returned as part of the string. * <code>\r</code>, <code>\n</code> or <code>\r\n</code>. These termination
* <p> * charaters are discarded and are not returned as part of the string.
* This method can read data that was written by an object implementing the * <p>
* <code>writeLine()</code> method in <code>DataOutput</code>. * This method can read data that was written by an object implementing the
* * <code>writeLine()</code> method in <code>DataOutput</code>.
* @return The line read as a <code>String</code> *
* * @return The line read as a <code>String</code>
* @exception IOException If an error occurs *
* * @exception IOException If an error occurs
* @see DataOutput *
*/ * @see DataOutput
String */
readLine() throws IOException; String readLine() throws IOException;
/*************************************************************************/ /*************************************************************************/
/** /**
* This method reads a <code>String</code> from an input stream that is * 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 * 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.
* sequence is read using the <code>readUnsignedShort()</code> method of this * This two byte
* interface. * 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 * After the number of remaining bytes have been determined, these bytes
* <code>char</code> values are encoded in the stream using either a one, two, * are read an transformed into <code>char</code> values. These
* or three byte format. * <code>char</code> values are encoded in the stream using either a one,
* The particular format in use can be determined by examining the first * two, or three byte format.
* byte read. * The particular format in use can be determined by examining the first
* <p> * byte read.
* If the first byte has a high order bit of 0, then * <p>
* that character consists on only one byte. This character value consists * If the first byte has a high order bit of 0, then
* of seven bits that are at positions 0 through 6 of the byte. As an * that character consists on only one byte. This character value consists
* example, if <code>byte1</code> is the byte read from the stream, it would * of seven bits that are at positions 0 through 6 of the byte. As an
* be converted to a <code>char</code> like so: * example, if <code>byte1</code> is the byte read from the stream, it would
* <p> * be converted to a <code>char</code> like so:
* <code>(char)byte1</code> * <p>
* <p> * <code>(char)byte1</code>
* If the first byte has 110 as its high order bits, then the * <p>
* character consists of two bytes. The bits that make up the character * If the first byte has 110 as its high order bits, then the
* value are in positions 0 through 4 of the first byte and bit positions * character consists of two bytes. The bits that make up the character
* 0 through 5 of the second byte. (The second byte should have * value are in positions 0 through 4 of the first byte and bit positions
* 10 as its high order bits). These values are in most significant * 0 through 5 of the second byte. (The second byte should have
* byte first (i.e., "big endian") order. * 10 as its high order bits). These values are in most significant
* <p> * byte first (i.e., "big endian") order.
* As an example, if <code>byte1</code> and <code>byte2</code> are the first * <p>
* two bytes read respectively, and the high order bits of them match the * As an example, if <code>byte1</code> and <code>byte2</code> are the first
* patterns which indicate a two byte character encoding, then they would be * two bytes read respectively, and the high order bits of them match the
* converted to a Java <code>char</code> like so: * patterns which indicate a two byte character encoding, then they would be
* <p> * converted to a Java <code>char</code> like so:
* <code>(char)(((byte1 & 0x1F) << 6) + (byte2 & 0x3F))</code> * <p>
* <p> * <code>(char)(((byte1 & 0x1F) << 6) + (byte2 & 0x3F))</code>
* If the first byte has a 1110 as its high order bits, then the * <p>
* character consists of three bytes. The bits that make up the character * If the first byte has a 1110 as its high order bits, then the
* value are in positions 0 through 3 of the first byte and bit positions * character consists of three bytes. The bits that make up the character
* 0 through 5 of the other two bytes. (The second and third bytes should * value are in positions 0 through 3 of the first byte and bit positions
* have 10 as their high order bits). These values are in most * 0 through 5 of the other two bytes. (The second and third bytes should
* significant byte first (i.e., "big endian") order. * have 10 as their high order bits). These values are in most
* <p> * significant byte first (i.e., "big endian") order.
* As an example, if <code>byte1</code>, <code>byte2</code>, and * <p>
* <code>byte3</code> are the three bytes read, and the high order bits of * As an example, if <code>byte1</code>, <code>byte2</code>, and
* them match the patterns which indicate a three byte character encoding, * <code>byte3</code> are the three bytes read, and the high order bits of
* then they would be converted to a Java <code>char</code> like so: * them match the patterns which indicate a three byte character encoding,
* * then they would be converted to a Java <code>char</code> like so:
* <code> *
* (char)(((byte1 & 0x0F) << 12) + ((byte2 & 0x3F) + (byte3 & 0x3F)) * <code>
* </code> * (char)(((byte1 & 0x0F) << 12) + ((byte2 & 0x3F) + (byte3 & 0x3F))
* * </code>
* Note that all characters are encoded in the method that requires the *
* fewest number of bytes with the exception of the character with the * Note that all characters are encoded in the method that requires the
* value of <code>\<llll>u0000</code> which is encoded as two bytes. This is * fewest number of bytes with the exception of the character with the
* a modification of the UTF standard used to prevent C language style * value of <code>\<llll>u0000</code> which is encoded as two bytes.
* <code>NUL</code> values from appearing in the byte stream. * This is a modification of the UTF standard used to prevent C language
* <p> * style <code>NUL</code> values from appearing in the byte stream.
* This method can read data that was written by an object implementing the * <p>
* <code>writeUTF()</code> method in <code>DataOutput</code>. * 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 *
* * @returns The <code>String</code> read
* @exception EOFException If end of file is reached before reading the String *
* @exception UTFDataFormatException If the data is not in UTF-8 format * @exception EOFException If end of file is reached before reading the
* @exception IOException If any other error occurs * String
* * @exception UTFDataFormatException If the data is not in UTF-8 format
* @see DataOutput * @exception IOException If any other error occurs
*/ *
String * @see DataOutput
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 * This method reads raw bytes into the passed array until the array is
* throws an exception if there is not enough data left in the stream to * full. Note that this method blocks until the data is available and
* fill the buffer * throws an exception if there is not enough data left in the stream to
* * fill the buffer
* @param buf The buffer into which to read the data *
* * @param buf The buffer into which to read the data
* @exception EOFException If end of file is reached before filling the buffer *
* @exception IOException If any other error occurs * @exception EOFException If end of file is reached before filling the
*/ * buffer
void * @exception IOException If any other error occurs
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>
* exactly <code>len</code>. Note that this method blocks until the data is * starting
* available and * throws an exception if there is not enough data left in * <code>offset</code> bytes into the buffer. The number of bytes read
* the stream to read <code>len</code> bytes. * will be
* * exactly <code>len</code>. Note that this method blocks until the data is
* @param buf The buffer into which to read the data * available and * throws an exception if there is not enough data left in
* @param offset The offset into the buffer to start storing data * the stream to read <code>len</code> bytes.
* @param len The number of bytes to read into the buffer *
* * @param buf The buffer into which to read the data
* @exception EOFException If end of file is reached before filling the buffer * @param offset The offset into the buffer to start storing data
* @exception IOException If any other error occurs * @param len The number of bytes to read into the buffer
*/ *
void * @exception EOFException If end of file is reached before filling the
readFully(byte[] buf, int offset, int len) throws EOFException, IOException; * buffer
* @exception IOException If any other error occurs
/*************************************************************************/ */
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 /*************************************************************************/
*
* @param num_bytes The number of bytes to skip /**
* * This method skips and discards the specified number of bytes in an
* @return The number of bytes actually skipped, which will always be * input stream
* <code>num_bytes</code> *
* * @param num_bytes The number of bytes to skip
* @exception EOFException If end of file is reached before all bytes can be *
* skipped * @return The number of bytes actually skipped, which will always be
* @exception IOException If any other error occurs * <code>num_bytes</code>
*/ *
int * @exception EOFException If end of file is reached before all bytes can be
skipBytes(int n) throws EOFException, IOException; * skipped
* @exception IOException If any other error occurs
*/
int skipBytes(int n) throws EOFException, IOException;
} // interface DataInput } // interface DataInput
libjava/java/io/DataInputStream.java
/* DataInputStream.java -- FilteredInputStream that implements DataInput /* 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. This file is part of GNU Classpath.
...@@ -50,8 +50,6 @@ package java.io; ...@@ -50,8 +50,6 @@ package java.io;
* *
* @see DataInput * @see DataInput
* *
* @version 0.0
*
* @author Warren Levy <warrenl@cygnus.com> * @author Warren Levy <warrenl@cygnus.com>
* @author Aaron M. Renn (arenn@urbanophile.com) * @author Aaron M. Renn (arenn@urbanophile.com)
* @date October 20, 1998. * @date October 20, 1998.
......
libjava/java/io/DataOutput.java
...@@ -53,176 +53,165 @@ package java.io; ...@@ -53,176 +53,165 @@ package java.io;
public interface DataOutput public interface DataOutput
{ {
/** /**
* This method writes a Java boolean value to an output stream * This method writes a Java boolean value to an output stream
* *
* @param value The boolean value to write * @param value The boolean value to write
* *
* @exception IOException If an error occurs * @exception IOException If an error occurs
*/ */
void void writeBoolean(boolean value) throws IOException;
writeBoolean(boolean value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/** * This method writes a Java byte value to an output stream
* This method writes a Java byte value to an output stream *
* * @param value The int value to write
* @param value The int value to write *
* * @exception IOException If an error occurs
* @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
/** *
* This method writes a Java char value to an output stream * @param value The char value to write
* *
* @param value The char value to write * @exception IOException If an error occurs
* */
* @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
* This method writes a Java int value to an output stream as a 16 bit value *
* * @exception IOException If an error occurs
* @param value The int value to write as a 16-bit value */
* void writeShort(int value) throws IOException;
* @exception IOException If an error occurs
*/ /*************************************************************************/
void
writeShort(int value) throws IOException; /**
* This method writes a Java int value to an output stream
/*************************************************************************/ *
* @param value The int value to write
/** *
* This method writes a Java int value to an output stream * @exception IOException If an error occurs
* */
* @param value The int value to write void writeInt(int value) throws IOException;
*
* @exception IOException If an error occurs /*************************************************************************/
*/
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
* This method writes a Java long value to an output stream */
* void writeLong(long value) throws IOException;
* @param value The long value to write
* /*************************************************************************/
* @exception IOException If an error occurs
*/ /**
void * This method writes a Java float value to an output stream
writeLong(long value) throws IOException; *
* @param value The float value to write
/*************************************************************************/ *
* @exception IOException If an error occurs
/** */
* This method writes a Java float value to an output stream void writeFloat(float value) throws IOException;
*
* @param value The float value to write /*************************************************************************/
*
* @exception IOException If an error occurs /**
*/ * This method writes a Java double value to an output stream
void *
writeFloat(float value) throws IOException; * @param value The double value to write
*
/*************************************************************************/ * @exception IOException If any other error occurs
*/
/** void writeDouble(double 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 * This method writes a String to an output stream as an array of bytes
*/ *
void * @param value The String to write
writeDouble(double value) throws IOException; *
* @exception IOException If an error occurs
/*************************************************************************/ */
void writeBytes(String value) throws IOException;
/**
* This method writes a String to an output stream as an array of bytes /*************************************************************************/
*
* @param value The String to write /**
* * This method writes a String to an output stream as an array of char's
* @exception IOException If an error occurs *
*/ * @param value The String to write
void *
writeBytes(String value) throws IOException; * @exception IOException If an error occurs
*/
/*************************************************************************/ void writeChars(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 * This method writes a String to an output stream encoded in
* * UTF-8 format.
* @exception IOException If an error occurs *
*/ * @param value The String to write
void *
writeChars(String value) throws IOException; * @exception IOException If an error occurs
*/
/*************************************************************************/ void writeUTF(String value) throws IOException;
/** /*************************************************************************/
* This method writes a String to an output stream encoded in
* UTF-8 format. /**
* * This method writes an 8-bit value (passed into the method as a Java
* @param value The String to write * int) to an output stream.
* *
* @exception IOException If an error occurs * @param value The byte to write to the output stream
*/ *
void * @exception IOException If an error occurs
writeUTF(String value) throws IOException; */
void write(int value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
* This method writes an 8-bit value (passed into the method as a Java /**
* int) to an output stream. * This method writes the raw byte array passed in to the output stream.
* *
* @param value The byte to write to the output stream * @param buf The byte array to write
* *
* @exception IOException If an error occurs * @exception IOException If an error occurs
*/ */
void void write(byte[] buf) throws IOException;
write(int value) throws IOException;
/*************************************************************************/
/*************************************************************************/
/**
/** * This method writes raw bytes from the passed array <code>buf</code>
* This method writes the raw byte array passed in to the output stream. * starting
* * <code>offset</code> bytes into the buffer. The number of bytes
* @param buf The byte array to write * written will be * exactly <code>len</code>.
* *
* @exception IOException If an error occurs * @param buf The buffer from which to write the data
*/ * @param offset The offset into the buffer to start writing data from
void * @param len The number of bytes to write from the buffer to the output
write(byte[] buf) throws IOException; * stream
*
/*************************************************************************/ * @exception IOException If any other error occurs
*/
/** void write(byte[] buf, int offset, int len) 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>.
*
* @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
*
* @exception IOException If any other error occurs
*/
void
write(byte[] buf, int offset, int len) throws IOException;
} // interface DataOutput } // interface DataOutput
libjava/java/io/Externalizable.java
...@@ -56,55 +56,58 @@ package java.io; ...@@ -56,55 +56,58 @@ package java.io;
* created using the default no-argument constructor and the * created using the default no-argument constructor and the
* <code>readExternal</code> method is used to restore the state. * <code>readExternal</code> method is used to restore the state.
* *
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com) * @author Aaron M. Renn (arenn@urbanophile.com)
*/ */
public interface Externalizable extends Serializable public interface Externalizable extends Serializable
{ {
static final long serialVersionUID = -282491828744381764L; static final long serialVersionUID = -282491828744381764L;
/** /**
* This method restores an object's state by reading in the instance data * 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 * 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 * a subclass of <code>InputStream</code>, but rather is a class that
* the <code>ObjectInput</code> interface. That interface provides a mechanism for * implements
* reading in Java data types from a stream. * the <code>ObjectInput</code> interface. That interface provides a
* <p> * mechanism for
* Note that this method must be compatible with <code>writeExternal</code>. * reading in Java data types from a stream.
* It must read back the exact same types that were written by that * <p>
* method in the exact order they were written. * Note that this method must be compatible with <code>writeExternal</code>.
* <p> * It must read back the exact same types that were written by that
* If this method needs to read back an object instance, then the class * method in the exact order they were written.
* for that object must be found and loaded. If that operation fails, * <p>
* then this method throws a <code>ClassNotFoundException</code> * If this method needs to read back an object instance, then the class
* * for that object must be found and loaded. If that operation fails,
* @param in An <code>ObjectInput</code> instance for reading in the object state * then this method throws a <code>ClassNotFoundException</code>
* *
* @exception ClassNotFoundException If the class of an object being restored cannot be found * @param in An <code>ObjectInput</code> instance for reading in the object
* @exception IOException If any other error occurs * state
*/ *
public abstract void * @exception ClassNotFoundException If the class of an object being
readExternal(ObjectInput in) throws ClassNotFoundException, IOException; * restored cannot be found
* @exception IOException If any other error occurs
*/
public abstract void readExternal(ObjectInput in)
throws ClassNotFoundException, IOException;
/*************************************************************************/ /*************************************************************************/
/** /**
* This method is responsible for writing the instance data of an object * 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 * 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>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
* for writing Java data values to a stream. * number of methods
* <p> * for writing Java data values to a stream.
* Not that the implementation of this method must be coordinated with * <p>
* the implementation of <code>readExternal</code>. * 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
* @exception IOException If an error occurs * object state
*/ *
public abstract void * @exception IOException If an error occurs
writeExternal(ObjectOutput out) throws IOException; */
public abstract void writeExternal(ObjectOutput out) throws IOException;
} // interface Externalizable } // 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