## org.klomp.snark
Class PeerState

    java.lang.Object
      org.klomp.snark.PeerState

     class PeerState

extends Object

Field Summary
`(package private) BitField` `bitfield`
`(package private) boolean` `choked`
`(package private) boolean` `choking`
`(package private) long` `downloaded`
`(package private) PeerConnectionIn` `in`
`(package private) boolean` `interested`
`(package private) boolean` `interesting`
`(package private) PeerListener` `listener`
`(package private) MetaInfo` `metainfo`
`(package private) PeerConnectionOut` `out`
`static int` `PARTSIZE`
`(package private) Peer` `peer`
`(package private) Request` `pendingRequest`
`(package private) long` `uploaded`

Constructor Summary
`PeerState(Peer peer, PeerListener listener, MetaInfo metainfo, PeerConnectionIn in, PeerConnectionOut out)`

Method Summary
`(package private) void` `addRequest()` Adds a new request to the outstanding requests list.
`(package private) void` `bitfieldMessage(byte[] bitmap)`
`(package private) void` `cancelMessage(int piece, int begin, int length)`
`(package private) void` `cancelPiece(int piece)` Tell the other side that we are no longer interested in any of the outstanding requests (if any) for this piece.
`(package private) void` `chokeMessage(boolean choke)`
`(package private) Request` `getOutstandingRequest(int piece, int begin, int length)` Called when a piece message is being processed by the incoming connection.
`(package private) Request` `getPartialRequest()`
`(package private) int[]` `getRequestedPieces()`
`(package private) String` `getRequests()` debug
`(package private) void` `haveMessage(int piece)`
`(package private) void` `havePiece(int piece)` We now have this piece.
`(package private) void` `interestedMessage(boolean interest)`
`(package private) boolean` `isRequesting(int piece)` Are we currently requesting the piece?
`(package private) void` `keepAlive()`
`(package private) void` `keepAliveMessage()`
`(package private) void` `pieceMessage(Request req)` Called when a partial piece request has been handled by PeerConnectionIn.
`(package private) void` `requestMessage(int piece, int begin, int length)`
`(package private) void` `retransmitRequests()`
`(package private) void` `setChoking(boolean choke)`
`(package private) void` `setInteresting(boolean interest)`
`(package private) void` `unknownMessage(int type, byte[] bs)`
`(package private) void` `uploaded(int size)` Called when some bytes have left the outgoing connection.

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

Field Detail

### peer

    final Peer peer

### listener

    final PeerListener listener

### metainfo

    final MetaInfo metainfo

### interesting

    boolean interesting

### choking

    boolean choking

### interested

    boolean interested

### choked

    boolean choked

### downloaded

    long downloaded

### uploaded

    long uploaded

### bitfield

    BitField bitfield

### in

    final PeerConnectionIn in

### out

    final PeerConnectionOut out

### PARTSIZE

    public static final int PARTSIZE

See Also:
  Constant Field Values

### pendingRequest

    Request pendingRequest

Constructor Detail

### PeerState

    PeerState(Peer peer,
              PeerListener listener,
              MetaInfo metainfo,
              PeerConnectionIn in,
              PeerConnectionOut out)

Method Detail

### keepAliveMessage

    void keepAliveMessage()

### chokeMessage

    void chokeMessage(boolean choke)

### interestedMessage

    void interestedMessage(boolean interest)

### haveMessage

    void haveMessage(int piece)

### bitfieldMessage

    void bitfieldMessage(byte[] bitmap)

### requestMessage

    void requestMessage(int piece,
                        int begin,
                        int length)

### uploaded

    void uploaded(int size)

  Called when some bytes have left the outgoing connection. XXX - Should indicate whether it was a real piece or overhead.

### pieceMessage

    void pieceMessage(Request req)

  Called when a partial piece request has been handled by PeerConnectionIn.

### getOutstandingRequest

    Request getOutstandingRequest(int piece,
                                  int begin,
                                  int length)

  Called when a piece message is being processed by the incoming connection. Returns null when there was no such request. It also requeues/sends requests when it thinks that they must have been lost.

### getPartialRequest

    Request getPartialRequest()

### getRequestedPieces

    int[] getRequestedPieces()

### cancelMessage

    void cancelMessage(int piece,
                       int begin,
                       int length)

### unknownMessage

    void unknownMessage(int type,
                        byte[] bs)

### havePiece

    void havePiece(int piece)

  We now have this piece. Tell the peer and cancel any requests for the piece.

### cancelPiece

    void cancelPiece(int piece)

  Tell the other side that we are no longer interested in any of the outstanding requests (if any) for this piece.

  Since:
    0.8.1

### isRequesting

    boolean isRequesting(int piece)

  Are we currently requesting the piece?

  Since:
    0.8.1

### addRequest

    void addRequest()

  Adds a new request to the outstanding requests list. Then send interested if we weren't. Then send new requests if not choked. If nothing to request, send not interested if we were.

### setInteresting

    void setInteresting(boolean interest)

### setChoking

    void setChoking(boolean choke)

### keepAlive

    void keepAlive()

### retransmitRequests

    void retransmitRequests()

### getRequests

    String getRequests()

  debug

  Returns:
    string or null
  Since:
    0.8.1