PipedInputStream to
* which it is connected.
*
* It is highly recommended that a PipedOutputStream and its
* connected PipedInputStream 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 PipedOutputStream extends OutputStream
{
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the PipedInputStream 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 close method has ever
* been called for this stream.
*/
private boolean closed;
/*************************************************************************/
/**
* This method initializes a new PipedOutputStream instance.
* This constructor creates an unconnected object. It must be connected
* to a PipedInputStream object using the connect
* method prior to writing any data or an exception will be thrown.
*/
public
PipedOutputStream()
{
; // Do Nothing
}
/*************************************************************************/
/**
* This method initializes a new PipedOutputStream instance
* to write to the specified PipedInputStream. This stream
* is then ready for writing.
*
* @param snk The PipedInputStream to connect this stream to.
*
* @exception IOException If an error occurs
*/
public
PipedOutputStream(PipedInputStream snk) throws IOException
{
connect(snk);
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method connects this object to the specified
* PipedInputStream 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 PipedInputStream to connect this stream to
*
* @exception IOException If an error occurs
*/
public synchronized void
connect(PipedInputStream 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");
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 PipedInputStream to which
* this object is connected has a full buffer.
*
* @param b The byte of data to be written, passed as an int.
*
* @exception IOException If an error occurs
*/
public synchronized void
write(int b) throws IOException
{
snk.receive (b);
}
/*************************************************************************/
/**
* This method writes len bytes of data from the byte array
* buf starting at index offset in the array
* to the stream. Note that this method will block if the
* PipedInputStream 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