net.i2p.router.transport.udp

## Class OutboundMessageState

- java.lang.Object
- - net.i2p.router.transport.udp.OutboundMessageState

-      class OutboundMessageState
      extends Object

  Maintain the outbound fragmentation for resending

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `MAX_MSG_SIZE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `OutboundMessageState(I2PAppContext context)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `acked(ACKBitfield bitfield)` Ack all the fragments in the ack list.
    `void` | `fragment(int fragmentSize)` Prepare the message for fragmented delivery, using no more than fragmentSize bytes per fragment.
    `int` | `fragmentSize(int fragmentNum)`
    `int` | `getFragmentCount()` how many fragments in the message
    `int` | `getFragmentSize()`
    `long` | `getLifetime()`
    `int` | `getMaxSends()`
    `OutNetMessage` | `getMessage()`
    `long` | `getMessageId()`
    `long` | `getNextSendTime()`
    `PeerState` | `getPeer()`
    `int` | `getPushCount()`
    `int` | `getUnackedSize()`
    `boolean` | `initialize(I2NPMessage msg, PeerState peer)`
    `boolean` | `initialize(OutNetMessage msg)`
    `boolean` | `initialize(OutNetMessage m, I2NPMessage msg)`
    `boolean` | `isComplete()`
    `boolean` | `isExpired()`
    `boolean` | `isFragmented()`
    `boolean` | `needsSending(int fragment)`
    `void` | `push()` note that we have pushed the message fragments
    `void` | `releaseResources()` This is synchronized with writeFragment(), so we do not release (probably due to an ack) while we are retransmitting.
    `void` | `setNextSendTime(long when)`
    `void` | `setPeer(PeerState peer)`
    `boolean` | `shouldSend(int fragmentNum)` should we continue sending this fragment?
    `String` | `toString()`
    `int` | `writeFragment(byte[] out, int outOffset, int fragmentNum)` Write a part of the the message onto the specified buffer.

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

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

- - ### Field Detail

    - #### MAX_MSG_SIZE

          public static final int MAX_MSG_SIZE

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### OutboundMessageState

          public OutboundMessageState(I2PAppContext context)

  - ### Method Detail

    - #### initialize

          public boolean initialize(OutNetMessage msg)

    - #### initialize

          public boolean initialize(I2NPMessage msg,
                           PeerState peer)

    - #### initialize

          public boolean initialize(OutNetMessage m,
                           I2NPMessage msg)

    - #### releaseResources

          public void releaseResources()

      This is synchronized with writeFragment(), so we do not release (probably due to an ack) while we are retransmitting. Also prevent double-free

    - #### getMessage

          public OutNetMessage getMessage()

    - #### getMessageId

          public long getMessageId()

    - #### getPeer

          public PeerState getPeer()

    - #### setPeer

          public void setPeer(PeerState peer)

    - #### isExpired

          public boolean isExpired()

    - #### isComplete

          public boolean isComplete()

    - #### getUnackedSize

          public int getUnackedSize()

    - #### needsSending

          public boolean needsSending(int fragment)

    - #### getLifetime

          public long getLifetime()

    - #### acked

          public boolean acked(ACKBitfield bitfield)

      Ack all the fragments in the ack list. As a side effect, if there are still unacked fragments, the 'next send' time will be updated under the assumption that that all of the packets within a volley would reach the peer within that ack frequency (2-400ms).
      Returns:
        true if the message was completely ACKed

    - #### getNextSendTime

          public long getNextSendTime()

    - #### setNextSendTime

          public void setNextSendTime(long when)

    - #### getMaxSends

          public int getMaxSends()

    - #### getPushCount

          public int getPushCount()

    - #### push

          public void push()

      note that we have pushed the message fragments

    - #### isFragmented

          public boolean isFragmented()

    - #### fragment

          public void fragment(int fragmentSize)

      Prepare the message for fragmented delivery, using no more than fragmentSize bytes per fragment.

    - #### getFragmentCount

          public int getFragmentCount()

      how many fragments in the message

    - #### getFragmentSize

          public int getFragmentSize()

    - #### shouldSend

          public boolean shouldSend(int fragmentNum)

      should we continue sending this fragment?

    - #### fragmentSize

          public int fragmentSize(int fragmentNum)

    - #### writeFragment

          public int writeFragment(byte[] out,
                          int outOffset,
                          int fragmentNum)

      Write a part of the the message onto the specified buffer. See releaseResources() above for synchhronization information.
      Parameters:
        `out` - target to write
        `outOffset` - into outOffset to begin writing
        `fragmentNum` - fragment to write (0 indexed)
      Returns:
        bytesWritten

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`