since: JDK1.1 -

since: JDK1.1 -

since: JDK1.1 -

since: JDK1.1 -

 public PipedInputStream() 
{
        initPipe(DEFAULT_PIPE_SIZE);
}

Creates a PipedInputStream so that it is not yet {@linkplain #connect(java.io.PipedOutputStream) connected}. It must be {@linkplain java.io.PipedOutputStream#connect( java.io.PipedInputStream) connected} to a PipedOutputStream before being used.

 public PipedInputStream(PipedOutputStream src) throws IOException 
{
                                                             
        this(src, DEFAULT_PIPE_SIZE);
}

Creates a PipedInputStream so that it is connected to the piped output stream src. Data bytes written to src will then be available as input from this stream.

Parameters:

src - the stream to connect to.

Throws:

IOException - if an I/O error occurs.

exception: IOException - if an I/O error occurs.

 public PipedInputStream(int pipeSize) 
{
        initPipe(pipeSize);
}

Creates a PipedInputStream so that it is not yet {@linkplain #connect(java.io.PipedOutputStream) connected} and uses the specified pipe size for the pipe's buffer. It must be {@linkplain java.io.PipedOutputStream#connect( java.io.PipedInputStream) connected} to a PipedOutputStream before being used.

Parameters:

pipeSize - the size of the pipe's buffer.

Throws:

IllegalArgumentException - if pipeSize <= 0.

exception: IllegalArgumentException - if pipeSize <= 0.

since: 1.6 -

 public PipedInputStream(PipedOutputStream src,
    int pipeSize) throws IOException 
{
         initPipe(pipeSize);
         connect(src);
}

Creates a PipedInputStream so that it is connected to the piped output stream src and uses the specified pipe size for the pipe's buffer. Data bytes written to src will then be available as input from this stream.

Parameters:

src - the stream to connect to.

pipeSize - the size of the pipe's buffer.

Throws:

IOException - if an I/O error occurs.

IllegalArgumentException - if pipeSize <= 0.

exception: IOException - if an I/O error occurs.

exception: IllegalArgumentException - if pipeSize <= 0.

since: 1.6 -

 public synchronized int available() throws IOException 
{
        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;
}

Returns the number of bytes that can be read from this input stream without blocking.

 public  void close() throws IOException 
{
        closedByReader = true;
        synchronized (this) {
            in = -1;
        }
}

Closes this piped input stream and releases any system resources associated with the stream.

 public  void connect(PipedOutputStream src) throws IOException 
{
        src.connect(this);
}

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.

 public synchronized int read() throws IOException 
{
        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;
}

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. This method blocks until input data is available, the end of the stream is detected, or an exception is thrown.

 public synchronized int read(byte[] b,
    int off,
    int len) throws IOException 
{
        if (b == null) {
            throw new NullPointerException();
        } else if (off <  0 || len <  0 || len  > b.length - off) {
            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  > 1)) {
            int available;
            if (in  > out) {
                available = Math.min((buffer.length - out), (in - out));
            } else {
                available = buffer.length - out;
            }
            // A byte is read beforehand outside the loop
            if (available  > (len - 1)) {
                available = len - 1;
            }
            System.arraycopy(buffer, out, b, off + rlen, available);
            out += available;
            rlen += available;
            len -= available;
            if (out  >= buffer.length) {
                out = 0;
            }
            if (in == out) {
                /* now empty */
                in = -1;
            }
        }
        return rlen;
}

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 or if len exceeds the pipe's buffer size. If len is zero, then no bytes are read and 0 is returned; otherwise, the method blocks until at least 1 byte of input is available, end of the stream has been detected, or an exception is thrown.

 protected synchronized  void receive(int b) throws IOException 
{
        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;
        }
}

Receives a byte of data. This method will block if no input is available.

 synchronized  void receive(byte[] b,
    int off,
    int len) throws IOException 
{
        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;
            }
        }
}

Receives data into an array of bytes. This method will block until some input is available.

 synchronized  void receivedLast() 
{
        closedByWriter = true;
        notifyAll();
}

Notifies all waiting threads that the last byte of data has been received.