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 126 additions and 137 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/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