## net.i2p.client.streaming
Class PacketLocal

    java.lang.Object
      net.i2p.client.streaming.Packet
          net.i2p.client.streaming.PacketLocal

All Implemented Interfaces:
  MessageOutputStream.WriteStatus

    public class PacketLocal

extends Packet
implements MessageOutputStream.WriteStatus

coordinate local attributes about a packet - send time, ack time, number of retries, etc.

Field Summary

Fields inherited from class net.i2p.client.streaming.Packet
`DEFAULT_MAX_SIZE, FLAG_CLOSE, FLAG_DELAY_REQUESTED, FLAG_ECHO, FLAG_FROM_INCLUDED, FLAG_MAX_PACKET_SIZE_INCLUDED, FLAG_NO_ACK, FLAG_PROFILE_INTERACTIVE, FLAG_RESET, FLAG_SIGNATURE_INCLUDED, FLAG_SIGNATURE_REQUESTED, FLAG_SYNCHRONIZE, MAX_PAYLOAD_SIZE, MAX_STREAM_ID, STREAM_ID_UNKNOWN`

Constructor Summary
`PacketLocal(I2PAppContext ctx, Destination to)`
`PacketLocal(I2PAppContext ctx, Destination to, Connection con)`

Method Summary
`void` `ackReceived()`
`void` `cancelled()`
`java.lang.StringBuffer` `formatAsString()`
`int` `getAckTime()` how long after packet creation was it acked?
`Connection` `getConnection()`
`long` `getCreatedOn()`
`SessionKey` `getKeyUsed()`
`long` `getLastSend()`
`long` `getLifetime()`
`int` `getNACKs()`
`int` `getNumSends()`
`SimpleTimer.TimedEvent` `getResendEvent()`
`java.util.Set` `getTagsSent()`
`Destination` `getTo()`
`void` `incrementNACKs()`
`void` `incrementSends()`
`void` `prepare()` last minute update of ack fields, just before write/sign
`void` `setKeyUsed(SessionKey key)`
`void` `setResendPacketEvent(SimpleTimer.TimedEvent evt)`
`void` `setTagsSent(java.util.Set tags)`
`void` `setTo(Destination to)`
`boolean` `shouldSign()`
`void` `waitForAccept(int maxWaitMs)` wait until the data written is accepted into the outbound pool, which we throttle rather than accept arbitrary data and queue
`void` `waitForCompletion(int maxWaitMs)` wait until the data written either fails or succeeds
`boolean` `writeAccepted()` the write was accepted.
`boolean` `writeFailed()` did the write fail?
`boolean` `writeSuccessful()` did the write succeed?

Methods inherited from class net.i2p.client.streaming.Packet

`acquirePayload, getAckThrough, getNacks, getOptionalDelay, getOptionalFrom, getOptionalMaxSize, getOptionalSignature, getPayload, getPayloadSize, getReceiveStreamId, getResendDelay, getSendStreamId, getSequenceNum, isFlagSet, readPacket, releasePayload, setAckThrough, setFlag, setFlag, setFlags, setNacks, setOptionalDelay, setOptionalFrom, setOptionalMaxSize, setOptionalSignature, setPayload, setReceiveStreamId, setResendDelay, setSendStreamId, setSequenceNum, toId, toString, verifySignature, writePacket, writeSignedPacket, writtenSize`

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

Constructor Detail

### PacketLocal

    public PacketLocal(I2PAppContext ctx,
                       Destination to)

### PacketLocal

    public PacketLocal(I2PAppContext ctx,
                       Destination to,
                       Connection con)

Method Detail

### getTo

    public Destination getTo()

### setTo

    public void setTo(Destination to)

### getKeyUsed

    public SessionKey getKeyUsed()

### setKeyUsed

    public void setKeyUsed(SessionKey key)

### getTagsSent

    public java.util.Set getTagsSent()

### setTagsSent

    public void setTagsSent(java.util.Set tags)

### shouldSign

    public boolean shouldSign()

### prepare

    public void prepare()

  last minute update of ack fields, just before write/sign

### getCreatedOn

    public long getCreatedOn()

### getLifetime

    public long getLifetime()

### incrementSends

    public void incrementSends()

### ackReceived

    public void ackReceived()

### cancelled

    public void cancelled()

### getResendEvent

    public SimpleTimer.TimedEvent getResendEvent()

### getAckTime

    public int getAckTime()

  how long after packet creation was it acked?

### getNumSends

    public int getNumSends()

### getLastSend

    public long getLastSend()

### getConnection

    public Connection getConnection()

### incrementNACKs

    public void incrementNACKs()

### getNACKs

    public int getNACKs()

### setResendPacketEvent

    public void setResendPacketEvent(SimpleTimer.TimedEvent evt)

### formatAsString

    public java.lang.StringBuffer formatAsString()

  Overrides:
    `formatAsString` in class `Packet`

### waitForAccept

    public void waitForAccept(int maxWaitMs)

  Description copied from interface: `MessageOutputStream.WriteStatus`
  wait until the data written is accepted into the outbound pool, which we throttle rather than accept arbitrary data and queue

  Specified by:
    `waitForAccept` in interface `MessageOutputStream.WriteStatus`

### waitForCompletion

    public void waitForCompletion(int maxWaitMs)

  Description copied from interface: `MessageOutputStream.WriteStatus`
  wait until the data written either fails or succeeds

  Specified by:
    `waitForCompletion` in interface `MessageOutputStream.WriteStatus`

### writeAccepted

    public boolean writeAccepted()

  Description copied from interface: `MessageOutputStream.WriteStatus`
  the write was accepted. aka did the socket not close?

  Specified by:
    `writeAccepted` in interface `MessageOutputStream.WriteStatus`

### writeFailed

    public boolean writeFailed()

  Description copied from interface: `MessageOutputStream.WriteStatus`
  did the write fail?

  Specified by:
    `writeFailed` in interface `MessageOutputStream.WriteStatus`

### writeSuccessful

    public boolean writeSuccessful()

  Description copied from interface: `MessageOutputStream.WriteStatus`
  did the write succeed?

  Specified by:
    `writeSuccessful` in interface `MessageOutputStream.WriteStatus`