Skip test failures due to Go uTP implementation

[btrtrc.git] / file.go

diff --git a/file.go b/file.go
index 6c728d15e3d5de5662a431091993cf34b9f4e61a..ed2f5da9ced0e74c87a903d1b160a3793331701d 100644 (file)
--- a/file.go
+++ b/file.go
@@ -1,19 +1,21 @@
 package torrent
 
 import (
-       "strings"
+       "github.com/RoaringBitmap/roaring"
+       "github.com/anacrolix/missinggo/v2/bitmap"
 
        "github.com/anacrolix/torrent/metainfo"
 )
 
 // Provides access to regions of torrent data that correspond to its files.
 type File struct {
-       t      *Torrent
-       path   string
-       offset int64
-       length int64
-       fi     metainfo.FileInfo
-       prio   piecePriority
+       t           *Torrent
+       path        string
+       offset      int64
+       length      int64
+       fi          metainfo.FileInfo
+       displayPath string
+       prio        piecePriority
 }
 
 func (f *File) Torrent() *Torrent {
@@ -40,15 +42,57 @@ func (f *File) Length() int64 {
        return f.length
 }
 
-// The relative file path for a multi-file torrent, and the torrent name for a
-// single-file torrent.
-func (f *File) DisplayPath() string {
-       fip := f.FileInfo().Path
-       if len(fip) == 0 {
-               return f.t.info.Name
+// Number of bytes of the entire file we have completed. This is the sum of
+// completed pieces, and dirtied chunks of incomplete pieces.
+func (f *File) BytesCompleted() (n int64) {
+       f.t.cl.rLock()
+       n = f.bytesCompletedLocked()
+       f.t.cl.rUnlock()
+       return
+}
+
+func (f *File) bytesCompletedLocked() int64 {
+       return f.length - f.bytesLeft()
+}
+
+func fileBytesLeft(
+       torrentUsualPieceSize int64,
+       fileFirstPieceIndex int,
+       fileEndPieceIndex int,
+       fileTorrentOffset int64,
+       fileLength int64,
+       torrentCompletedPieces *roaring.Bitmap,
+) (left int64) {
+       numPiecesSpanned := fileEndPieceIndex - fileFirstPieceIndex
+       switch numPiecesSpanned {
+       case 0:
+       case 1:
+               if !torrentCompletedPieces.Contains(bitmap.BitIndex(fileFirstPieceIndex)) {
+                       left += fileLength
+               }
+       default:
+               if !torrentCompletedPieces.Contains(bitmap.BitIndex(fileFirstPieceIndex)) {
+                       left += torrentUsualPieceSize - (fileTorrentOffset % torrentUsualPieceSize)
+               }
+               if !torrentCompletedPieces.Contains(bitmap.BitIndex(fileEndPieceIndex - 1)) {
+                       left += fileTorrentOffset + fileLength - int64(fileEndPieceIndex-1)*torrentUsualPieceSize
+               }
+               completedMiddlePieces := torrentCompletedPieces.Clone()
+               completedMiddlePieces.RemoveRange(0, bitmap.BitRange(fileFirstPieceIndex+1))
+               completedMiddlePieces.RemoveRange(bitmap.BitRange(fileEndPieceIndex-1), bitmap.ToEnd)
+               left += int64(numPiecesSpanned-2-pieceIndex(completedMiddlePieces.GetCardinality())) * torrentUsualPieceSize
        }
-       return strings.Join(fip, "/")
+       return
+}
+
+func (f *File) bytesLeft() (left int64) {
+       return fileBytesLeft(int64(f.t.usualPieceSize()), f.BeginPieceIndex(), f.EndPieceIndex(), f.offset, f.length, &f.t._completedPieces)
+}
 
+// The relative file path for a multi-file torrent, and the torrent name for a
+// single-file torrent. Dir separators are '/'.
+func (f *File) DisplayPath() string {
+       return f.displayPath
 }
 
 // The download status of a piece that comprises part of a File.
@@ -59,8 +103,8 @@ type FilePieceState struct {
 
 // Returns the state of pieces in this file.
 func (f *File) State() (ret []FilePieceState) {
-       f.t.cl.mu.RLock()
-       defer f.t.cl.mu.RUnlock()
+       f.t.cl.rLock()
+       defer f.t.cl.rUnlock()
        pieceSize := int64(f.t.usualPieceSize())
        off := f.offset % pieceSize
        remaining := f.length
@@ -91,55 +135,45 @@ func byteRegionExclusivePieces(off, size, pieceSize int64) (begin, end int) {
        return
 }
 
-func (f *File) exclusivePieces() (begin, end int) {
-       return byteRegionExclusivePieces(f.offset, f.length, int64(f.t.usualPieceSize()))
-}
-
 // Deprecated: Use File.SetPriority.
 func (f *File) Cancel() {
        f.SetPriority(PiecePriorityNone)
 }
 
 func (f *File) NewReader() Reader {
-       tr := reader{
-               mu:        &f.t.cl.mu,
-               t:         f.t,
-               readahead: 5 * 1024 * 1024,
-               offset:    f.Offset(),
-               length:    f.Length(),
-       }
-       f.t.addReader(&tr)
-       return &tr
+       return f.t.newReader(f.Offset(), f.Length())
 }
 
 // Sets the minimum priority for pieces in the File.
 func (f *File) SetPriority(prio piecePriority) {
-       f.t.cl.mu.Lock()
-       defer f.t.cl.mu.Unlock()
-       if prio == f.prio {
-               return
+       f.t.cl.lock()
+       if prio != f.prio {
+               f.prio = prio
+               f.t.updatePiecePriorities(f.BeginPieceIndex(), f.EndPieceIndex(), "File.SetPriority")
        }
-       f.prio = prio
-       f.t.updatePiecePriorities(f.firstPieceIndex(), f.endPieceIndex())
+       f.t.cl.unlock()
 }
 
 // Returns the priority per File.SetPriority.
-func (f *File) Priority() piecePriority {
-       f.t.cl.mu.Lock()
-       defer f.t.cl.mu.Unlock()
-       return f.prio
+func (f *File) Priority() (prio piecePriority) {
+       f.t.cl.rLock()
+       prio = f.prio
+       f.t.cl.rUnlock()
+       return
 }
 
-func (f *File) firstPieceIndex() pieceIndex {
+// Returns the index of the first piece containing data for the file.
+func (f *File) BeginPieceIndex() int {
        if f.t.usualPieceSize() == 0 {
                return 0
        }
        return pieceIndex(f.offset / int64(f.t.usualPieceSize()))
 }
 
-func (f *File) endPieceIndex() pieceIndex {
+// Returns the index of the piece after the last one containing data for the file.
+func (f *File) EndPieceIndex() int {
        if f.t.usualPieceSize() == 0 {
                return 0
        }
-       return pieceIndex((f.offset+f.length-1)/int64(f.t.usualPieceSize())) + 1
+       return pieceIndex((f.offset + f.length + int64(f.t.usualPieceSize()) - 1) / int64(f.t.usualPieceSize()))
 }