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.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class PipedWriter extends Writer
{
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the PipedReader to which this object
* is connected.
*/
private PipedReader 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 close method has ever
* been called for this stream.
*/
private boolean closed;
/*************************************************************************/
/**
* This method initializes a new PipedWriter instance.
* This constructor creates an unconnected object. It must be connected
* to a PipedReader object using the connect
* method prior to writing any data or an exception will be thrown.
*/
public
PipedWriter()
{
; // Do Nothing
}
/*************************************************************************/
/**
* This method initializes a new PipedWriter instance
* to write to the specified PipedReader. This stream
* is then ready for writing.
*
* @param snk The PipedReader to connect this stream to.
*
* @exception IOException If an error occurs
*/
public
PipedWriter(PipedReader snk) throws IOException
{
connect(snk);
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method connects this object to the specified
* PipedReader 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 PipedReader to connect this stream to
*
* @exception IOException If an error occurs
*/
public void
connect(PipedReader snk) throws IOException
{
if (snk == this.snk)
return;
if (ever_connected)
throw new IOException("Already connected");
if (closed)
throw new IOException("Stream is closed and cannot be reopened");
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 char to write, passed as an int.
*
* @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 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 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