cmd/btrtrc client

[btrtrc.git] / request-strategy-impls.go

diff --git a/request-strategy-impls.go b/request-strategy-impls.go
index 661769f3c1a94d5767397444d455d273785e8726..0b05ed41b0da43bba65255c9c07316387a12161a 100644 (file)
--- a/request-strategy-impls.go
+++ b/request-strategy-impls.go
@@ -1,67 +1,38 @@
 package torrent
 
 import (
-       g "github.com/anacrolix/generics"
-
        "github.com/anacrolix/torrent/metainfo"
        request_strategy "github.com/anacrolix/torrent/request-strategy"
        "github.com/anacrolix/torrent/storage"
 )
 
-type requestStrategyInputCommon struct {
-       maxUnverifiedBytes int64
-}
-
-func (r requestStrategyInputCommon) MaxUnverifiedBytes() int64 {
-       return r.maxUnverifiedBytes
-}
-
-type requestStrategyInputMultiTorrent struct {
-       requestStrategyInputCommon
-       torrents map[metainfo.Hash]*Torrent
-       capFunc  storage.TorrentCapacity
+type requestStrategyInput struct {
+       cl      *Client
+       capFunc storage.TorrentCapacity
 }
 
-func (r requestStrategyInputMultiTorrent) Torrent(ih metainfo.Hash) request_strategy.Torrent {
-       return requestStrategyTorrent{g.MapMustGet(r.torrents, ih)}
+func (r requestStrategyInput) Torrent(ih metainfo.Hash) request_strategy.Torrent {
+       return requestStrategyTorrent{r.cl.torrents[ih]}
 }
 
-func (r requestStrategyInputMultiTorrent) Capacity() (int64, bool) {
+func (r requestStrategyInput) Capacity() (int64, bool) {
+       if r.capFunc == nil {
+               return 0, false
+       }
        return (*r.capFunc)()
 }
 
-type requestStrategyInputSingleTorrent struct {
-       requestStrategyInputCommon
-       t *Torrent
-}
-
-func (r requestStrategyInputSingleTorrent) Torrent(_ metainfo.Hash) request_strategy.Torrent {
-       return requestStrategyTorrent{r.t}
+func (r requestStrategyInput) MaxUnverifiedBytes() int64 {
+       return r.cl.config.MaxUnverifiedBytes
 }
 
-func (r requestStrategyInputSingleTorrent) Capacity() (cap int64, capped bool) {
-       return 0, false
-}
-
-var _ request_strategy.Input = requestStrategyInputSingleTorrent{}
-
-func (cl *Client) getRequestStrategyInputCommon() requestStrategyInputCommon {
-       return requestStrategyInputCommon{cl.config.MaxUnverifiedBytes}
-}
+var _ request_strategy.Input = requestStrategyInput{}
 
 // Returns what is necessary to run request_strategy.GetRequestablePieces for primaryTorrent.
 func (cl *Client) getRequestStrategyInput(primaryTorrent *Torrent) (input request_strategy.Input) {
-       if !primaryTorrent.hasStorageCap() {
-               return requestStrategyInputSingleTorrent{
-                       requestStrategyInputCommon: cl.getRequestStrategyInputCommon(),
-                       t:                          primaryTorrent,
-               }
-       } else {
-               return requestStrategyInputMultiTorrent{
-                       requestStrategyInputCommon: cl.getRequestStrategyInputCommon(),
-                       torrents:                   cl.torrents,
-                       capFunc:                    primaryTorrent.storage.Capacity,
-               }
+       return requestStrategyInput{
+               cl:      cl,
+               capFunc: primaryTorrent.storage.Capacity,
        }
 }
 
@@ -73,8 +44,15 @@ type requestStrategyTorrent struct {
        t *Torrent
 }
 
-func (r requestStrategyTorrent) Piece(i int) request_strategy.Piece {
-       return (*requestStrategyPiece)(r.t.piece(i))
+func (r requestStrategyTorrent) IgnorePiece(i int) bool {
+       if r.t.ignorePieceForRequests(i) {
+               return true
+       }
+       if r.t.pieceNumPendingChunks(i) == 0 {
+               return true
+       }
+
+       return false
 }
 
 func (r requestStrategyTorrent) PieceLength() int64 {
@@ -83,14 +61,17 @@ func (r requestStrategyTorrent) PieceLength() int64 {
 
 var _ request_strategy.Torrent = requestStrategyTorrent{}
 
-type requestStrategyPiece Piece
+type requestStrategyPiece struct {
+       t *Torrent
+       i pieceIndex
+}
 
-func (r *requestStrategyPiece) Request() bool {
-       return !r.t.ignorePieceForRequests(r.index)
+func (r requestStrategyPiece) Request() bool {
+       return !r.t.ignorePieceForRequests(r.i)
 }
 
-func (r *requestStrategyPiece) NumPendingChunks() int {
-       return int(r.t.pieceNumPendingChunks(r.index))
+func (r requestStrategyPiece) NumPendingChunks() int {
+       return int(r.t.pieceNumPendingChunks(r.i))
 }
 
-var _ request_strategy.Piece = (*requestStrategyPiece)(nil)
+var _ request_strategy.Piece = requestStrategyPiece{}