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 262 additions and 340 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;
/*
* Instance Variables /** Set to true if close() has been called on this OutputStream. */
*/ boolean closed;
/** /**
* This is the <code>PipedInputStream</code> to which this object * Create an unconnected PipedOutputStream. It must be connected
* is connected. * to a <code>PipedInputStream</code> using the <code>connect</code>
*/ * method prior to writing any data or an exception will be thrown.
private PipedInputStream snk; */
public PipedOutputStream()
/** {
* This flag indicates whether or not this stream has ever been }
* connected to an input stream
*/ /**
private boolean ever_connected; * Create a new <code>PipedOutputStream</code> instance
* to write to the specified <code>PipedInputStream</code>. This stream
/** * is then ready for writing.
* This flag indicates whether the <code>close</code> method has ever *
* been called for this stream. * @param sink The <code>PipedInputStream</code> to connect this stream to.
*/ *
private boolean closed; * @exception IOException If <code>sink</code> has already been connected
* to a different PipedOutputStream.
/*************************************************************************/ */
public PipedOutputStream(PipedInputStream sink) throws IOException
/** {
* This method initializes a new <code>PipedOutputStream</code> instance. sink.connect(this);
* This constructor creates an unconnected object. It must be connected }
* to a <code>PipedInputStream</code> object using the <code>connect</code>
* method prior to writing any data or an exception will be thrown. /**
*/ * Connects this object to the specified <code>PipedInputStream</code>
public * object. This stream will then be ready for writing.
PipedOutputStream() *
{ * @param sink The <code>PipedInputStream</code> to connect this stream to
; // Do Nothing *
} * @exception IOException If the stream has not been connected or has
* been closed.
/*************************************************************************/ */
public void connect(PipedInputStream sink) throws IOException
/** {
* This method initializes a new <code>PipedOutputStream</code> instance if (sink != null)
* to write to the specified <code>PipedInputStream</code>. This stream throw new IOException ("Already connected");
* is then ready for writing. sink.connect(this);
* }
* @param snk The <code>PipedInputStream</code> to connect this stream to.
* /**
* @exception IOException If an error occurs * Write a single byte of date to the stream. Note that this method will
*/ * block if the <code>PipedInputStream</code> to which this object is
public * connected has a full buffer.
PipedOutputStream(PipedInputStream snk) throws IOException *
{ * @param b The byte of data to be written, passed as an <code>int</code>.
connect(snk); *
} * @exception IOException If the stream has not been connected or has
* been closed.
/*************************************************************************/ */
public void write(int b) throws IOException
/* {
* Instance Methods if (sink == null)
*/ throw new IOException ("Not connected");
if (closed)
/** throw new IOException ("Pipe closed");
* This method connects this object to the specified
* <code>PipedInputStream</code> object. This stream will then be ready sink.receive (b);
* 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 * 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
* @exception IOException If an error occurs * to the stream. Note that this method will block if the
*/ * <code>PipedInputStream</code> to which this object is connected has
public synchronized void * a buffer that cannot hold all of the bytes to be written.
connect(PipedInputStream snk) throws IOException *
{ * @param buf The array containing bytes to write to the stream.
if (snk == this.snk) * @param offset The index into the array to start writing bytes from.
return; * @param len The number of bytes to write.
*
if (ever_connected) * @exception IOException If the stream has not been connected or has
throw new IOException("Already connected"); * been closed.
*/
if (closed) public void write(byte[] b, int off, int len) throws IOException
throw new IOException("Stream is closed and cannot be reopened"); {
if (sink == null)
this.snk = snk; throw new IOException ("Not connected");
ever_connected = true; if (closed)
snk.src = this; throw new IOException ("Pipe closed");
snk.connect(this); sink.receive (b, off, len);
} }
/*************************************************************************/ /**
* This method does nothing.
/** *
* This method closes this stream so that no more data can be written * @exception IOException If the stream is closed.
* to it. Any further attempts to write to this stream may throw an * @specnote You'd think that this method would block until the sink
* exception * had read all available data. Thats not the case - this method
* * appears to be a no-op?
* @exception IOException If an error occurs */
*/ public void flush()
public synchronized void {
close() throws IOException }
{
closed = true; /**
snk.close(); * This method closes this stream so that no more data can be written
notifyAll(); * to it. Any further attempts to write to this stream may throw an
} * exception
*
/*************************************************************************/ * @exception IOException If an error occurs
*/
/** public void close()
* This method writes a single byte of date to the stream. Note that {
* this method will block if the <code>PipedInputStream</code> to which // A close call on an unconnected PipedOutputStream has no effect.
* this object is connected has a full buffer. if (sink != null)
* {
* @param b The byte of data to be written, passed as an <code>int</code>. closed = true;
* // Notify any waiting readers that the stream is now closed.
* @exception IOException If an error occurs synchronized (sink)
*/ {
public synchronized void sink.notifyAll();
write(int b) throws IOException }
{ }
snk.receive (b); }
} }
/*************************************************************************/
/**
* 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
* to the stream. Note that this method will block if the
* <code>PipedInputStream</code> to which this object is connected has
* a buffer that cannot hold all of the bytes to be written.
*
* @param buf The array containing bytes to write to thes stream.
* @param offset The index into the array to start writing bytes from.
* @param len The number of bytes to write.
*
* @exception IOException If an error occurs
*/
public void
write(byte[] buf, int offset, int len) throws IOException
{
snk.receive (buf, 0, len);
}
/*************************************************************************/
/**
* This method flushes any unwritten bytes to the output and notifies
* any waiting readers that the pipe is ready to be read.
*
* @exception IOException If an error occurs.
*/
public void
flush() throws IOException
{
return;
}
} // class PipedOutputStream
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;
/*
* Instance Variables /** Set to true if close() has been called on this Writer. */
*/ boolean closed;
/** /** Buffer used to implement single-argument write */
* This is the <code>PipedReader</code> to which this object char[] read_buf = new char[1];
* is connected.
*/ /**
private PipedReader snk; * Create an unconnected PipedWriter. It must be connected
* to a <code>PipedReader</code> using the <code>connect</code>
/** * method prior to writing any data or an exception will be thrown.
* This flag indicates whether or not this stream has ever been */
* connected to an input stream public PipedWriter()
*/ {
private boolean ever_connected; }
/** /**
* This flag indicates whether the <code>close</code> method has ever * Create a new <code>PipedWriter</code> instance
* been called for this stream. * to write to the specified <code>PipedReader</code>. This stream
*/ * is then ready for writing.
private boolean closed; *
* @param sink The <code>PipedReader</code> to connect this stream to.
/*************************************************************************/ *
* @exception IOException If <code>sink</code> has already been connected
/** * to a different PipedWriter.
* This method initializes a new <code>PipedWriter</code> instance. */
* This constructor creates an unconnected object. It must be connected public PipedWriter(PipedReader sink) throws IOException
* to a <code>PipedReader</code> object using the <code>connect</code> {
* method prior to writing any data or an exception will be thrown. sink.connect(this);
*/ }
public
PipedWriter() /**
{ * Connects this object to the specified <code>PipedReader</code>
; // Do Nothing * object. This stream will then be ready for writing.
} *
* @param sink The <code>PipedReader</code> to connect this stream to
/*************************************************************************/ *
* @exception IOException If the stream has not been connected or has
/** * been closed.
* This method initializes a new <code>PipedWriter</code> instance */
* to write to the specified <code>PipedReader</code>. This stream public void connect(PipedReader sink) throws IOException
* is then ready for writing. {
* if (sink != null)
* @param snk The <code>PipedReader</code> to connect this stream to. throw new IOException ("Already connected");
* sink.connect(this);
* @exception IOException If an error occurs }
*/
public /**
PipedWriter(PipedReader snk) throws IOException * Write a single char of date to the stream. Note that this method will
{ * block if the <code>PipedReader</code> to which this object is
connect(snk); * connected has a full buffer.
} *
* @param b The char of data to be written, passed as an <code>int</code>.
/*************************************************************************/ *
* @exception IOException If the stream has not been connected or has
/* * been closed.
* Instance Methods */
*/ public void write(char b) throws IOException
{
/** read_buf[0] = b;
* This method connects this object to the specified sink.receive (read_buf, 0, 1);
* <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. /**
* * This method writes <code>len</code> chars of data from the char array
* @param snk The <code>PipedReader</code> to connect this stream to * <code>buf</code> starting at index <code>offset</code> in the array
* * to the stream. Note that this method will block if the
* @exception IOException If an error occurs * <code>PipedReader</code> to which this object is connected has
*/ * a buffer that cannot hold all of the chars to be written.
public void *
connect(PipedReader snk) throws IOException * @param buf The array containing chars to write to the stream.
{ * @param offset The index into the array to start writing chars from.
if (snk == this.snk) * @param len The number of chars to write.
return; *
* @exception IOException If the stream has not been connected or has
if (ever_connected) * been closed.
throw new IOException("Already connected"); */
public void write(char[] b, int off, int len) throws IOException
if (closed) {
throw new IOException("Stream is closed and cannot be reopened"); if (sink == null)
throw new IOException ("Not connected");
synchronized (lock) { if (closed)
throw new IOException ("Pipe closed");
this.snk = snk;
ever_connected = true; sink.receive (b, off, len);
snk.src = this; }
snk.connect(this); /**
* This method does nothing.
} // synchronized *
} * @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?
/** */
* This method closes this stream so that no more data can be written public void flush()
* to it. Any further attempts to write to this stream may throw an {
* exception }
*
* @exception IOException If an error occurs /**
*/ * This method closes this stream so that no more data can be written
public void * to it. Any further attempts to write to this stream may throw an
close() throws IOException * exception
{ *
synchronized (lock) { * @exception IOException If an error occurs
*/
closed = true; public void close()
snk.close(); {
notifyAll(); // A close call on an unconnected PipedWriter has no effect.
if (sink != null)
} // synchronized {
closed = true;
// Notify any waiting readers that the stream is now closed.
synchronized (sink)
{
sink.notifyAll();
}
}
}
} }
/*************************************************************************/
/**
* 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>.
*
* @exception IOException If an error occurs.
*/
public void
write(int c) throws IOException
{
char[] buf = new char[1];
buf[0] = (char)c;
write(buf, 0, buf.length);
}
/*************************************************************************/
/**
* 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
* to the stream. Note that this method will block if the
* <code>PipedReader</code> to which this object is connected has
* a buffer that cannot hold all of the chars to be written.
*
* @param buf The array containing chars to write to thes stream.
* @param offset The index into the array to start writing chars from.
* @param len The number of chars to write.
*
* @exception IOException If an error occurs
*/
public void
write(char[] buf, int offset, int len) throws IOException
{
snk.write(buf, 0, len);
}
/*************************************************************************/
/**
* This method flushes any unwritten chars to the underlying output
* sink. This method does nothing in this class because this class does
* not buffer any chars.
*
* @exception IOException If an error occurs
*/
public void
flush() throws IOException
{
; // Do Nothing
}
} // 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