Skip to content

R
riscv-gcc-1
Commit 865b4ea7 by Bryce McKinlay Committed by Bryce McKinlay
Options

PipedInputStream: Rewrote to be simpler and more correct. 

	* java/io/PipedInputStream: Rewrote to be simpler and more correct.
	* java/io/PipedOutputStream: Updated to match new PipedInputStream.
	* java/io/PipedReader: New implementation based on new
	PipedInputStream.
	* java/io/PipedWriter: Updated to match new PipedOutputStream.

From-SVN: r38708
parent a5a4ce3c
Showing with 196 additions and 274 deletions
libjava/ChangeLog
...@@ -2,6 +2,12 @@ ...@@ -2,6 +2,12 @@
* java/lang/Thread.java: Update comment. * java/lang/Thread.java: Update comment.
* java/io/PipedInputStream: Rewrote to be simpler and more correct.
* java/io/PipedOutputStream: Updated to match new PipedInputStream.
* java/io/PipedReader: New implementation based on new
PipedInputStream.
* java/io/PipedWriter: Updated to match new PipedOutputStream.
2001-01-03 Tom Tromey <tromey@redhat.com> 2001-01-03 Tom Tromey <tromey@redhat.com>
* java/awt/ScrollPane.java (setBlockIncrement): Throw error. * java/awt/ScrollPane.java (setBlockIncrement): Throw error.
......
libjava/java/io/PipedOutputStream.java
/* PipedOutputStream.java -- Write portion of piped streams. /* PipedOutputStream.java -- Write portion of piped streams.
Copyright (C) 1998, 2000 Free Software Foundation, Inc. Copyright (C) 1998, 2000, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -27,6 +27,10 @@ executable file might be covered by the GNU General Public License. */ ...@@ -27,6 +27,10 @@ executable file might be covered by the GNU General Public License. */
package java.io; package java.io;
// NOTE: This implementation is very similar to that of PipedWriter. If you
// fix a bug in here, chances are you should make a similar change to the
// PipedWriter code.
/** /**
* This class writes its bytes to a <code>PipedInputStream</code> to * This class writes its bytes to a <code>PipedInputStream</code> to
* which it is connected. * which it is connected.
...@@ -36,171 +40,131 @@ package java.io; ...@@ -36,171 +40,131 @@ package java.io;
* they are in the same thread, read and write operations could deadlock * they are in the same thread, read and write operations could deadlock
* the thread. * the thread.
* *
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com) * @author Aaron M. Renn (arenn@urbanophile.com)
*/ */
public class PipedOutputStream extends OutputStream public class PipedOutputStream extends OutputStream
{ {
/** Target PipedInputStream to which this is connected. Null only if this
* OutputStream hasn't been connected yet. */
PipedInputStream sink;
/*************************************************************************/ /** Set to true if close() has been called on this OutputStream. */
boolean closed;
/*
* Instance Variables
*/
/**
* This is the <code>PipedInputStream</code> to which this object
* is connected.
*/
private PipedInputStream snk;
/**
* This flag indicates whether or not this stream has ever been
* connected to an input stream
*/
private boolean ever_connected;
/**
* This flag indicates whether the <code>close</code> method has ever
* been called for this stream.
*/
private boolean closed;
/*************************************************************************/
/** /**
* This method initializes a new <code>PipedOutputStream</code> instance. * Create an unconnected PipedOutputStream. It must be connected
* This constructor creates an unconnected object. It must be connected * to a <code>PipedInputStream</code> using the <code>connect</code>
* to a <code>PipedInputStream</code> object using the <code>connect</code>
* method prior to writing any data or an exception will be thrown. * method prior to writing any data or an exception will be thrown.
*/ */
public public PipedOutputStream()
PipedOutputStream() {
{ }
; // Do Nothing
}
/*************************************************************************/
/** /**
* This method initializes a new <code>PipedOutputStream</code> instance * Create a new <code>PipedOutputStream</code> instance
* to write to the specified <code>PipedInputStream</code>. This stream * to write to the specified <code>PipedInputStream</code>. This stream
* is then ready for writing. * is then ready for writing.
* *
* @param snk The <code>PipedInputStream</code> to connect this stream to. * @param sink The <code>PipedInputStream</code> to connect this stream to.
* *
* @exception IOException If an error occurs * @exception IOException If <code>sink</code> has already been connected
* to a different PipedOutputStream.
*/ */
public public PipedOutputStream(PipedInputStream sink) throws IOException
PipedOutputStream(PipedInputStream snk) throws IOException {
{ sink.connect(this);
connect(snk); }
}
/**
/*************************************************************************/ * Connects this object to the specified <code>PipedInputStream</code>
* object. This stream will then be ready for writing.
/*
* Instance Methods
*/
/**
* This method connects this object to the specified
* <code>PipedInputStream</code> object. This stream will then be ready
* for writing. If this stream is already connected or has been
* previously closed, then an exception is thrown.
* *
* @param snk The <code>PipedInputStream</code> to connect this stream to * @param sink The <code>PipedInputStream</code> to connect this stream to
* *
* @exception IOException If an error occurs * @exception IOException If the stream has not been connected or has
* been closed.
*/ */
public synchronized void public void connect(PipedInputStream sink) throws IOException
connect(PipedInputStream snk) throws IOException {
{ if (sink != null)
if (snk == this.snk) throw new IOException ("Already connected");
return; sink.connect(this);
}
if (ever_connected)
throw new IOException("Already connected"); /**
* Write a single byte of date to the stream. Note that this method will
if (closed) * block if the <code>PipedInputStream</code> to which this object is
throw new IOException("Stream is closed and cannot be reopened"); * connected has a full buffer.
this.snk = snk;
ever_connected = true;
snk.src = this;
snk.connect(this);
}
/*************************************************************************/
/**
* This method closes this stream so that no more data can be written
* to it. Any further attempts to write to this stream may throw an
* exception
*
* @exception IOException If an error occurs
*/
public synchronized void
close() throws IOException
{
closed = true;
snk.close();
notifyAll();
}
/*************************************************************************/
/**
* This method writes a single byte of date to the stream. Note that
* this method will block if the <code>PipedInputStream</code> to which
* this object is connected has a full buffer.
* *
* @param b The byte of data to be written, passed as an <code>int</code>. * @param b The byte of data to be written, passed as an <code>int</code>.
* *
* @exception IOException If an error occurs * @exception IOException If the stream has not been connected or has
* been closed.
*/ */
public synchronized void public void write(int b) throws IOException
write(int b) throws IOException {
{ if (sink == null)
snk.receive (b); throw new IOException ("Not connected");
} if (closed)
throw new IOException ("Pipe closed");
/*************************************************************************/ sink.receive (b);
}
/** /**
* This method writes <code>len</code> bytes of data from the byte array * This method writes <code>len</code> bytes of data from the byte array
* <code>buf</code> starting at index <code>offset</code> in the array * <code>buf</code> starting at index <code>offset</code> in the array
* to the stream. Note that this method will block if the * to the stream. Note that this method will block if the
* <code>PipedInputStream</code> to which this object is connected has * <code>PipedInputStream</code> to which this object is connected has
* a buffer that cannot hold all of the bytes to be written. * a buffer that cannot hold all of the bytes to be written.
* *
* @param buf The array containing bytes to write to thes stream. * @param buf The array containing bytes to write to the stream.
* @param offset The index into the array to start writing bytes from. * @param offset The index into the array to start writing bytes from.
* @param len The number of bytes to write. * @param len The number of bytes to write.
* *
* @exception IOException If an error occurs * @exception IOException If the stream has not been connected or has
* been closed.
*/ */
public void public void write(byte[] b, int off, int len) throws IOException
write(byte[] buf, int offset, int len) throws IOException {
{ if (sink == null)
snk.receive (buf, 0, len); throw new IOException ("Not connected");
} if (closed)
throw new IOException ("Pipe closed");
/*************************************************************************/ sink.receive (b, off, len);
}
/** /**
* This method flushes any unwritten bytes to the output and notifies * This method does nothing.
* any waiting readers that the pipe is ready to be read.
* *
* @exception IOException If an error occurs. * @exception IOException If the stream is closed.
* @specnote You'd think that this method would block until the sink
* had read all available data. Thats not the case - this method
* appears to be a no-op?
*/ */
public void public void flush()
flush() throws IOException {
{ }
return;
}
} // class PipedOutputStream
/**
* This method closes this stream so that no more data can be written
* to it. Any further attempts to write to this stream may throw an
* exception
*
* @exception IOException If an error occurs
*/
public void close()
{
// A close call on an unconnected PipedOutputStream has no effect.
if (sink != null)
{
closed = true;
// Notify any waiting readers that the stream is now closed.
synchronized (sink)
{
sink.notifyAll();
}
}
}
}
libjava/java/io/PipedWriter.java
/* PipedWriter.java -- Write portion of piped streams. /* PipedWriter.java -- Write portion of piped character streams.
Copyright (C) 1998 Free Software Foundation, Inc. Copyright (C) 1998, 2000, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -27,6 +27,10 @@ executable file might be covered by the GNU General Public License. */ ...@@ -27,6 +27,10 @@ executable file might be covered by the GNU General Public License. */
package java.io; package java.io;
// NOTE: This implementation is very similar to that of PipedOutputStream.
// If you fix a bug in here, chances are you should make a similar change to
// the PipedOutputStream code.
/** /**
* This class writes its chars to a <code>PipedReader</code> to * This class writes its chars to a <code>PipedReader</code> to
* which it is connected. * which it is connected.
...@@ -36,182 +40,130 @@ package java.io; ...@@ -36,182 +40,130 @@ package java.io;
* they are in the same thread, read and write operations could deadlock * they are in the same thread, read and write operations could deadlock
* the thread. * the thread.
* *
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com) * @author Aaron M. Renn (arenn@urbanophile.com)
*/ */
public class PipedWriter extends Writer public class PipedWriter extends Writer
{ {
/** Target PipedReader to which this is connected. Null only if this
* Writer hasn't been connected yet. */
PipedReader sink;
/*************************************************************************/ /** Set to true if close() has been called on this Writer. */
boolean closed;
/*
* Instance Variables
*/
/**
* This is the <code>PipedReader</code> to which this object
* is connected.
*/
private PipedReader snk;
/** /** Buffer used to implement single-argument write */
* This flag indicates whether or not this stream has ever been char[] read_buf = new char[1];
* connected to an input stream
*/
private boolean ever_connected;
/** /**
* This flag indicates whether the <code>close</code> method has ever * Create an unconnected PipedWriter. It must be connected
* been called for this stream. * to a <code>PipedReader</code> using the <code>connect</code>
*/
private boolean closed;
/*************************************************************************/
/**
* This method initializes a new <code>PipedWriter</code> instance.
* This constructor creates an unconnected object. It must be connected
* to a <code>PipedReader</code> object using the <code>connect</code>
* method prior to writing any data or an exception will be thrown. * method prior to writing any data or an exception will be thrown.
*/ */
public public PipedWriter()
PipedWriter() {
{ }
; // Do Nothing
}
/*************************************************************************/
/** /**
* This method initializes a new <code>PipedWriter</code> instance * Create a new <code>PipedWriter</code> instance
* to write to the specified <code>PipedReader</code>. This stream * to write to the specified <code>PipedReader</code>. This stream
* is then ready for writing. * is then ready for writing.
* *
* @param snk The <code>PipedReader</code> to connect this stream to. * @param sink The <code>PipedReader</code> to connect this stream to.
* *
* @exception IOException If an error occurs * @exception IOException If <code>sink</code> has already been connected
* to a different PipedWriter.
*/ */
public public PipedWriter(PipedReader sink) throws IOException
PipedWriter(PipedReader snk) throws IOException {
{ sink.connect(this);
connect(snk); }
}
/**
/*************************************************************************/ * Connects this object to the specified <code>PipedReader</code>
* object. This stream will then be ready for writing.
/*
* Instance Methods
*/
/**
* This method connects this object to the specified
* <code>PipedReader</code> object. This stream will then be ready
* for writing. If this stream is already connected or has been
* previously closed, then an exception is thrown.
* *
* @param snk The <code>PipedReader</code> to connect this stream to * @param sink The <code>PipedReader</code> to connect this stream to
* *
* @exception IOException If an error occurs * @exception IOException If the stream has not been connected or has
* been closed.
*/ */
public void public void connect(PipedReader sink) throws IOException
connect(PipedReader snk) throws IOException {
{ if (sink != null)
if (snk == this.snk) throw new IOException ("Already connected");
return; sink.connect(this);
}
if (ever_connected)
throw new IOException("Already connected"); /**
* Write a single char of date to the stream. Note that this method will
if (closed) * block if the <code>PipedReader</code> to which this object is
throw new IOException("Stream is closed and cannot be reopened"); * connected has a full buffer.
synchronized (lock) {
this.snk = snk;
ever_connected = true;
snk.src = this;
snk.connect(this);
} // synchronized
}
/*************************************************************************/
/**
* This method closes this stream so that no more data can be written
* to it. Any further attempts to write to this stream may throw an
* exception
*
* @exception IOException If an error occurs
*/
public void
close() throws IOException
{
synchronized (lock) {
closed = true;
snk.close();
notifyAll();
} // synchronized
}
/*************************************************************************/
/**
* This methods writes a single byte of data to the pipe. This call may
* block if the pipe is full.
* *
* @param c The <code>char</code> to write, passed as an <code>int</code>. * @param b The char of data to be written, passed as an <code>int</code>.
* *
* @exception IOException If an error occurs. * @exception IOException If the stream has not been connected or has
* been closed.
*/ */
public void public void write(char b) throws IOException
write(int c) throws IOException {
{ read_buf[0] = b;
char[] buf = new char[1]; sink.receive (read_buf, 0, 1);
buf[0] = (char)c; }
write(buf, 0, buf.length);
}
/*************************************************************************/
/** /**
* This method writes <code>len</code> chars of data from the char array * This method writes <code>len</code> chars of data from the char array
* <code>buf</code> starting at index <code>offset</code> in the array * <code>buf</code> starting at index <code>offset</code> in the array
* to the stream. Note that this method will block if the * to the stream. Note that this method will block if the
* <code>PipedReader</code> to which this object is connected has * <code>PipedReader</code> to which this object is connected has
* a buffer that cannot hold all of the chars to be written. * a buffer that cannot hold all of the chars to be written.
* *
* @param buf The array containing chars to write to thes stream. * @param buf The array containing chars to write to the stream.
* @param offset The index into the array to start writing chars from. * @param offset The index into the array to start writing chars from.
* @param len The number of chars to write. * @param len The number of chars to write.
* *
* @exception IOException If an error occurs * @exception IOException If the stream has not been connected or has
* been closed.
*/ */
public void public void write(char[] b, int off, int len) throws IOException
write(char[] buf, int offset, int len) throws IOException {
{ if (sink == null)
snk.write(buf, 0, len); throw new IOException ("Not connected");
} if (closed)
throw new IOException ("Pipe closed");
/*************************************************************************/ sink.receive (b, off, len);
}
/** /**
* This method flushes any unwritten chars to the underlying output * This method does nothing.
* sink. This method does nothing in this class because this class does *
* not buffer any chars. * @exception IOException If the stream is closed.
* @specnote You'd think that this method would block until the sink
* had read all available data. Thats not the case - this method
* appears to be a no-op?
*/
public void flush()
{
}
/**
* This method closes this stream so that no more data can be written
* to it. Any further attempts to write to this stream may throw an
* exception
* *
* @exception IOException If an error occurs * @exception IOException If an error occurs
*/ */
public void public void close()
flush() throws IOException {
{ // A close call on an unconnected PipedWriter has no effect.
; // Do Nothing if (sink != null)
{
closed = true;
// Notify any waiting readers that the stream is now closed.
synchronized (sink)
{
sink.notifyAll();
}
}
}
} }
} // class PipedWriter
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