PipedReader to
* which it is connected.
*
* It is highly recommended that a PipedWriter and its
* connected PipedReader be in different threads. If
* they are in the same thread, read and write operations could deadlock
* the thread.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
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;
/** Buffer used to implement single-argument write */
char[] read_buf = new char[1];
/**
* Create an unconnected PipedWriter. It must be connected
* to a PipedReader using the connect
* method prior to writing any data or an exception will be thrown.
*/
public PipedWriter()
{
}
/**
* Create a new PipedWriter instance
* to write to the specified PipedReader. This stream
* is then ready for writing.
*
* @param sink The PipedReader to connect this stream to.
*
* @exception IOException If sink has already been connected
* to a different PipedWriter.
*/
public PipedWriter(PipedReader sink) throws IOException
{
sink.connect(this);
}
/**
* Connects this object to the specified PipedReader
* object. This stream will then be ready for writing.
*
* @param sink The PipedReader to connect this stream to
*
* @exception IOException If the stream has not been connected or has
* been closed.
*/
public void connect(PipedReader sink) throws IOException
{
if (this.sink != null || sink.source != null)
throw new IOException ("Already connected");
sink.connect(this);
}
/**
* Write a single char of date to the stream. Note that this method will
* block if the PipedReader to which this object is
* connected has a full buffer.
*
* @param b The char of data to be written, passed as an int.
*
* @exception IOException If the stream has not been connected or has
* been closed.
*/
public void write(int b) throws IOException
{
read_buf[0] = (char) (b & 0xffff);
sink.receive (read_buf, 0, 1);
}
/**
* This method writes len chars of data from the char array
* buf starting at index offset in the array
* to the stream. Note that this method will block if the
* PipedReader 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 the stream.
* @param offset The index into the array to start writing chars from.
* @param len The number of chars to write.
*
* @exception IOException If the stream has not been connected or has
* been closed.
*/
public void write(char[] b, int off, int len) throws IOException
{
if (sink == null)
throw new IOException ("Not connected");
if (closed)
throw new IOException ("Pipe closed");
sink.receive (b, off, len);
}
/**
* This method does nothing.
*
* @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() throws IOException
{
if (closed)
throw new IOException ("Pipe closed");
}
/**
* 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
{
// A close call on an unconnected PipedWriter has no effect.
if (sink != null)
{
closed = true;
// Notify any waiting readers that the stream is now closed.
synchronized (sink)
{
sink.notifyAll();
}
}
}
}