153 lines
3.8 KiB
Go
Executable File
153 lines
3.8 KiB
Go
Executable File
package bufseekio
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
)
|
|
|
|
const (
|
|
defaultBufSize = 4096
|
|
)
|
|
|
|
// ReadSeeker implements buffering for an io.ReadSeeker object.
|
|
// ReadSeeker is based on bufio.Reader with Seek functionality added
|
|
// and unneeded functionality removed.
|
|
type ReadSeeker struct {
|
|
buf []byte
|
|
pos int64 // absolute start position of buf
|
|
rd io.ReadSeeker // read-seeker provided by the client
|
|
r, w int // buf read and write positions within buf
|
|
err error
|
|
}
|
|
|
|
const minReadBufferSize = 16
|
|
|
|
// NewReadSeekerSize returns a new ReadSeeker whose buffer has at least the specified
|
|
// size. If the argument io.ReadSeeker is already a ReadSeeker with large enough
|
|
// size, it returns the underlying ReadSeeker.
|
|
func NewReadSeekerSize(rd io.ReadSeeker, size int) *ReadSeeker {
|
|
// Is it already a Reader?
|
|
b, ok := rd.(*ReadSeeker)
|
|
if ok && len(b.buf) >= size {
|
|
return b
|
|
}
|
|
if size < minReadBufferSize {
|
|
size = minReadBufferSize
|
|
}
|
|
r := new(ReadSeeker)
|
|
r.reset(make([]byte, size), rd)
|
|
return r
|
|
}
|
|
|
|
// NewReadSeeker returns a new ReadSeeker whose buffer has the default size.
|
|
func NewReadSeeker(rd io.ReadSeeker) *ReadSeeker {
|
|
return NewReadSeekerSize(rd, defaultBufSize)
|
|
}
|
|
|
|
var errNegativeRead = errors.New("bufseekio: reader returned negative count from Read")
|
|
|
|
func (b *ReadSeeker) reset(buf []byte, r io.ReadSeeker) {
|
|
*b = ReadSeeker{
|
|
buf: buf,
|
|
rd: r,
|
|
}
|
|
}
|
|
|
|
func (b *ReadSeeker) readErr() error {
|
|
err := b.err
|
|
b.err = nil
|
|
return err
|
|
}
|
|
|
|
// Read reads data into p.
|
|
// It returns the number of bytes read into p.
|
|
// The bytes are taken from at most one Read on the underlying Reader,
|
|
// hence n may be less than len(p).
|
|
// To read exactly len(p) bytes, use io.ReadFull(b, p).
|
|
// If the underlying Reader can return a non-zero count with io.EOF,
|
|
// then this Read method can do so as well; see the [io.Reader] docs.
|
|
func (b *ReadSeeker) Read(p []byte) (n int, err error) {
|
|
n = len(p)
|
|
if n == 0 {
|
|
if b.buffered() > 0 {
|
|
return 0, nil
|
|
}
|
|
return 0, b.readErr()
|
|
}
|
|
if b.r == b.w {
|
|
if b.err != nil {
|
|
return 0, b.readErr()
|
|
}
|
|
if len(p) >= len(b.buf) {
|
|
// Large read, empty buffer.
|
|
// Read directly into p to avoid copy.
|
|
n, b.err = b.rd.Read(p)
|
|
if n < 0 {
|
|
panic(errNegativeRead)
|
|
}
|
|
b.pos += int64(n)
|
|
return n, b.readErr()
|
|
}
|
|
// One read.
|
|
b.pos += int64(b.r)
|
|
b.r = 0
|
|
b.w = 0
|
|
n, b.err = b.rd.Read(b.buf)
|
|
if n < 0 {
|
|
panic(errNegativeRead)
|
|
}
|
|
if n == 0 {
|
|
return 0, b.readErr()
|
|
}
|
|
b.w += n
|
|
}
|
|
|
|
// copy as much as we can
|
|
// Note: if the slice panics here, it is probably because
|
|
// the underlying reader returned a bad count. See issue 49795.
|
|
n = copy(p, b.buf[b.r:b.w])
|
|
b.r += n
|
|
return n, nil
|
|
}
|
|
|
|
// buffered returns the number of bytes that can be read from the current buffer.
|
|
func (b *ReadSeeker) buffered() int { return b.w - b.r }
|
|
|
|
func (b *ReadSeeker) Seek(offset int64, whence int) (int64, error) {
|
|
// The stream.Seek() implementation makes heavy use of seeking with offset 0
|
|
// to obtain the current position; let's optimize for it.
|
|
if offset == 0 && whence == io.SeekCurrent {
|
|
return b.position(), nil
|
|
}
|
|
// When seeking from the end, the absolute position isn't known by ReadSeeker
|
|
// so the current buffer cannot be used. Seeking cannot be avoided.
|
|
if whence == io.SeekEnd {
|
|
return b.seek(offset, whence)
|
|
}
|
|
// Calculate the absolute offset.
|
|
abs := offset
|
|
if whence == io.SeekCurrent {
|
|
abs += b.position()
|
|
}
|
|
// Check if the offset is within buf.
|
|
if abs >= b.pos && abs < b.pos+int64(b.w) {
|
|
b.r = int(abs - b.pos)
|
|
return abs, nil
|
|
}
|
|
|
|
return b.seek(abs, io.SeekStart)
|
|
}
|
|
|
|
func (b *ReadSeeker) seek(offset int64, whence int) (int64, error) {
|
|
b.r = 0
|
|
b.w = 0
|
|
var err error
|
|
b.pos, err = b.rd.Seek(offset, whence)
|
|
return b.pos, err
|
|
}
|
|
|
|
// position returns the absolute read offset.
|
|
func (b *ReadSeeker) position() int64 {
|
|
return b.pos + int64(b.r)
|
|
}
|