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 862 additions and 1240 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/PipedInputStream.java
/* PipedInputStream.java -- Input stream that reads from an output stream /* PipedInputStream.java -- Read portion of piped streams.
Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc. Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -24,467 +24,334 @@ resulting executable to be covered by the GNU General Public License. ...@@ -24,467 +24,334 @@ resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */ executable file might be covered by the GNU General Public License. */
// NOTE: This implementation is very similar to that of PipedReader. If you
// fix a bug in here, chances are you should make a similar change to the
// PipedReader code.
package java.io; package java.io;
/** /**
* This class is an input stream that reads its bytes from an output stream * An input stream that reads its bytes from an output stream
* to which it is connected. * to which it is connected.
* <p> * <p>
* Data is read and written to an internal buffer. It is highly recommended * Data is read and written to an internal buffer. It is highly recommended
* that the <code>PipedInputStream</code> and connected <code>PipedOutputStream</code> * that the <code>PipedInputStream</code> and connected <code>PipedOutputStream</code>
* be part of different threads. If they are not, there is a possibility * be part of different threads. If they are not, the read and write
* that the read and write operations could deadlock their thread. * operations could deadlock their thread.
* *
* @version 0.0 * @specnote The JDK implementation appears to have some undocumented
* functionality where it keeps track of what thread is writing
* to pipe and throws an IOException if that thread susequently
* dies. This behaviour seems dubious and unreliable - we don't
* implement it.
* *
* @author Aaron M. Renn (arenn@urbanophile.com) * @author Aaron M. Renn (arenn@urbanophile.com)
*/ */
public class PipedInputStream extends InputStream public class PipedInputStream extends InputStream
{ {
/** PipedOutputStream to which this is connected. Null only if this
/*************************************************************************/ * InputStream hasn't been connected yet. */
PipedOutputStream source;
/*
* Class Variables /** Set to true if close() has been called on this InputStream. */
*/ boolean closed;
/** /**
* The size of the internal buffer used for input/output. Note that this * The size of the internal buffer used for input/output.
* can be overriden by setting the system property */
* <code>gnu.java.io.PipedInputStream.pipe_size</code> to the desired size shown protected static final int PIPE_SIZE = 2048;
* in bytes. This is not a standard part of the class library. Note that
* since this variable is <code>final</code>, it cannot be changed to refect /**
* the size specified in the property. * This is the internal circular buffer used for storing bytes written
* <p> * to the pipe and from which bytes are read by this stream
* The value for this variable is 2048. */
*/ protected byte[] buffer = new byte[PIPE_SIZE];
protected static final int PIPE_SIZE = 2048;
/**
/** * The index into buffer where the next byte from the connected
* This is the real pipe size. It defaults to PIPE_SIZE, unless overridden * <code>PipedOutputStream</code> will be written. If this variable is
* by use of the system property <code>gnu.java.io.PipedInputStream.pipe_size</code>. * equal to <code>out</code>, then the buffer is full. If set to < 0,
*/ * the buffer is empty.
private static int pipe_size; */
protected int in = -1;
static
{ /**
pipe_size = Integer.getInteger("gnu.java.io.PipedInputStream.pipe_size", * This index into the buffer where bytes will be read from.
PIPE_SIZE).intValue(); */
} protected int out = 0;
/*************************************************************************/ /** Buffer used to implement single-argument read/receive */
private byte[] read_buf = new byte[1];
/*
* Instance Variables /**
*/ * Creates a new <code>PipedInputStream</code> that is not connected to a
* <code>PipedOutputStream</code>. It must be connected before bytes can
/** * be read from this stream.
* This is the internal circular buffer used for storing bytes written */
* to the pipe and from which bytes are read by this stream public PipedInputStream()
*/ {
protected byte[] buffer = new byte[pipe_size]; }
/** /**
* The index into buffer where the bytes written byte the connected * This constructor creates a new <code>PipedInputStream</code> and connects
* <code>PipedOutputStream</code> will be written. If this variables is less * it to the passed in <code>PipedOutputStream</code>. The stream is then
* than 0, then the buffer is empty. If this variable is equal to * ready for reading.
* <code>out</code>, then the buffer is full *
*/ * @param source The <code>PipedOutputStream</code> to connect this stream to
protected int in = -1; *
* @exception IOException If <code>source</code> is already connected.
/** */
* This index into the buffer where bytes will be read from. public PipedInputStream(PipedOutputStream source) throws IOException
*/ {
protected int out = 0; connect(source);
}
/**
* This variable is <code>true</code> if this object has ever been connected /**
* to a <code>PipedOutputStream</code>, and <code>false</code> otherwise. It is used * This method connects this stream to the passed in <code>PipedOutputStream</code>.
* to detect an attempt to connect an already connected stream or to * This stream is then ready for reading. If this stream is already
* otherwise use the stream before it is connected. * connected or has been previously closed, then an exception is thrown
*/ *
private boolean ever_connected = false; * @param src The <code>PipedOutputStream</code> to connect this stream to
*
/** * @exception IOException If this PipedInputStream or <code>source</code>
* This variable is set to <code>true</code> if the <code>close()</code> method is * has been connected already.
* called. This value is checked prevents a caller from re-opening the */
* stream. public void connect(PipedOutputStream source) throws IOException
*/ {
private boolean closed = false; // The JDK (1.3) does not appear to check for a previously closed
// connection here.
/**
* This variable is the PipedOutputStream to which this stream is connected. if (this.source != null || source.sink != null)
*/ throw new IOException ("Already connected");
PipedOutputStream src;
source.sink = this;
/** this.source = source;
* Used by <code>read()</code> to call an overloaded method }
*/
private byte[] read_buf = new byte[1]; /**
/*************************************************************************/
/*
* Constructors
*/
/**
* This constructor creates a new <code>PipedInputStream</code> that is not
* connected to a <code>PipedOutputStream</code>. It must be connected before
* bytes can be read from this stream.
*/
public
PipedInputStream()
{
return;
}
/*************************************************************************/
/**
* This constructor creates a new <code>PipedInputStream</code> and connects
* it to the passed in <code>PipedOutputStream</code>. The stream is then read
* for reading.
*
* @param src The <code>PipedOutputStream</code> to connect this stream to
*
* @exception IOException If an error occurs
*/
public
PipedInputStream(PipedOutputStream src) throws IOException
{
connect(src);
}
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This method connects this stream to the passed in <code>PipedOutputStream</code>.
* This stream is then ready for reading. If this stream is already
* connected or has been previously closed, then an exception is thrown
*
* @param src The <code>PipedOutputStream</code> to connect this stream to
*
* @exception IOException If an error occurs
*/
public synchronized void
connect(PipedOutputStream src) throws IOException
{
if (src == this.src)
return;
if (ever_connected)
throw new IOException("Already connected");
if (closed)
throw new IOException("Stream is closed and cannot be reopened");
src.connect(this);
ever_connected = true;
}
/*************************************************************************/
/**
* This methods closes the stream so that no more data can be read
* from it.
*
* @exception IOException If an error occurs
*/
public synchronized void
close() throws IOException
{
closed = true;
notifyAll();
}
/*************************************************************************/
/**
* This method returns the number of bytes that can be read from this stream
* before blocking could occur. This is the number of bytes that are
* currently unread in the internal circular buffer. Note that once this
* many additional bytes are read, the stream may block on a subsequent
* read, but it not guaranteed to block.
*
* @return The number of bytes that can be read before blocking might occur
*
* @exception IOException If an error occurs
*/
public synchronized int
available() throws IOException
{
if (in == -1)
return(0);
else if (in > out)
return(in - out);
else
return(in + (pipe_size - out));
}
/*************************************************************************/
/**
* Reads the next byte from the stream. The byte read is returned as
* and int in the range of 0-255. If a byte cannot be read because of an
* end of stream condition, -1 is returned. If the stream is already
* closed, an IOException will be thrown.
* <code>
* This method will block if no bytes are available to be read.
*
* @return The byte read or -1 if end of stream.
*
* @exception IOException If an error occurs
*/
public synchronized int
read() throws IOException
{
// Method operates by calling the multibyte overloaded read method
// Note that read_buf is an internal instance variable. I allocate it
// there to avoid constant reallocation overhead for applications that
// call this method in a loop at the cost of some unneeded overhead
// if this method is never called.
int bytes_read = read(read_buf, 0, read_buf.length);
if (bytes_read == -1)
return(-1);
else
return((read_buf[0] & 0xFF));
}
/*************************************************************************/
/**
* This method reads bytes from the stream into a caller supplied buffer.
* It starts storing bytes at position <code>offset</code> into the buffer and
* reads a maximum of <cod>>len</code> bytes. Note that this method can actually
* read fewer than <code>len</code> bytes. The actual number of bytes read is
* returned. A -1 is returned to indicated that no bytes can be read
* because the end of the stream was reached. If the stream is already
* closed, a -1 will again be returned to indicate the end of the stream.
* <p>
* This method will block if no bytes are available to be read.
*
* @param buf The buffer into which bytes will be stored
* @param offset The index into the buffer at which to start writing.
* @param len The maximum number of bytes to read.
*/
public synchronized int
read(byte[] buf, int offset, int len) throws IOException
{
if (!ever_connected)
throw new IOException("Not connected");
int bytes_read = 0;
for (;;)
{
// If there are bytes, take them.
if (in != -1)
{
int desired_bytes = len - bytes_read;
// We are in a "wrap" condition.
if (out >= in)
{
desired_bytes = Math.min (desired_bytes, pipe_size - out);
System.arraycopy (buffer, out, buf, offset + bytes_read,
desired_bytes);
bytes_read += desired_bytes;
out += desired_bytes;
desired_bytes = len - bytes_read;
if (out == pipe_size)
{
out = 0;
// OUT has wrapped. Make sure that we don't falsely
// indicate that the buffer is full.
if (in == 0)
in = -1;
}
notifyAll();
}
// We are in a "no wrap". This can be triggered by
// fall-through from the above.
if (in > out)
{
desired_bytes = Math.min (desired_bytes, in - out);
System.arraycopy(buffer, out, buf, offset + bytes_read,
desired_bytes);
bytes_read += desired_bytes;
out += desired_bytes;
desired_bytes = len - bytes_read;
if (out == in)
{
// Don't falsely indicate that the buffer is full.
out = 0;
in = -1;
}
else if (out == pipe_size)
out = 0;
notifyAll();
}
}
// Return when we've read something. A short return is ok.
// Also return in the case where LEN==0.
if (bytes_read > 0 || bytes_read == len)
return(bytes_read);
// Handle the case where the end of stream was encountered.
if (closed)
{
if (in == -1)
{
// The stream is closed and empty. We've already
// returned if bytes were read. So we know EOF is the
// only answer.
return -1;
}
// I think this shouldn't happen. I don't think there is a
// way to get here when nothing has been read but there are
// bytes in the buffer. Still...
continue;
}
// Wait for a byte to be received.
try
{
wait();
}
catch(InterruptedException e) { ; }
}
}
/*************************************************************************/
/**
* This method receives a byte of input from the source PipedOutputStream. * This method receives a byte of input from the source PipedOutputStream.
* If there is no data ready to be written, or if the internal circular * If the internal circular buffer is full, this method blocks.
* buffer is full, this method blocks.
* *
* @param byte_received The byte to write to this stream * @param byte_received The byte to write to this stream
* *
* @exception IOException if error occurs * @exception IOException if error occurs
* * @specnote Weird. This method must be some sort of accident.
*/ */
protected synchronized void protected synchronized void receive(int b) throws IOException
receive(int byte_received) throws IOException {
{ read_buf[0] = (byte) (b & 0xff);
// This is really slow, but it has the benefit of not duplicating receive (read_buf, 0, 1);
// the complicated machinery in receive(byte[],int,int). }
byte[] buf = new byte[1];
buf[0] = (byte) (byte_received & 0xff); /**
receive (buf, 0, 1); * This method is used by the connected <code>PipedOutputStream</code> to
} * write bytes into the buffer.
*
/*************************************************************************/ * @param buf The array containing bytes to write to this stream
* @param offset The offset into the array to start writing from
/** * @param len The number of bytes to write.
* This method is used by the connected <code>PipedOutputStream</code> to *
* write bytes into the buffer. It uses this method instead of directly * @exception IOException If an error occurs
* writing the bytes in order to obtain ownership of the object's monitor * @specnote This code should be in PipedOutputStream.write, but we
* for the purposes of calling <code>notify</code>. * put it here in order to support that bizarre recieve(int)
* * method.
* @param buf The array containing bytes to write to this stream */
* @param offset The offset into the array to start writing from synchronized void receive(byte[] buf, int offset, int len)
* @param len The number of bytes to write. throws IOException
{
if (closed)
throw new IOException ("Pipe closed");
int bufpos = offset;
int copylen;
while (len > 0)
{
try
{
while (in == out)
{
// The pipe is full. Wake up any readers and wait for them.
notifyAll();
wait();
// The pipe could have been closed while we were waiting.
if (closed)
throw new IOException ("Pipe closed");
}
}
catch (InterruptedException ix)
{
throw new InterruptedIOException ();
}
if (in < 0) // The pipe is empty.
in = 0;
// Figure out how many bytes from buf can be copied without
// overrunning out or going past the length of the buffer.
if (in < out)
copylen = Math.min (len, out - in);
else
copylen = Math.min (len, buffer.length - in);
// Copy bytes until the pipe is filled, wrapping if neccessary.
System.arraycopy(buf, bufpos, buffer, in, copylen);
len -= copylen;
bufpos += copylen;
in += copylen;
if (in == buffer.length)
in = 0;
}
// Notify readers that new data is in the pipe.
notifyAll();
}
/**
* This method reads bytes from the stream into a caller supplied buffer.
* It starts storing bytes at position <code>offset</code> into the buffer and
* reads a maximum of <cod>>len</code> bytes. Note that this method can actually
* read fewer than <code>len</code> bytes. The actual number of bytes read is
* returned. A -1 is returned to indicated that no bytes can be read
* because the end of the stream was reached. If the stream is already
* closed, a -1 will again be returned to indicate the end of the stream.
* <p>
* This method will block if no bytes are available to be read.
*
* @param buf The buffer into which bytes will be stored
* @param offset The index into the buffer at which to start writing.
* @param len The maximum number of bytes to read.
*/
public int read() throws IOException
{
// Method operates by calling the multibyte overloaded read method
// Note that read_buf is an internal instance variable. I allocate it
// there to avoid constant reallocation overhead for applications that
// call this method in a loop at the cost of some unneeded overhead
// if this method is never called.
int r = read(read_buf, 0, 1);
if (r == -1)
return -1;
else
return read_buf[0];
}
/**
* This method reads bytes from the stream into a caller supplied buffer.
* It starts storing bytes at position <code>offset</code> into the buffer and
* reads a maximum of <cod>>len</code> bytes. Note that this method can actually
* read fewer than <code>len</code> bytes. The actual number of bytes read is
* returned. A -1 is returned to indicated that no bytes can be read
* because the end of the stream was reached - ie close() was called on the
* connected PipedOutputStream.
* <p>
* This method will block if no bytes are available to be read.
*
* @param buf The buffer into which bytes will be stored
* @param offset The index into the buffer at which to start writing.
* @param len The maximum number of bytes to read.
*
* @exception IOException If <code>close()/code> was called on this Piped
* InputStream.
*/
public synchronized int read(byte[] buf, int offset, int len)
throws IOException
{
if (source == null)
throw new IOException ("Not connected");
if (closed)
throw new IOException ("Pipe closed");
// If the buffer is empty, wait until there is something in the pipe
// to read.
try
{
while (in < 0)
{
if (source.closed)
return -1;
wait();
}
}
catch (InterruptedException ix)
{
throw new InterruptedIOException();
}
int total = 0;
int copylen;
while (true)
{
// Figure out how many bytes from the pipe can be copied without
// overrunning in or going past the length of buf.
if (out < in)
copylen = Math.min (len, in - out);
else
copylen = Math.min (len, buffer.length - out);
System.arraycopy (buffer, out, buf, offset, copylen);
offset += copylen;
len -= copylen;
out += copylen;
total += copylen;
if (out == buffer.length)
out = 0;
if (out == in)
{
// Pipe is now empty.
in = -1;
out = 0;
}
// If output buffer is filled or the pipe is empty, we're done.
if (len == 0 || in == -1)
{
// Notify any waiting outputstream that there is now space
// to write.
notifyAll();
return total;
}
}
}
/**
* This method returns the number of bytes that can be read from this stream
* before blocking could occur. This is the number of bytes that are
* currently unread in the internal circular buffer. Note that once this
* many additional bytes are read, the stream may block on a subsequent
* read, but it not guaranteed to block.
*
* @return The number of bytes that can be read before blocking might occur
*
* @exception IOException If an error occurs
*/
public synchronized int available() throws IOException
{
// The JDK 1.3 implementation does not appear to check for the closed or
// unconnected stream conditions here.
if (in < 0)
return 0;
else if (out < in)
return in - out;
else
return (buffer.length - out) + in;
}
/**
* This methods closes the stream so that no more data can be read
* from it.
* *
* @exception IOException If an error occurs * @exception IOException If an error occurs
*/ */
synchronized void public synchronized void close() throws IOException
receive(byte[] buf, int offset, int len) throws IOException {
{ closed = true;
if (len <= 0) // Wake any thread which may be in receive() waiting to write data.
return; notifyAll();
}
int total_written = 0;
outer:
while (total_written < len)
{
// If the buffer is full, then wait.
// Also, if we are at the end of the buffer and OUT is 0, wait.
if (! (in == out
|| (in == pipe_size - 1 && out == 0)))
{
// This is the "no wrap" situation
if (in > out)
{
int bytes_written = 0;
if ((pipe_size - in) > (len - total_written))
bytes_written = (len - total_written);
else if (out == 0)
bytes_written = (pipe_size - in) - 1;
else
bytes_written = (pipe_size - in);
if (bytes_written > 0)
{
System.arraycopy(buf, offset + total_written, buffer, in,
bytes_written);
total_written += bytes_written;
in += bytes_written;
if (in == pipe_size)
in = 0;
notifyAll();
}
}
// This is the "wrap" situtation
if ((out > in) && (total_written != len))
{
int bytes_written = 0;
// Do special processing if we are at the beginning
if (in == -1)
{
in = 0;
bytes_written = Math.min (len - total_written, pipe_size);
}
else
{
bytes_written = Math.min (len - total_written,
out - in);
}
System.arraycopy(buf, offset + total_written, buffer, in,
bytes_written);
total_written += bytes_written;
in += bytes_written;
if (in == pipe_size)
in = 0;
notifyAll();
}
}
// Wait for some reads to occur before we write anything.
else
{
try
{
wait();
}
catch (InterruptedException e) { ; }
}
}
} }
} // class PipedInputStream
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/PipedReader.java
/* PipedReader.java -- Input stream that reads from an output stream /* PipedReader.java -- Read portion of piped character streams.
Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc. Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -24,479 +24,312 @@ resulting executable to be covered by the GNU General Public License. ...@@ -24,479 +24,312 @@ resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */ 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 PipedInputStream.
// If you fix a bug in here, chances are you should make a similar change to
// the PipedInputStream code.
/** /**
* This class is an input stream that reads its chars from an output stream * An input stream that reads characters from a piped writer to which it is
* to which it is connected. * connected.
* <p> * <p>
* Data is read and written to an internal buffer. It is highly recommended * Data is read and written to an internal buffer. It is highly recommended
* that the <code>PipedReader</code> and connected <code>PipedWriter</code> * that the <code>PipedReader</code> and connected <code>PipedWriter</code>
* be part of different threads. If they are not, there is a possibility * be part of different threads. If they are not, there is a possibility
* that the read and write operations could deadlock their thread. * that the read and write operations could deadlock their thread.
* *
* @version 0.0 * @specnote The JDK implementation appears to have some undocumented
* functionality where it keeps track of what thread is writing
* to pipe and throws an IOException if that thread susequently
* dies. This behaviour seems dubious and unreliable - we don't
* implement it.
* *
* @author Aaron M. Renn (arenn@urbanophile.com) * @author Aaron M. Renn (arenn@urbanophile.com)
*/ */
public class PipedReader extends Reader public class PipedReader extends Reader
{ {
/** PipedWriter to which this is connected. Null only if this
/*************************************************************************/ * Reader hasn't been connected yet. */
PipedWriter source;
/*
* Class Variables /** Set to true if close() has been called on this Reader. */
*/ boolean closed;
/** /**
* The size of the internal buffer used for input/output. Note that this * The size of the internal buffer used for input/output.
* can be overriden by setting the system property */
* <code>gnu.java.io.PipedReader.pipe_size</code> to the desired size shown static final int PIPE_SIZE = 2048;
* in chars. This is not a standard part of the class library. Note that
* since this variable is <code>final</code>, it cannot be changed to refect /**
* the size specified in the property. * This is the internal circular buffer used for storing chars written
* <p> * to the pipe and from which chars are read by this stream
* The value for this variable is 2048. */
*/ char[] buffer = new char[PIPE_SIZE];
private static final int PIPE_SIZE = 2048;
/**
/** * The index into buffer where the next char from the connected
* This is the real pipe size. It defaults to PIPE_SIZE, unless overridden * <code>PipedWriter</code> will be written. If this variable is
* by use of the system property <code>gnu.java.io.PipedReader.pipe_size</code>. * equal to <code>out</code>, then the buffer is full. If set to < 0,
*/ * the buffer is empty.
private static int pipe_size; */
int in = -1;
static
{ /**
pipe_size = Integer.getInteger("gnu.java.io.PipedReader.pipe_size", * This index into the buffer where chars will be read from.
PIPE_SIZE).intValue(); */
} int out = 0;
/*************************************************************************/ /** Buffer used to implement single-argument read/receive */
char[] read_buf = new char[1];
/*
* Instance Variables /**
*/ * Creates a new <code>PipedReader</code> that is not connected to a
* <code>PipedWriter</code>. It must be connected before chars can
/** * be read from this stream.
* This is the internal circular buffer used for storing chars written */
* to the pipe and from which chars are read by this stream public PipedReader()
*/ {
private char[] buffer = new char[pipe_size]; }
/** /**
* The index into buffer where the chars written char the connected * This constructor creates a new <code>PipedReader</code> and connects
* <code>PipedWriter</code> will be written. If this variables is less * it to the passed in <code>PipedWriter</code>. The stream is then
* than 0, then the buffer is empty. If this variable is equal to * ready for reading.
* <code>out</code>, then the buffer is full *
*/ * @param source The <code>PipedWriter</code> to connect this stream to
private int in = -1; *
* @exception IOException If <code>source</code> is already connected.
/** */
* This index into the buffer where chars will be read from. public PipedReader(PipedWriter source) throws IOException
*/ {
private int out = 0; connect(source);
}
/**
* This variable is <code>true</code> if this object has ever been connected /**
* to a <code>PipedWriter</code>, and <code>false</code> otherwise. It is used * This method connects this stream to the passed in <code>PipedWriter</code>.
* to detect an attempt to connect an already connected stream or to * This stream is then ready for reading. If this stream is already
* otherwise use the stream before it is connected. * connected or has been previously closed, then an exception is thrown
*/ *
private boolean ever_connected = false; * @param src The <code>PipedWriter</code> to connect this stream to
*
/** * @exception IOException If this PipedReader or <code>source</code>
* This variable is set to <code>true</code> if the <code>close()</code> method is * has been connected already.
* called. This value is checked prevents a caller from re-opening the */
* stream. public void connect(PipedWriter source) throws IOException
*/ {
private boolean closed = false; // The JDK (1.3) does not appear to check for a previously closed
// connection here.
/**
* This variable is the PipedWriter to which this stream is connected. if (this.source != null || source.sink != null)
*/ throw new IOException ("Already connected");
PipedWriter src;
source.sink = this;
/*************************************************************************/ this.source = source;
}
/*
* Constructors /**
*/ * This method is used by the connected <code>PipedWriter</code> to
* write chars into the buffer.
/** *
* This constructor creates a new <code>PipedReader</code> that is not * @param buf The array containing chars to write to this stream
* connected to a <code>PipedWriter</code>. It must be connected before * @param offset The offset into the array to start writing from
* chars can be read from this stream. * @param len The number of chars to write.
*/ *
public * @exception IOException If an error occurs
PipedReader() * @specnote This code should be in PipedWriter.write, but we
{ * put it here in order to support that bizarre recieve(int)
return; * method.
} */
synchronized void receive(char[] buf, int offset, int len)
/*************************************************************************/ throws IOException
{
/** if (closed)
* This constructor creates a new <code>PipedReader</code> and connects throw new IOException ("Pipe closed");
* it to the passed in <code>PipedWriter</code>. The stream is then read
* for reading. int bufpos = offset;
* int copylen;
* @param src The <code>PipedWriter</code> to connect this stream to
* while (len > 0)
* @exception IOException If an error occurs {
*/ try
public {
PipedReader(PipedWriter src) throws IOException while (in == out)
{ {
connect(src); // The pipe is full. Wake up any readers and wait for them.
} notifyAll();
wait();
/*************************************************************************/ // The pipe could have been closed while we were waiting.
if (closed)
/* throw new IOException ("Pipe closed");
* Instance Variables }
*/ }
catch (InterruptedException ix)
/** {
* This method connects this stream to the passed in <code>PipedWriter</code>. throw new InterruptedIOException ();
* This stream is then ready for reading. If this stream is already }
* connected or has been previously closed, then an exception is thrown
* if (in < 0) // The pipe is empty.
* @param src The <code>PipedWriter</code> to connect this stream to in = 0;
*
* @exception IOException If an error occurs // Figure out how many chars from buf can be copied without
*/ // overrunning out or going past the length of the buffer.
public void if (in < out)
connect(PipedWriter src) throws IOException copylen = Math.min (len, out - in);
{ else
if (src == this.src) copylen = Math.min (len, buffer.length - in);
return;
// Copy chars until the pipe is filled, wrapping if neccessary.
if (ever_connected) System.arraycopy(buf, bufpos, buffer, in, copylen);
throw new IOException("Already connected"); len -= copylen;
bufpos += copylen;
if (closed) in += copylen;
throw new IOException("Stream is closed and cannot be reopened"); if (in == buffer.length)
in = 0;
synchronized (lock) }
{ // Notify readers that new data is in the pipe.
src.connect(this); notifyAll();
}
ever_connected = true;
} // synchronized /**
} * This method reads chars from the stream into a caller supplied buffer.
* It starts storing chars at position <code>offset</code> into the buffer and
/*************************************************************************/ * reads a maximum of <cod>>len</code> chars. Note that this method can actually
* read fewer than <code>len</code> chars. The actual number of chars read is
/** * returned. A -1 is returned to indicated that no chars can be read
* because the end of the stream was reached. If the stream is already
* closed, a -1 will again be returned to indicate the end of the stream.
* <p>
* This method will block if no chars are available to be read.
*
* @param buf The buffer into which chars will be stored
* @param offset The index into the buffer at which to start writing.
* @param len The maximum number of chars to read.
*/
public int read() throws IOException
{
// Method operates by calling the multichar overloaded read method
// Note that read_buf is an internal instance variable. I allocate it
// there to avoid constant reallocation overhead for applications that
// call this method in a loop at the cost of some unneeded overhead
// if this method is never called.
int r = read(read_buf, 0, 1);
if (r == -1)
return -1;
else
return read_buf[0];
}
/**
* This method reads characters from the stream into a caller supplied buffer.
* It starts storing chars at position <code>offset</code> into the buffer and
* reads a maximum of <cod>>len</code> chars. Note that this method can actually
* read fewer than <code>len</code> chars. The actual number of chars read is
* returned. A -1 is returned to indicated that no chars can be read
* because the end of the stream was reached - ie close() was called on the
* connected PipedWriter.
* <p>
* This method will block if no chars are available to be read.
*
* @param buf The buffer into which chars will be stored
* @param offset The index into the buffer at which to start writing.
* @param len The maximum number of chars to read.
*
* @exception IOException If <code>close()/code> was called on this Piped
* Reader.
*/
public synchronized int read(char[] buf, int offset, int len)
throws IOException
{
if (source == null)
throw new IOException ("Not connected");
if (closed)
throw new IOException ("Pipe closed");
// If the buffer is empty, wait until there is something in the pipe
// to read.
try
{
while (in < 0)
{
if (source.closed)
return -1;
wait();
}
}
catch (InterruptedException ix)
{
throw new InterruptedIOException();
}
int total = 0;
int copylen;
while (true)
{
// Figure out how many chars from the pipe can be copied without
// overrunning in or going past the length of buf.
if (out < in)
copylen = Math.min (len, in - out);
else
copylen = Math.min (len, buffer.length - out);
System.arraycopy (buffer, out, buf, offset, copylen);
offset += copylen;
len -= copylen;
out += copylen;
total += copylen;
if (out == buffer.length)
out = 0;
if (out == in)
{
// Pipe is now empty.
in = -1;
out = 0;
}
// If output buffer is filled or the pipe is empty, we're done.
if (len == 0 || in == -1)
{
// Notify any waiting Writer that there is now space
// to write.
notifyAll();
return total;
}
}
}
public synchronized boolean ready() throws IOException
{
// The JDK 1.3 implementation does not appear to check for the closed or
// unconnected stream conditions here.
if (in < 0)
return false;
int count;
if (out < in)
count = in - out;
else
count = (buffer.length - out) - in;
return (count > 0);
}
/**
* This methods closes the stream so that no more data can be read * This methods closes the stream so that no more data can be read
* from it. * from it.
* *
* @exception IOException If an error occurs * @exception IOException If an error occurs
*/ */
public void public synchronized void close() throws IOException
close() throws IOException {
{ closed = true;
synchronized (lock) // Wake any thread which may be in receive() waiting to write data.
{ notifyAll();
closed = true; }
notifyAll();
} // synchronized
}
/*************************************************************************/
/**
* This method determines whether or not this stream is ready to be read.
* If this metho returns <code>false</code> an attempt to read may (but is
* not guaranteed to) block.
*
* @return <code>true</code> if this stream is ready to be read, <code>false</code> otherwise
*
* @exception IOException If an error occurs
*/
public boolean
ready() throws IOException
{
if (in == -1)
return(false);
if (out == (in - 1))
return(false);
if ((out == pipe_size) && (in == 0))
return(false);
return(true);
}
/*************************************************************************/
/**
* This method reads a single char from the pipe and returns it as an
* <code>int</code>.
* <p>
* This method will block if no chars are available to be read.
*
* @return An char read from the pipe, or -1 if the end of stream is
* reached.
*
* @exception IOException If an error occurs.
*/
public int
read() throws IOException
{
char[] buf = new char[1];
return(read(buf, 0, buf.length));
}
/*************************************************************************/
/**
* This method reads chars from the stream into a caller supplied buffer.
* It starts storing chars at position <code>offset</code> into the buffer and
* reads a maximum of <cod>>len</code> chars. Note that this method can actually
* read fewer than <code>len</code> chars. The actual number of chars read is
* returned. A -1 is returned to indicated that no chars can be read
* because the end of the stream was reached. If the stream is already
* closed, a -1 will again be returned to indicate the end of the stream.
* <p>
* This method will block if no chars are available to be read.
*
* @param buf The buffer into which chars will be stored
* @param offset The index into the buffer at which to start writing.
* @param len The maximum number of chars to read.
*/
public int
read(char[] buf, int offset, int len) throws IOException
{
if (!ever_connected)
throw new IOException("Not connected");
synchronized (lock)
{
int chars_read = 0;
for (;;)
{
// If there are chars, take them
if (in != -1)
{
int desired_chars = len - chars_read;
// We are in a "wrap" condition
if (out > in)
{
if (desired_chars > (pipe_size - out))
{
if (in == 0)
desired_chars = (pipe_size - out) - 1;
else
desired_chars = pipe_size - out;
System.arraycopy(buffer, out, buf, offset + chars_read,
desired_chars);
chars_read += desired_chars;
out += desired_chars;
desired_chars = len - chars_read;
if (out == pipe_size)
out = 0;
notifyAll();
}
else
{
if ((out + desired_chars) == in)
--desired_chars;
if (((out + desired_chars) == pipe_size) && (in == 0))
desired_chars = (pipe_size - out) - 1;
System.arraycopy(buffer, out, buf, offset + chars_read,
desired_chars);
chars_read += desired_chars;
out += desired_chars;
desired_chars = len - chars_read;
if (out == pipe_size)
out = 0;
notifyAll();
}
}
// We are in a "no wrap" or condition (can also be fall through
// from above
if (in > out)
{
if (desired_chars >= ((in - out) - 1))
desired_chars = (in - out) - 1;
System.arraycopy(buffer, out, buf, offset + chars_read,
desired_chars);
chars_read += desired_chars;
out += desired_chars;
desired_chars = len - chars_read;
if (out == pipe_size)
out = 0;
notifyAll();
}
}
// If we are done, return
if (chars_read == len)
return(chars_read);
// Return a short count if necessary
if (chars_read > 0 && chars_read < len)
return(chars_read);
// Handle the case where the end of stream was encountered.
if (closed)
{
// We never let in == out so there might be one last char
// available that we have not copied yet.
if (in != -1)
{
buf[offset + chars_read] = buffer[out];
in = -1;
++out;
++chars_read;
}
if (chars_read != 0)
return(chars_read);
else
return(-1);
}
// Wait for a char to be read
try
{
wait();
}
catch(InterruptedException e) { ; }
}
} // synchronized
}
/*************************************************************************/
/**
* This method is used by the connected <code>PipedWriter</code> to
* write chars into the buffer. It uses this method instead of directly
* writing the chars in order to obtain ownership of the object's monitor
* for the purposes of calling <code>notify</code>.
*
* @param buf The array containing chars to write to this stream
* @param offset The offset into the array to start writing from
* @param len The number of chars to write.
*
* @exception IOException If an error occurs
*/
void
write(char[] buf, int offset, int len) throws IOException
{
if (len <= 0)
return;
synchronized (lock)
{
int total_written = 0;
while (total_written < len)
{
// If we are not at the end of the buffer with out = 0
if (!((in == (buffer.length - 1)) && (out == 0)))
{
// This is the "no wrap" situation
if ((in - 1) >= out)
{
int chars_written = 0;
if ((buffer.length - in) > (len - total_written))
chars_written = (len - total_written);
else if (out == 0)
chars_written = (buffer.length - in) - 1;
else
chars_written = (buffer.length - in);
if (chars_written > 0)
System.arraycopy(buf, offset + total_written, buffer, in,
chars_written);
total_written += chars_written;
in += chars_written;
if (in == buffer.length)
in = 0;
notifyAll();
}
// This is the "wrap" situtation
if ((out > in) && (total_written != len))
{
int chars_written = 0;
// Do special processing if we are at the beginning
if (in == -1)
{
in = 0;
if (buffer.length > len)
chars_written = len;
else
chars_written = buffer.length - 1;
}
else if (((out - in) - 1) < (len - total_written))
{
chars_written = (out - in) - 1;
}
else
{
chars_written = len - total_written;
}
// If the buffer is full, wait for it to empty out
if ((out - 1) == in)
{
try
{
wait();
}
catch (InterruptedException e)
{
continue;
}
}
System.arraycopy(buf, offset + total_written, buffer, in,
chars_written);
total_written += chars_written;
in += chars_written;
if (in == buffer.length)
in = 0;
notifyAll();
}
}
// Wait for some reads to occur before we write anything.
else
{
try
{
wait();
}
catch (InterruptedException e) { ; }
}
}
} // synchronized
} }
} // class PipedReader
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