| Methods Summary |
|---|
| public synchronized int | available()Returns the number of bytes that are available before this stream will
block. This implementation returns the number of bytes written to this
pipe that have not been read yet.
if (buffer == null || in == -1) {
return 0;
}
return in <= out ? buffer.length - out + in : in - out;
|
| public void | close()Closes this stream. This implementation releases the buffer used for the
pipe and notifies all threads waiting to read or write.
synchronized (this) {
/* No exception thrown if already closed */
if (buffer != null) {
/* Release buffer to indicate closed. */
buffer = null;
}
}
|
| public void | connect(java.io.PipedOutputStream src)Connects this {@code PipedInputStream} to a {@link PipedOutputStream}.
Any data written to the output stream becomes readable in this input
stream.
src.connect(this);
|
| synchronized void | done()
isClosed = true;
notifyAll();
|
| public synchronized int | read()Reads a single byte from this stream and returns it as an integer in the
range from 0 to 255. Returns -1 if the end of this stream has been
reached. If there is no data in the pipe, this method blocks until data
is available, the end of the stream is detected or an exception is
thrown.
Separate threads should be used to read from a {@code PipedInputStream}
and to write to the connected {@link PipedOutputStream}. If the same
thread is used, a deadlock may occur.
if (!isConnected) {
throw new IOException(Msg.getString("K0074")); //$NON-NLS-1$
}
if (buffer == null) {
throw new IOException(Msg.getString("K0075")); //$NON-NLS-1$
}
/**
* Set the last thread to be reading on this PipedInputStream. If
* lastReader dies while someone is waiting to write an IOException of
* "Pipe broken" will be thrown in receive()
*/
lastReader = Thread.currentThread();
try {
boolean first = true;
while (in == -1) {
// Are we at end of stream?
if (isClosed) {
return -1;
}
if (!first && lastWriter != null && !lastWriter.isAlive()) {
throw new IOException(Msg.getString("K0076")); //$NON-NLS-1$
}
first = false;
// Notify callers of receive()
notifyAll();
wait(1000);
}
} catch (InterruptedException e) {
throw new InterruptedIOException();
}
byte result = buffer[out++];
if (out == buffer.length) {
out = 0;
}
if (out == in) {
// empty buffer
in = -1;
out = 0;
}
return result & 0xff;
|
| public synchronized int | read(byte[] bytes, int offset, int count)Reads at most {@code count} bytes from this stream and stores them in the
byte array {@code bytes} starting at {@code offset}. Blocks until at
least one byte has been read, the end of the stream is detected or an
exception is thrown.
Separate threads should be used to read from a {@code PipedInputStream}
and to write to the connected {@link PipedOutputStream}. If the same
thread is used, a deadlock may occur.
// BEGIN android-changed
if (bytes == null) {
throw new NullPointerException(Msg.getString("K0047")); //$NON-NLS-1$
}
// Exception priorities (in case of multiple errors) differ from
// RI, but are spec-compliant.
// removed redundant check, used (offset | count) < 0
// instead of (offset < 0) || (count < 0) to safe one operation
if ((offset | count) < 0 || count > bytes.length - offset) {
throw new IndexOutOfBoundsException(Msg.getString("K002f")); //$NON-NLS-1$
}
// END android-changed
if (count == 0) {
return 0;
}
if (!isConnected) {
throw new IOException(Msg.getString("K0074")); //$NON-NLS-1$
}
if (buffer == null) {
throw new IOException(Msg.getString("K0075")); //$NON-NLS-1$
}
/**
* Set the last thread to be reading on this PipedInputStream. If
* lastReader dies while someone is waiting to write an IOException of
* "Pipe broken" will be thrown in receive()
*/
lastReader = Thread.currentThread();
try {
boolean first = true;
while (in == -1) {
// Are we at end of stream?
if (isClosed) {
return -1;
}
if (!first && lastWriter != null && !lastWriter.isAlive()) {
throw new IOException(Msg.getString("K0076")); //$NON-NLS-1$
}
first = false;
// Notify callers of receive()
notifyAll();
wait(1000);
}
} catch (InterruptedException e) {
throw new InterruptedIOException();
}
int copyLength = 0;
/* Copy bytes from out to end of buffer first */
if (out >= in) {
copyLength = count > (buffer.length - out) ? buffer.length - out
: count;
System.arraycopy(buffer, out, bytes, offset, copyLength);
out += copyLength;
if (out == buffer.length) {
out = 0;
}
if (out == in) {
// empty buffer
in = -1;
out = 0;
}
}
/*
* Did the read fully succeed in the previous copy or is the buffer
* empty?
*/
if (copyLength == count || in == -1) {
return copyLength;
}
int bytesCopied = copyLength;
/* Copy bytes from 0 to the number of available bytes */
copyLength = in - out > (count - bytesCopied) ? count - bytesCopied
: in - out;
System.arraycopy(buffer, out, bytes, offset + bytesCopied, copyLength);
out += copyLength;
if (out == in) {
// empty buffer
in = -1;
out = 0;
}
return bytesCopied + copyLength;
|
| protected synchronized void | receive(int oneByte)Receives a byte and stores it in this stream's {@code buffer}. This
method is called by {@link PipedOutputStream#write(int)}. The least
significant byte of the integer {@code oneByte} is stored at index
{@code in} in the {@code buffer}.
This method blocks as long as {@code buffer} is full.
if (buffer == null || isClosed) {
throw new IOException(Msg.getString("K0078")); //$NON-NLS-1$
}
if (lastReader != null && !lastReader.isAlive()) {
throw new IOException(Msg.getString("K0076")); //$NON-NLS-1$
}
/**
* Set the last thread to be writing on this PipedInputStream. If
* lastWriter dies while someone is waiting to read an IOException of
* "Pipe broken" will be thrown in read()
*/
lastWriter = Thread.currentThread();
try {
while (buffer != null && out == in) {
notifyAll();
wait(1000);
if (lastReader != null && !lastReader.isAlive()) {
throw new IOException(Msg.getString("K0076")); //$NON-NLS-1$
}
}
} catch (InterruptedException e) {
throw new InterruptedIOException();
}
if (buffer != null) {
if (in == -1) {
in = 0;
}
buffer[in++] = (byte) oneByte;
if (in == buffer.length) {
in = 0;
}
return;
}
|
