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.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class PipedOutputStream extends OutputStream
{
/** Target PipedInputStream to which this is connected. Null only if this
* OutputStream hasn't been connected yet. */
PipedInputStream sink;
/** Set to true if close() has been called on this OutputStream. */
boolean closed;
/**
* Create an unconnected PipedOutputStream. It must be connected
* to a PipedInputStream using the connect
* method prior to writing any data or an exception will be thrown.
*/
public PipedOutputStream()
{
}
/**
* Create a new PipedOutputStream instance
* to write to the specified PipedInputStream. This stream
* is then ready for writing.
*
* @param sink The PipedInputStream to connect this stream to.
*
* @exception IOException If sink has already been connected
* to a different PipedOutputStream.
*/
public PipedOutputStream(PipedInputStream sink) throws IOException
{
sink.connect(this);
}
/**
* Connects this object to the specified PipedInputStream
* object. This stream will then be ready for writing.
*
* @param sink The PipedInputStream to connect this stream to
*
* @exception IOException If the stream has not been connected or has
* been closed.
*/
public void connect(PipedInputStream sink) throws IOException
{
if (this.sink != null || sink.source != null)
throw new IOException ("Already connected");
sink.connect(this);
}
/**
* Write 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 the stream has not been connected or has
* been closed.
*/
public void write(int b) throws IOException
{
if (sink == null)
throw new IOException ("Not connected");
if (closed)
throw new IOException ("Pipe closed");
sink.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 buffer The array containing bytes to write to the stream.
* @param offset The index into the array to start writing bytes from.
* @param len The number of bytes to write.
*
* @exception IOException If the stream has not been connected or has
* been closed.
*/
public void write(byte[] buffer, int offset, int len) throws IOException
{
if (sink == null)
throw new IOException ("Not connected");
if (closed)
throw new IOException ("Pipe closed");
sink.receive(buffer, offset, 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
{
}
/**
* 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 PipedOutputStream has no effect.
if (sink != null)
{
closed = true;
// Notify any waiting readers that the stream is now closed.
synchronized (sink)
{
sink.notifyAll();
}
}
}
}