Caleb J. Gardner
63 lines
1.1 KiB
Go
63 lines
1.1 KiB
Go
package data
|
|
|
|
import "io"
|
|
|
|
type Reader struct {
|
|
f *FullReader
|
|
curBlock []byte
|
|
nextIdx uint32
|
|
curOffset uint32
|
|
}
|
|
|
|
func NewReader(f *FullReader) (Reader, error) {
|
|
dat, err := f.Block(0)
|
|
if err != nil {
|
|
return Reader{}, err
|
|
}
|
|
return Reader{
|
|
f: f,
|
|
curBlock: dat,
|
|
nextIdx: 1,
|
|
curOffset: 0,
|
|
}, nil
|
|
}
|
|
|
|
func (d *Reader) Close() error {
|
|
d.curBlock = nil
|
|
return nil
|
|
}
|
|
|
|
func (d *Reader) advanceBlock() error {
|
|
if d.nextIdx >= d.f.BlockNum() {
|
|
d.curBlock = nil
|
|
return io.EOF
|
|
}
|
|
var err error
|
|
d.curBlock, err = d.f.Block(d.nextIdx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
d.nextIdx++
|
|
d.curOffset = 0
|
|
return nil
|
|
}
|
|
|
|
func (d *Reader) Read(buf []byte) (int, error) {
|
|
totRed := 0
|
|
toRead := 0
|
|
var err error
|
|
for totRed < len(buf) {
|
|
if int(d.curOffset) >= len(d.curBlock) {
|
|
err = d.advanceBlock()
|
|
if err != nil {
|
|
return totRed, err
|
|
}
|
|
}
|
|
toRead = min(len(d.curBlock)-int(d.curOffset), len(buf)-totRed)
|
|
copy(buf[totRed:], d.curBlock[d.curOffset:d.curOffset+uint32(toRead)])
|
|
totRed += toRead
|
|
d.curOffset += uint32(toRead)
|
|
}
|
|
return totRed, nil
|
|
}
|