Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| J2ME CDC
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.io
Class PipedInputStream

    java.lang.Object
      |
      +--java.io.InputStream
            |
            +--java.io.PipedInputStream

public class PipedInputStream
extends InputStream

A piped input stream should be connected to a piped output stream; the piped input stream then provides whatever data bytes are written to the piped output stream. Typically, data is read from a `PipedInputStream` object by one thread and data is written to the corresponding `PipedOutputStream` by some other thread. Attempting to use both objects from a single thread is not recommended, as it may deadlock the thread. The piped input stream contains a buffer, decoupling read operations from write operations, within limits.

Since:
  JDK1.0
See Also:
  `PipedOutputStream`

Field Summary
`protected byte[]` | `buffer` The circular buffer into which incoming data is placed.
`protected int` | `in` The index of the position in the circular buffer at which the next byte of data will be stored when received from the connected piped output stream.
`protected int` | `out` The index of the position in the circular buffer at which the next byte of data will be read by this piped input stream.
`protected static int` | `PIPE_SIZE` The size of the pipe's circular input buffer.

Constructor Summary
`PipedInputStream()` Creates a `PipedInputStream` so that it is not yet connected.
`PipedInputStream(PipedOutputStream src)` Creates a `PipedInputStream` so that it is connected to the piped output stream `src`.

Method Summary
`int` | `available()` Returns the number of bytes that can be read from this input stream without blocking.
`void` | `close()` Closes this piped input stream and releases any system resources associated with the stream.
`void` | `connect(PipedOutputStream src)` Causes this piped input stream to be connected to the piped output stream `src`.
`int` | `read()` Reads the next byte of data from this piped input stream.
`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.
`protected void` | `receive(int b)` Receives a byte of data.

Methods inherited from class java.io.InputStream
`mark, markSupported, read, reset, skip`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### PIPE_SIZE

    protected static final int PIPE_SIZE

  The size of the pipe's circular input buffer.
  Since:
    JDK1.1

### buffer

    protected byte[] buffer

  The circular buffer into which incoming data is placed.
  Since:
    JDK1.1

### in

    protected int in

  The index of the position in the circular buffer at which the next byte of data will be stored when received from the connected piped output stream. `in<0` implies the buffer is empty, `in==out` implies the buffer is full
  Since:
    JDK1.1

### out

    protected int out

  The index of the position in the circular buffer at which the next byte of data will be read by this piped input stream.
  Since:
    JDK1.1

Constructor Detail

### PipedInputStream

    public PipedInputStream(PipedOutputStream src)
                     throws IOException

  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.

### PipedInputStream

    public PipedInputStream()

  Creates a `PipedInputStream` so that it is not yet connected. It must be connected to a `PipedOutputStream` before being used.
  See Also:
    `connect(java.io.PipedOutputStream)`, `PipedOutputStream.connect(java.io.PipedInputStream)`

Method Detail

### connect

    public void connect(PipedOutputStream src)
                 throws IOException

  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.

  Parameters:
    `src` - The piped output stream to connect to.
  Throws:
    `IOException` - if an I/O error occurs.

### receive

    protected void receive(int b)
                    throws IOException

  Receives a byte of data. This method will block if no input is available.
  Parameters:
    `b` - the byte being received
  Throws:
    `IOException` - If the pipe is broken.
  Since:
    JDK1.1

### read

    public int read()
             throws IOException

  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.
  Overrides:
    `read` in class `InputStream`
  Returns:
    the next byte of data, or `-1` if the end of the stream is reached.
  Throws:
    `IOException` - if the pipe is broken.

### read

    public int read(byte[] b,
                    int off,
                    int len)
             throws IOException

  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.
  Overrides:
    `read` in class `InputStream`
  Parameters:
    `b` - the buffer into which the data is read.
    `off` - the start offset of the data.
    `len` - the maximum number of bytes read.
  Returns:
    the total number of bytes read into the buffer, or `-1` if there is no more data because the end of the stream has been reached.
  Throws:
    `IOException` - if an I/O error occurs.

### available

    public int available()
                  throws IOException

  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.
  Overrides:
    `available` in class `InputStream`
  Returns:
    the number of bytes that can be read from this input stream without blocking.
  Throws:
    `IOException` - if an I/O error occurs.
  Since:
    JDK1.0.2

### close

    public void close()
               throws IOException

  Closes this piped input stream and releases any system resources associated with the stream.
  Overrides:
    `close` in class `InputStream`
  Throws:
    `IOException` - if an I/O error occurs.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| J2ME CDC
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Java is a trademark or registred trademark of Sun Microsystems, Inc. in the US and other countries.
Copyright 1993-2000 Sun Microsystems, Inc. 901 San Antonio Road,
Palo, Alto, California, 94303, U.S.A All Rights Reserved.