Make type piece public

diff --git a/connection_test.go b/connection_test.go
index 4f1d715b5196082a9e070a1f674dded9df03cdd3..fad120c8387f1985b243f46dae712c74bbabd1f8 100644 (file)
--- a/connection_test.go
+++ b/connection_test.go
@@ -122,7 +122,7 @@ func BenchmarkConnectionMainReadLoop(b *testing.B) {
        ts.writeSem.Lock()
        for range iter.N(b.N) {
                cl.mu.Lock()
-               t.pieces[0].DirtyChunks.Clear()
+               t.pieces[0].dirtyChunks.Clear()
                cl.mu.Unlock()
                n, err := w.Write(wb)
                require.NoError(b, err)

diff --git a/piece.go b/piece.go
index cfdb8ef29d8b862d08a1a27502d1f35529e39919..7a0c2f1789f4b169c694724a9e981db478717b06 100644 (file)
--- a/piece.go
+++ b/piece.go
@@ -29,21 +29,21 @@ const (
        PiecePriorityNow // A Reader is reading in this piece.
 )
 
-type piece struct {
+type Piece struct {
        // The completed piece SHA1 hash, from the metainfo "pieces" field.
-       Hash  metainfo.Hash
+       hash  metainfo.Hash
        t     *Torrent
        index int
        // Chunks we've written to since the last check. The chunk offset and
        // length can be determined by the request chunkSize in use.
-       DirtyChunks bitmap.Bitmap
+       dirtyChunks bitmap.Bitmap
 
-       Hashing       bool
-       QueuedForHash bool
-       EverHashed    bool
+       hashing       bool
+       queuedForHash bool
+       everHashed    bool
        numVerifies   int64
 
-       PublicPieceState PieceState
+       publicPieceState PieceState
        priority         piecePriority
 
        pendingWritesMutex sync.Mutex
@@ -51,55 +51,55 @@ type piece struct {
        noPendingWrites    sync.Cond
 }
 
-func (p *piece) Info() metainfo.Piece {
+func (p *Piece) Info() metainfo.Piece {
        return p.t.info.Piece(p.index)
 }
 
-func (p *piece) Storage() storage.Piece {
+func (p *Piece) Storage() storage.Piece {
        return p.t.storage.Piece(p.Info())
 }
 
-func (p *piece) pendingChunkIndex(chunkIndex int) bool {
-       return !p.DirtyChunks.Contains(chunkIndex)
+func (p *Piece) pendingChunkIndex(chunkIndex int) bool {
+       return !p.dirtyChunks.Contains(chunkIndex)
 }
 
-func (p *piece) pendingChunk(cs chunkSpec, chunkSize pp.Integer) bool {
+func (p *Piece) pendingChunk(cs chunkSpec, chunkSize pp.Integer) bool {
        return p.pendingChunkIndex(chunkIndex(cs, chunkSize))
 }
 
-func (p *piece) hasDirtyChunks() bool {
-       return p.DirtyChunks.Len() != 0
+func (p *Piece) hasDirtyChunks() bool {
+       return p.dirtyChunks.Len() != 0
 }
 
-func (p *piece) numDirtyChunks() (ret int) {
-       return p.DirtyChunks.Len()
+func (p *Piece) numDirtyChunks() (ret int) {
+       return p.dirtyChunks.Len()
 }
 
-func (p *piece) unpendChunkIndex(i int) {
-       p.DirtyChunks.Add(i)
+func (p *Piece) unpendChunkIndex(i int) {
+       p.dirtyChunks.Add(i)
 }
 
-func (p *piece) pendChunkIndex(i int) {
-       p.DirtyChunks.Remove(i)
+func (p *Piece) pendChunkIndex(i int) {
+       p.dirtyChunks.Remove(i)
 }
 
-func (p *piece) numChunks() int {
+func (p *Piece) numChunks() int {
        return p.t.pieceNumChunks(p.index)
 }
 
-func (p *piece) undirtiedChunkIndices() (ret bitmap.Bitmap) {
-       ret = p.DirtyChunks.Copy()
+func (p *Piece) undirtiedChunkIndices() (ret bitmap.Bitmap) {
+       ret = p.dirtyChunks.Copy()
        ret.FlipRange(0, p.numChunks())
        return
 }
 
-func (p *piece) incrementPendingWrites() {
+func (p *Piece) incrementPendingWrites() {
        p.pendingWritesMutex.Lock()
        p.pendingWrites++
        p.pendingWritesMutex.Unlock()
 }
 
-func (p *piece) decrementPendingWrites() {
+func (p *Piece) decrementPendingWrites() {
        p.pendingWritesMutex.Lock()
        if p.pendingWrites == 0 {
                panic("assertion")
@@ -111,7 +111,7 @@ func (p *piece) decrementPendingWrites() {
        p.pendingWritesMutex.Unlock()
 }
 
-func (p *piece) waitNoPendingWrites() {
+func (p *Piece) waitNoPendingWrites() {
        p.pendingWritesMutex.Lock()
        for p.pendingWrites != 0 {
                p.noPendingWrites.Wait()
@@ -119,15 +119,15 @@ func (p *piece) waitNoPendingWrites() {
        p.pendingWritesMutex.Unlock()
 }
 
-func (p *piece) chunkIndexDirty(chunk int) bool {
-       return p.DirtyChunks.Contains(chunk)
+func (p *Piece) chunkIndexDirty(chunk int) bool {
+       return p.dirtyChunks.Contains(chunk)
 }
 
-func (p *piece) chunkIndexSpec(chunk int) chunkSpec {
+func (p *Piece) chunkIndexSpec(chunk int) chunkSpec {
        return chunkIndexSpec(chunk, p.length(), p.chunkSize())
 }
 
-func (p *piece) numDirtyBytes() (ret pp.Integer) {
+func (p *Piece) numDirtyBytes() (ret pp.Integer) {
        defer func() {
                if ret > p.length() {
                        panic("too many dirty bytes")
@@ -142,30 +142,30 @@ func (p *piece) numDirtyBytes() (ret pp.Integer) {
        return
 }
 
-func (p *piece) length() pp.Integer {
+func (p *Piece) length() pp.Integer {
        return p.t.pieceLength(p.index)
 }
 
-func (p *piece) chunkSize() pp.Integer {
+func (p *Piece) chunkSize() pp.Integer {
        return p.t.chunkSize
 }
 
-func (p *piece) lastChunkIndex() int {
+func (p *Piece) lastChunkIndex() int {
        return p.numChunks() - 1
 }
 
-func (p *piece) bytesLeft() (ret pp.Integer) {
+func (p *Piece) bytesLeft() (ret pp.Integer) {
        if p.t.pieceComplete(p.index) {
                return 0
        }
        return p.length() - p.numDirtyBytes()
 }
 
-func (p *piece) VerifyData() {
+func (p *Piece) VerifyData() {
        p.t.cl.mu.Lock()
        defer p.t.cl.mu.Unlock()
        target := p.numVerifies + 1
-       if p.Hashing {
+       if p.hashing {
                target++
        }
        p.t.queuePieceCheck(p.index)

diff --git a/t.go b/t.go
index ce0c007f08b6b23ca1770fae78c6f2c65dac28fd..cc69d8e3c7ac9c04c756af316bd81c81fc1c0d08 100644 (file)
--- a/t.go
+++ b/t.go
@@ -210,7 +210,7 @@ func (t *Torrent) AddTrackers(announceList [][]string) {
        t.addTrackers(announceList)
 }
 
-func (t *Torrent) Piece(i int) *piece {
+func (t *Torrent) Piece(i int) *Piece {
        t.cl.mu.Lock()
        defer t.cl.mu.Unlock()
        return &t.pieces[i]

diff --git a/torrent.go b/torrent.go
index 29ca25a66aa4075f981a9b5b47856ee180f4d2cd..650f247a7ca3637375cf0784c196529446a17cec 100644 (file)
--- a/torrent.go
+++ b/torrent.go
@@ -47,7 +47,7 @@ type Torrent struct {
 
        closed   missinggo.Event
        infoHash metainfo.Hash
-       pieces   []piece
+       pieces   []Piece
        // Values are the piece indices that changed.
        pieceStateChanges *pubsub.PubSub
        // The size of chunks to request from peers over the wire. This is
@@ -233,13 +233,13 @@ func infoPieceHashes(info *metainfo.Info) (ret []string) {
 
 func (t *Torrent) makePieces() {
        hashes := infoPieceHashes(t.info)
-       t.pieces = make([]piece, len(hashes))
+       t.pieces = make([]Piece, len(hashes))
        for i, hash := range hashes {
                piece := &t.pieces[i]
                piece.t = t
                piece.index = i
                piece.noPendingWrites.L = &piece.pendingWritesMutex
-               missinggo.CopyExact(piece.Hash[:], hash)
+               missinggo.CopyExact(piece.hash[:], hash)
        }
 }
 
@@ -344,7 +344,7 @@ func (t *Torrent) pieceState(index int) (ret PieceState) {
        if t.pieceComplete(index) {
                ret.Complete = true
        }
-       if p.QueuedForHash || p.Hashing {
+       if p.queuedForHash || p.hashing {
                ret.Checking = true
        }
        if !ret.Complete && t.piecePartiallyDownloaded(index) {
@@ -598,7 +598,7 @@ func (t *Torrent) pieceNumChunks(piece int) int {
 }
 
 func (t *Torrent) pendAllChunkSpecs(pieceIndex int) {
-       t.pieces[pieceIndex].DirtyChunks.Clear()
+       t.pieces[pieceIndex].dirtyChunks.Clear()
 }
 
 type Peer struct {
@@ -691,10 +691,10 @@ func (t *Torrent) wantPieceIndex(index int) bool {
                return false
        }
        p := &t.pieces[index]
-       if p.QueuedForHash {
+       if p.queuedForHash {
                return false
        }
-       if p.Hashing {
+       if p.hashing {
                return false
        }
        if t.pieceComplete(index) {
@@ -737,8 +737,8 @@ type PieceStateChange struct {
 func (t *Torrent) publishPieceChange(piece int) {
        cur := t.pieceState(piece)
        p := &t.pieces[piece]
-       if cur != p.PublicPieceState {
-               p.PublicPieceState = cur
+       if cur != p.publicPieceState {
+               p.publicPieceState = cur
                t.pieceStateChanges.Publish(PieceStateChange{
                        piece,
                        cur,
@@ -754,7 +754,7 @@ func (t *Torrent) pieceNumPendingChunks(piece int) int {
 }
 
 func (t *Torrent) pieceAllDirty(piece int) bool {
-       return t.pieces[piece].DirtyChunks.Len() == t.pieceNumChunks(piece)
+       return t.pieces[piece].dirtyChunks.Len() == t.pieceNumChunks(piece)
 }
 
 func (t *Torrent) readersChanged() {
@@ -1383,17 +1383,17 @@ func (t *Torrent) pieceHashed(piece int, correct bool) {
        }
        p := &t.pieces[piece]
        touchers := t.reapPieceTouchers(piece)
-       if p.EverHashed {
+       if p.everHashed {
                // Don't score the first time a piece is hashed, it could be an
                // initial check.
                if correct {
                        pieceHashedCorrect.Add(1)
                } else {
-                       log.Printf("%s: piece %d (%s) failed hash: %d connections contributed", t, piece, p.Hash, len(touchers))
+                       log.Printf("%s: piece %d (%s) failed hash: %d connections contributed", t, piece, p.hash, len(touchers))
                        pieceHashedNotCorrect.Add(1)
                }
        }
-       p.EverHashed = true
+       p.everHashed = true
        if correct {
                for _, c := range touchers {
                        c.goodPiecesDirtied++
@@ -1472,22 +1472,22 @@ func (t *Torrent) verifyPiece(piece int) {
        cl.mu.Lock()
        defer cl.mu.Unlock()
        p := &t.pieces[piece]
-       for p.Hashing || t.storage == nil {
+       for p.hashing || t.storage == nil {
                cl.event.Wait()
        }
-       p.QueuedForHash = false
+       p.queuedForHash = false
        if t.closed.IsSet() || t.pieceComplete(piece) {
                t.updatePiecePriority(piece)
                return
        }
-       p.Hashing = true
+       p.hashing = true
        t.publishPieceChange(piece)
        cl.mu.Unlock()
        sum := t.hashPiece(piece)
        cl.mu.Lock()
        p.numVerifies++
-       p.Hashing = false
-       t.pieceHashed(piece, sum == p.Hash)
+       p.hashing = false
+       t.pieceHashed(piece, sum == p.hash)
 }
 
 // Return the connections that touched a piece, and clear the entry while
@@ -1512,10 +1512,10 @@ func (t *Torrent) connsAsSlice() (ret []*connection) {
 // Currently doesn't really queue, but should in the future.
 func (t *Torrent) queuePieceCheck(pieceIndex int) {
        piece := &t.pieces[pieceIndex]
-       if piece.QueuedForHash {
+       if piece.queuedForHash {
                return
        }
-       piece.QueuedForHash = true
+       piece.queuedForHash = true
        t.publishPieceChange(pieceIndex)
        go t.verifyPiece(pieceIndex)
 }

diff --git a/torrent_test.go b/torrent_test.go
index edda574dbb420b92946dd522ade0b330262a281e..4c5ac447c6826eb441d79dd46b15f10e48e242e9 100644 (file)
--- a/torrent_test.go
+++ b/torrent_test.go
@@ -149,7 +149,7 @@ func TestPieceHashFailed(t *testing.T) {
        }
        require.NoError(t, tt.setInfoBytes(mi.InfoBytes))
        tt.cl.mu.Lock()
-       tt.pieces[1].DirtyChunks.AddRange(0, 3)
+       tt.pieces[1].dirtyChunks.AddRange(0, 3)
        require.True(t, tt.pieceAllDirty(1))
        tt.pieceHashed(1, false)
        // Dirty chunks should be cleared so we can try again.