in<0 implies the buffer is empty, in==out implies
* the buffer is full
*/
int in = -1;
/**
* The index of the position in the circular buffer at which the next character of data will be read by this piped
* reader.
*/
int out = 0;
/**
* Creates a PipedReader so that it is connected to the piped writer src. Data written to
* src will then be available as input from this stream.
*
* @param src
* the stream to connect to.
* @exception IOException
* if an I/O error occurs.
*/
public PipedReader(PipedWriter src) throws IOException {
this(src, DEFAULT_PIPE_SIZE);
}
/**
* Creates a PipedReader so that it is connected to the piped writer src and uses the
* specified pipe size for the pipe's buffer. Data written to src will then be available as input from
* this stream.
*
* @param src
* the stream to connect to.
* @param pipeSize
* the size of the pipe's buffer.
* @exception IOException
* if an I/O error occurs.
* @exception IllegalArgumentException
* if {@code pipeSize <= 0}.
* @since 1.6
*/
public PipedReader(PipedWriter src, int pipeSize) throws IOException {
// inlined from initPipe(pipeSize)
if (pipeSize <= 0) {
throw new IllegalArgumentException("Pipe size <= 0");
}
this.buffer = new char[pipeSize];
connect(src);
}
/**
* Creates a PipedReader so that it is not yet {@linkplain #connect(java.io.PipedWriter) connected}. It
* must be {@linkplain java.io.PipedWriter#connect( java.io.PipedReader) connected} to a PipedWriter
* before being used.
*/
public PipedReader() {
// inlined from initPipe(pipeSize)
this.buffer = new char[DEFAULT_PIPE_SIZE];
}
/**
* Creates a PipedReader so that it is not yet {@link #connect(java.io.PipedWriter) connected} and uses
* the specified pipe size for the pipe's buffer. It must be
* {@linkplain java.io.PipedWriter#connect( java.io.PipedReader) connected} to a PipedWriter before
* being used.
*
* @param pipeSize
* the size of the pipe's buffer.
* @exception IllegalArgumentException
* if {@code pipeSize <= 0}.
* @since 1.6
*/
public PipedReader(int pipeSize) {
// inlined from initPipe(pipeSize)
if (pipeSize <= 0) {
throw new IllegalArgumentException("Pipe size <= 0");
}
this.buffer = new char[pipeSize];
}
/**
* Causes this piped reader to be connected to the piped writer src. If this object is already
* connected to some other piped writer, an IOException is thrown.
*
* If src is an unconnected piped writer and snk is an unconnected piped reader, they may
* be connected by either the call:
*
*
* snk.connect(src)
*
* * or the call: * *
* src.connect(snk)
*
*
* The two calls have the same effect.
*
* @param src
* The piped writer to connect to.
* @exception IOException
* if an I/O error occurs.
*/
public void connect(PipedWriter src) throws IOException {
src.connect(this);
}
/**
* Receives a char of data. This method will block if no input is available.
*/
synchronized void receive(int c) throws IOException {
if (!this.connected) {
throw new IOException("Pipe not connected");
} else if (this.closedByWriter || this.closedByReader) {
throw new IOException("Pipe closed");
} else {
Thread readSide = this.readSide;
if (readSide != null && !readSide.isAlive()) {
throw new IOException("Read end dead");
}
}
this.writeSide = Thread.currentThread();
while (this.in == this.out) {
Thread readSide = this.readSide;
if ((readSide != null) && !readSide.isAlive()) {
throw new IOException("Pipe broken");
}
/* full: kick any waiting readers */
notifyAll();
try {
wait(1000);
} catch (InterruptedException ex) {
throw new java.io.InterruptedIOException();
}
}
if (this.in < 0) {
this.in = 0;
this.out = 0;
}
this.buffer[this.in++] = (char) c;
if (this.in >= this.buffer.length) {
this.in = 0;
}
}
/**
* Receives data into an array of characters. This method will block until some input is available.
*/
synchronized void receive(char c[], int off, int len) throws IOException {
while (--len >= 0) {
receive(c[off++]);
}
}
/**
* Notifies all waiting threads that the last character of data has been received.
*/
synchronized void receivedLast() {
this.closedByWriter = true;
notifyAll();
}
/**
* Reads the next character of data from this piped stream. If no character is available because the end of the
* stream has been reached, the value -1 is returned. This method blocks until input data is available,
* the end of the stream is detected, or an exception is thrown.
*
* @return the next character of data, or -1 if the end of the stream is reached.
* @exception IOException
* if the pipe is broken,
* {@link #connect(java.io.PipedWriter) unconnected}, closed, or an I/O error occurs.
*/
@Override
public synchronized int read() throws IOException {
if (!this.connected) {
throw new IOException("Pipe not connected");
} else if (this.closedByReader) {
throw new IOException("Pipe closed");
} else {
Thread writeSide = this.writeSide;
if (writeSide != null && !writeSide.isAlive() && !this.closedByWriter && (this.in < 0)) {
throw new IOException("Write end dead");
}
}
this.readSide = Thread.currentThread();
int trials = 2;
while (this.in < 0) {
if (this.closedByWriter) {
/* closed by writer, return EOF */
return -1;
}
Thread writeSide = this.writeSide;
if ((writeSide != null) && (!writeSide.isAlive()) && (--trials < 0)) {
throw new IOException("Pipe broken");
}
/* might be a writer waiting */
notifyAll();
try {
wait(1000);
} catch (InterruptedException ex) {
throw new java.io.InterruptedIOException();
}
}
int ret = this.buffer[this.out++];
if (this.out >= this.buffer.length) {
this.out = 0;
}
if (this.in == this.out) {
/* now empty */
this.in = -1;
}
return ret;
}
/**
* Reads up to len characters of data from this piped stream into an array of characters. Less than
* len characters will be read if the end of the data stream is reached or if len exceeds
* the pipe's buffer size. This method blocks until at least one character of input is available.
*
* @param cbuf
* the buffer into which the data is read.
* @param off
* the start offset of the data.
* @param len
* the maximum number of characters read.
* @return the total number of characters read into the buffer, or -1 if there is no more data because
* the end of the stream has been reached.
* @exception IOException
* if the pipe is broken,
* {@link #connect(java.io.PipedWriter) unconnected}, closed, or an I/O error occurs.
*/
@Override
public synchronized int read(char cbuf[], int off, int len) throws IOException {
if (!this.connected) {
throw new IOException("Pipe not connected");
} else if (this.closedByReader) {
throw new IOException("Pipe closed");
} else {
Thread writeSide = this.writeSide;
if (writeSide != null && !writeSide.isAlive() && !this.closedByWriter && (this.in < 0)) {
throw new IOException("Write end dead");
}
}
if ((off < 0) || (off > cbuf.length) || (len < 0) || ((off + len) > cbuf.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
/* possibly wait on the first character */
int c = read();
if (c < 0) {
return -1;
}
cbuf[off] = (char) c;
int rlen = 1;
while ((this.in >= 0) && (--len > 0)) {
cbuf[off + rlen] = this.buffer[this.out++];
rlen++;
if (this.out >= this.buffer.length) {
this.out = 0;
}
if (this.in == this.out) {
/* now empty */
this.in = -1;
}
}
return rlen;
}
/**
* Tell whether this stream is ready to be read. A piped character stream is ready if the circular buffer is not
* empty.
*
* @exception IOException
* if the pipe is broken,
* {@link #connect(java.io.PipedWriter) unconnected}, or closed.
*/
@Override
public synchronized boolean ready() throws IOException {
if (!this.connected) {
throw new IOException("Pipe not connected");
} else if (this.closedByReader) {
throw new IOException("Pipe closed");
} else {
Thread writeSide = this.writeSide;
if (writeSide != null && !writeSide.isAlive() && !this.closedByWriter && (this.in < 0)) {
throw new IOException("Write end dead");
}
}
if (this.in < 0) {
return false;
} else {
return true;
}
}
/**
* Closes this piped stream and releases any system resources associated with the stream.
*
* @exception IOException
* if an I/O error occurs.
*/
@Override
public void close() throws IOException {
this.in = -1;
this.closedByReader = true;
}
}