| Methods Summary |
|---|
| public synchronized int | available()Returns the number of bytes that can be read from this input
stream without blocking. This method overrides the available
method of the parent class.
if(in < 0)
return 0;
else if(in == out)
return buffer.length;
else if (in > out)
return in - out;
else
return in + buffer.length - out;
|
| private void | awaitSpace()
while (in == out) {
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();
}
}
|
| private void | checkStateForReceive()
if (!connected) {
throw new IOException("Pipe not connected");
} else if (closedByWriter || closedByReader) {
throw new IOException("Pipe closed");
} else if (readSide != null && !readSide.isAlive()) {
throw new IOException("Read end dead");
}
|
| public void | close()Closes this piped input stream and releases any system resources
associated with the stream.
closedByReader = true;
synchronized (this) {
in = -1;
}
|
| public void | connect(java.io.PipedOutputStream src)Causes this piped input stream to be connected
to the piped output stream src.
If this object is already connected to some
other piped output stream, an IOException
is thrown.
If src is an
unconnected piped output stream and snk
is an unconnected piped input stream, they
may be connected by either the call:
snk.connect(src)
or the call:
src.connect(snk)
The two
calls have the same effect.
src.connect(this);
|
| public synchronized int | read(byte[] b, int off, int len)Reads up to len bytes of data from this piped input
stream into an array of bytes. Less than len bytes
will be read if the end of the data stream is reached. This method
blocks until at least one byte of input is available.
If a thread was providing data bytes
to the connected piped output stream, but
the thread is no longer alive, then an
IOException is thrown.
if (b == null) {
throw new NullPointerException();
} else if ((off < 0) || (off > b.length) || (len < 0) ||
((off + len) > b.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;
}
b[off] = (byte) c;
int rlen = 1;
while ((in >= 0) && (--len > 0)) {
b[off + rlen] = buffer[out++];
rlen++;
if (out >= buffer.length) {
out = 0;
}
if (in == out) {
/* now empty */
in = -1;
}
}
return rlen;
|
| public synchronized int | read()Reads the next byte of data from this piped input stream. The
value byte is returned as an int in the range
0 to 255. If no byte 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.
If a thread was providing data bytes
to the connected piped output stream, but
the thread is no longer alive, then an
IOException is thrown.
if (!connected) {
throw new IOException("Pipe not connected");
} else if (closedByReader) {
throw new IOException("Pipe closed");
} else if (writeSide != null && !writeSide.isAlive()
&& !closedByWriter && (in < 0)) {
throw new IOException("Write end dead");
}
readSide = Thread.currentThread();
int trials = 2;
while (in < 0) {
if (closedByWriter) {
/* closed by writer, return EOF */
return -1;
}
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 = buffer[out++] & 0xFF;
if (out >= buffer.length) {
out = 0;
}
if (in == out) {
/* now empty */
in = -1;
}
return ret;
|
| protected synchronized void | receive(int b)Receives a byte of data. This method will block if no input is
available.
checkStateForReceive();
writeSide = Thread.currentThread();
if (in == out)
awaitSpace();
if (in < 0) {
in = 0;
out = 0;
}
buffer[in++] = (byte)(b & 0xFF);
if (in >= buffer.length) {
in = 0;
}
|
| synchronized void | receive(byte[] b, int off, int len)Receives data into an array of bytes. This method will
block until some input is available.
checkStateForReceive();
writeSide = Thread.currentThread();
int bytesToTransfer = len;
while (bytesToTransfer > 0) {
if (in == out)
awaitSpace();
int nextTransferAmount = 0;
if (out < in) {
nextTransferAmount = buffer.length - in;
} else if (in < out) {
if (in == -1) {
in = out = 0;
nextTransferAmount = buffer.length - in;
} else {
nextTransferAmount = out - in;
}
}
if (nextTransferAmount > bytesToTransfer)
nextTransferAmount = bytesToTransfer;
assert(nextTransferAmount > 0);
System.arraycopy(b, off, buffer, in, nextTransferAmount);
bytesToTransfer -= nextTransferAmount;
off += nextTransferAmount;
in += nextTransferAmount;
if (in >= buffer.length) {
in = 0;
}
}
|
| synchronized void | receivedLast()Notifies all waiting threads that the last byte of data has been
received.
closedByWriter = true;
notifyAll();
|
