## org.klomp.snark
Class PeerState

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

All Implemented Interfaces:
  DataLoader

     class PeerState

extends Object
implements DataLoader

Field Summary
`(package private) BitField` `bitfield` the pieces the peer has
`(package private) boolean` `choked`
`(package private) boolean` `choking`
`(package private) PeerConnectionIn` `in`
`(package private) boolean` `interested`
`(package private) boolean` `interesting`
`(package private) PeerListener` `listener` Fixme, used by Peer.disconnect() to get to the coordinator
`(package private) PeerConnectionOut` `out`
`static int` `PARTSIZE`

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) void` `extensionMessage(int id, byte[] bs)`
`(package private) Request` `getOutstandingRequest(int piece, int begin, int length)` Called when a piece message is being processed by the incoming connection.
`(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)` Deprecated. deadlocks
`(package private) void` `keepAlive()`
`(package private) void` `keepAliveMessage()`
`byte[]` `loadData(int piece, int begin, int length)` This is the callback that PeerConnectionOut calls
`(package private) void` `pieceMessage(Request req)` Called when a full chunk (i.e.
`(package private) void` `portMessage(int port)`
`(package private) void` `requestMessage(int piece, int begin, int length)`
`(package private) void` `retransmitRequests()`
`(package private) List<PartialPiece>` `returnPartialPieces()` Get partial pieces, give them back to PeerCoordinator.
`(package private) void` `setChoking(boolean choke)`
`(package private) void` `setInteresting(boolean interest)`
`void` `setMetaInfo(MetaInfo meta)` Switch from magnet mode to normal mode.
`(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

### listener

    final PeerListener listener

  Fixme, used by Peer.disconnect() to get to the coordinator

### interesting

    boolean interesting

### choking

    boolean choking

### interested

    boolean interested

### choked

    boolean choked

### bitfield

    BitField bitfield

  the pieces the peer has

### in

    final PeerConnectionIn in

### out

    final PeerConnectionOut out

### PARTSIZE

    public static final int PARTSIZE

See Also:
  Constant Field Values

Constructor Detail

### PeerState

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

Parameters:
  `metainfo` - null if in magnet mode

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)

### loadData

    public byte[] loadData(int piece,
                           int begin,
                           int length)

  This is the callback that PeerConnectionOut calls

  Specified by:
    `loadData` in interface `DataLoader`
  Returns:
    bytes or null for errors
  Since:
    0.8.2

### 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 full chunk (i.e. a piece message) has been received by PeerConnectionIn. This may block quite a while if it is the last chunk for a piece, as it calls the listener, who stores the piece and then calls havePiece for every peer on the torrent (including us).

### getOutstandingRequest

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

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

### returnPartialPieces

    List<PartialPiece> returnPartialPieces()

  Get partial pieces, give them back to PeerCoordinator. Clears the request queue.

  Returns:
    List of PartialPieces, even those with an offset == 0, or empty list
  Since:
    0.8.2

### cancelMessage

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

### extensionMessage

    void extensionMessage(int id,
                          byte[] bs)

  Since:
    0.8.2

### setMetaInfo

    public void setMetaInfo(MetaInfo meta)

  Switch from magnet mode to normal mode. If we already have the metainfo, this does nothing.

  Parameters:
    `meta` - non-null
  Since:
    0.8.4

### portMessage

    void portMessage(int port)

  Since:
    0.8.4

### 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)

  Deprecated. deadlocks

  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. This is called from several places:

         By getOustandingRequest() when the first part of a chunk comes in
         By havePiece() when somebody got a new piece completed
         By chokeMessage() when we receive an unchoke
         By setInteresting() when we are now interested
         By PeerCoordinator.updatePiecePriorities()

### 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