snk.
*
* @param snk
* The piped reader to connect to.
* @exception IOException
* if an I/O error occurs.
*/
public PipedWriter(PipedReader snk) throws IOException {
connect(snk);
}
/**
* Creates a piped writer that is not yet connected to a piped reader. It must be connected to a piped reader,
* either by the receiver or the sender, before being used.
*
* @see java.io.PipedReader#connect(java.io.PipedWriter)
* @see java.io.PipedWriter#connect(java.io.PipedReader)
*/
public PipedWriter() {
}
/**
* Connects this piped writer to a receiver. If this object is already connected to some other piped reader, an
* IOException is thrown.
*
* If snk is an unconnected piped reader and src is an unconnected piped writer, 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 reader to connect to. * @exception IOException * if an I/O error occurs. */ public synchronized void connect(PipedReader 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"); } else if (snk.closedByReader || this.closed) { throw new IOException("Pipe closed"); } this.sink = snk; snk.in = -1; snk.out = 0; snk.connected = true; } /** * Writes the specified* snk.connect(src) ** *
char to the piped output stream. If a thread was reading data characters from
* the connected piped input stream, but the thread is no longer alive, then an IOException is thrown.
*
* Implements the write method of Writer.
*
* @param c
* the char to be written.
* @exception IOException
* if the pipe is broken,
* {@link #connect(java.io.PipedReader) unconnected}, closed or an I/O error occurs.
*/
@Override
public void write(int c) throws IOException {
PipedReader sink = this.sink;
if (sink == null) {
throw new IOException("Pipe not connected");
}
sink.receive(c);
}
/**
* Writes len characters from the specified character array starting at offset off to this
* piped output stream. This method blocks until all the characters are written to the output stream. If a thread
* was reading data characters from the connected piped input stream, but the thread is no longer alive, then an
* IOException is thrown.
*
* @param cbuf
* the data.
* @param off
* the start offset in the data.
* @param len
* the number of characters to write.
* @exception IOException
* if the pipe is broken,
* {@link #connect(java.io.PipedReader) unconnected}, closed or an I/O error occurs.
*/
@Override
public void write(char cbuf[], int off, int len) throws IOException {
PipedReader sink = this.sink;
if (sink == null) {
throw new IOException("Pipe not connected");
} else if ((off | len | (off + len) | (cbuf.length - (off + len))) < 0) {
throw new IndexOutOfBoundsException();
}
sink.receive(cbuf, off, len);
}
/**
* Flushes this output stream and forces any buffered output characters to be written out. This will notify any
* readers that characters are waiting in the pipe.
*
* @exception IOException
* if the pipe is closed, or an I/O error occurs.
*/
@Override
public synchronized void flush() throws IOException {
PipedReader sink = this.sink;
if (sink != null) {
if (sink.closedByReader || this.closed) {
throw new IOException("Pipe closed");
}
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 characters.
*
* @exception IOException
* if an I/O error occurs.
*/
@Override
public void close() throws IOException {
PipedReader sink = this.sink;
this.closed = true;
if (sink != null) {
sink.receivedLast();
}
}
}