PipedOutputStream object by one
* thread and data is read from the connected PipedInputStream by some other thread. Attempting to use both
* objects from a single thread is not recommended as it may deadlock the thread. The pipe is said to be
* broken if a thread that was reading data bytes from the connected piped input stream is no longer alive.
*
* @author James Gosling
* @see java.io.PipedInputStream
* @since JDK1.0
*/
public class PipedOutputStream extends OutputStream {
/*
* REMIND: identification of the read and write sides needs to be more sophisticated. Either using thread groups
* (but what about pipes within a thread?) or using finalization (but it may be a long time until the next GC).
*/
@Nullable
private PipedInputStream sink;
/**
* Creates a piped output stream connected to the specified piped input stream. Data bytes written to this stream
* will then be available as input from snk.
*
* @param snk
* The piped input stream to connect to.
* @exception IOException
* if an I/O error occurs.
*/
public PipedOutputStream(PipedInputStream snk) throws IOException {
connect(snk);
}
/**
* Creates a piped output stream that is not yet connected to a piped input stream. It must be connected to a piped
* input stream, either by the receiver or the sender, before being used.
*
* @see java.io.PipedInputStream#connect(java.io.PipedOutputStream)
* @see java.io.PipedOutputStream#connect(java.io.PipedInputStream)
*/
public PipedOutputStream() {
}
/**
* Connects this piped output stream to a receiver. If this object is already connected to some other piped input
* stream, an IOException is thrown.
*
* If snk is an unconnected piped input stream and src is an unconnected piped output
* stream, they may be connected by either the call:
* *or the call:* src.connect(snk) ** *
* *The two calls have the same effect. * * @param snk * the piped input stream to connect to. * @exception IOException * if an I/O error occurs. */ public synchronized void connect(PipedInputStream snk) throws IOException { if (snk.connected || this.sink != null) { // throws NullPointerException in case snk is null, which it shouldn't // be throw new IOException("Already connected"); } this.sink = snk; snk.in = -1; snk.out = 0; snk.connected = true; } /** * Writes the specified* snk.connect(src) ** *
byte to the piped output stream.
*
* Implements the write method of OutputStream.
*
* @param b
* the byte to be written.
* @exception IOException
* if the pipe is broken, {@link #connect(java.io.PipedInputStream)
* unconnected}, closed, or if an I/O error occurs.
*/
@Override
public void write(int b) throws IOException {
PipedInputStream sink = this.sink;
if (sink == null) {
throw new IOException("Pipe not connected");
} else {
sink.receive(b);
}
}
/**
* Writes len bytes from the specified byte array starting at offset off to this piped
* output stream. This method blocks until all the bytes are written to the output stream.
*
* @param b
* the data.
* @param off
* the start offset in the data.
* @param len
* the number of bytes to write.
* @exception IOException
* if the pipe is broken, {@link #connect(java.io.PipedInputStream)
* unconnected}, closed, or if an I/O error occurs.
*/
@Override
public void write(byte b[], int off, int len) throws IOException {
PipedInputStream sink = this.sink;
if (sink == null) {
throw new IOException("Pipe not connected");
} else {
int length = b.length; // throws NullPointerException in case b is null
if ((off < 0) || (off > length) || (len < 0) || ((off + len) > length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return;
}
}
sink.receive(b, off, len);
}
/**
* Flushes this output stream and forces any buffered output bytes to be written out. This will notify any readers
* that bytes are waiting in the pipe.
*
* @exception IOException
* if an I/O error occurs.
*/
@Override
public synchronized void flush() throws IOException {
PipedInputStream sink = this.sink;
if (sink != null) {
synchronized (sink) {
sink.notifyAll();
}
}
}
/**
* Closes this piped output stream and releases any system resources associated with this stream. This stream may no
* longer be used for writing bytes.
*
* @exception IOException
* if an I/O error occurs.
*/
@Override
public void close() throws IOException {
PipedInputStream sink = this.sink;
if (sink != null) {
sink.receivedLast();
}
}
}