requestStrategy

type Btree interface {
	Delete(PieceRequestOrderItem)
	Add(PieceRequestOrderItem)
	// This is an iterator. Go can't guarantee to not allocate if you return an iterator.
	Scan(func(PieceRequestOrderItem) bool)
	Contains(PieceRequestOrderItem) bool
}

type ChunkIndex = RequestIndex

type ChunkSpec = types.ChunkSpec

type Input interface {
	Torrent(metainfo.Hash) Torrent
	// Storage capacity, shared among all Torrents with the same storage.TorrentCapacity pointer in
	// their storage.Torrent references.
	Capacity() (cap int64, capped bool)
	// Across all the Torrents. This might be partitioned by storage capacity key now.
	MaxUnverifiedBytes() int64
}

type PeerRequestState struct {
	Interested bool
	Requests   PeerRequests
	// Cancelled and waiting response
	Cancelled typedRoaring.Bitmap[RequestIndex]
}

type PeerRequests interface {
	// Can be more efficient than GetCardinality.
	IsEmpty() bool
	// See roaring.Bitmap.GetCardinality.
	GetCardinality() uint64
	Contains(RequestIndex) bool
	// Should not adjust iteration order if item already exists, although I don't think that usage
	// exists.
	Add(RequestIndex)
	// See roaring.Bitmap.Rank.
	Rank(RequestIndex) uint64
	// Must yield in order items were added.
	Iterate(func(RequestIndex) bool) (all bool)
	// Must yield in order items were added.
	Iterator() iter.Seq[RequestIndex]
	// See roaring.Bitmap.CheckedRemove.
	CheckedRemove(RequestIndex) bool
	// Iterate a snapshot of the values. It is safe to mutate the underlying data structure.
	IterateSnapshot(func(RequestIndex) bool)
}

type Piece interface {
	// Whether requests should be made for this piece. This would be false for cases like the piece
	// is currently being hashed, or already complete.
	Request() bool
	// Whether the piece should be counted towards the unverified bytes limit. The intention is to
	// prevent pieces being starved from the opportunity to move to the completed state. Pieces that
	// are in an overhead state like being hashed, queued, or having metadata modified are here. If
	// we didn't count them we could race ahead downloading and leave lots of pieces stuck in an
	// intermediate state.
	CountUnverified() bool
}

type PieceRequestOrder struct {
	// contains filtered or unexported fields
}

type PieceRequestOrderItem struct {
	Key   PieceRequestOrderKey
	State PieceRequestOrderState
}

type PieceRequestOrderKey struct {
	// It should be the canonical short hash.
	InfoHash unique.Handle[metainfo.Hash]
	Index    int
}

type PieceRequestOrderPathHint = btree.PathHint

type PieceRequestOrderState struct {
	Availability int
	Priority     piecePriority
	Partial      bool
}

type Request = types.Request

type RequestIndex uint32

type RequestPieceFunc func(ih metainfo.Hash, pieceIndex int, orderState PieceRequestOrderState) bool

type Torrent interface {
	Piece(int) Piece
	PieceLength() int64
}