net.i2p.client.streaming

## Class MessageInputStream

- java.lang.Object
- - java.io.InputStream
  - - net.i2p.client.streaming.MessageInputStream

All Implemented Interfaces:
  Closeable

     class MessageInputStream
    extends InputStream

Stream that can be given messages out of order yet present them in order.

### Constructor Summary

Constructors
Constructor and Description
`MessageInputStream(I2PAppContext ctx)`

### Method Summary

Methods
`int` `available()`
`void` `close()`
`void` `closeReceived()`
`long` `getHighestBlockId()`
`long` `getHighestReadyBockId()` What is the highest block ID we've completely received through?
`long[]` `getNacks()` Retrieve the message IDs that are holes in our sequence - ones past the highest ready ID and below the highest received message ID.
`int` `getOutOfOrderBlockCount()` how many blocks have we received that we still have holes before?
`long[]` `getOutOfOrderBlocks()` Ascending list of block IDs greater than the highest ready block ID, or null if there aren't any.
`int` `getReadTimeout()` how long a read() call should block (if less than 0, block indefinitely, but if it is 0, do not block at all)
`int` `getTotalQueuedSize()` How many bytes are queued up for reading (or sitting in the out-of-order buffer)?
`int` `getTotalReadySize()`
`boolean` `messageReceived(long messageId, ByteArray payload)` A new message has arrived - toss it on the appropriate queue (moving previously pending messages to the ready queue if it fills the gap, etc).
`void` `notifyActivity()`
`int` `read()`
`int` `read(byte[] target)`
`int` `read(byte[] target, int offset, int length)`
`void` `setReadTimeout(int timeout)`
`(package private) void` `streamErrorOccurred(IOException ioe)` Stream b0rked, die with the given error
`void` `updateAcks(PacketLocal packet)`

### Methods inherited from class java.io.InputStream

`mark, markSupported, reset, skip`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### MessageInputStream

    public MessageInputStream(I2PAppContext ctx)

### Method Detail

#### getHighestReadyBockId

    public long getHighestReadyBockId()

What is the highest block ID we've completely received through?

Returns:
  highest data block ID completely received

#### getHighestBlockId

    public long getHighestBlockId()

#### getNacks

    public long[] getNacks()

Retrieve the message IDs that are holes in our sequence - ones past the highest ready ID and below the highest received message ID. This may return null if there are no such IDs.

Returns:
  array of message ID holes, or null if none

#### updateAcks

    public void updateAcks(PacketLocal packet)

#### getOutOfOrderBlocks

    public long[] getOutOfOrderBlocks()

Ascending list of block IDs greater than the highest ready block ID, or null if there aren't any.

Returns:
  block IDs greater than the highest ready block ID, or null if there aren't any.

#### getOutOfOrderBlockCount

    public int getOutOfOrderBlockCount()

how many blocks have we received that we still have holes before?

Returns:
  Count of blocks received that still have holes

#### getReadTimeout

    public int getReadTimeout()

how long a read() call should block (if less than 0, block indefinitely, but if it is 0, do not block at all)

Returns:
  how long read calls should block, 0 or less indefinitely block

#### setReadTimeout

    public void setReadTimeout(int timeout)

#### closeReceived

    public void closeReceived()

#### notifyActivity

    public void notifyActivity()

#### messageReceived

    public boolean messageReceived(long messageId,
                          ByteArray payload)

A new message has arrived - toss it on the appropriate queue (moving previously pending messages to the ready queue if it fills the gap, etc).

Parameters:
  `messageId` - ID of the message
  `payload` - message payload
Returns:
  true if this is a new packet, false if it is a dup

#### read

    public int read()
             throws IOException

Specified by:
  `read` in class `InputStream`
Throws:
  `IOException`

#### read

    public int read(byte[] target)
             throws IOException

Overrides:
  `read` in class `InputStream`
Throws:
  `IOException`

#### read

    public int read(byte[] target,
           int offset,
           int length)
             throws IOException

Overrides:
  `read` in class `InputStream`
Throws:
  `IOException`

#### available

    public int available()
                  throws IOException

Overrides:
  `available` in class `InputStream`
Throws:
  `IOException`

#### getTotalQueuedSize

    public int getTotalQueuedSize()

How many bytes are queued up for reading (or sitting in the out-of-order buffer)?

Returns:
  Count of bytes waiting to be read

#### getTotalReadySize

    public int getTotalReadySize()

#### close

    public void close()

Specified by:
  `close` in interface `Closeable`
Overrides:
  `close` in class `InputStream`

#### streamErrorOccurred

    void streamErrorOccurred(IOException ioe)

Stream b0rked, die with the given error