mirror of
https://github.com/tuneinsight/lattigo.git
synced 2025-09-13 03:27:14 +00:00
86d081bce2
The WriterTo and ReaderFrom standard interface should be sufficient for the serialization of lattigo objects from their pointers. Other interfaces such as BinaryMarshaller should be based on WriterTo. This is possible in an efficient way if the Writer and Reader interface expose their internal buffer.
136 lines
3.7 KiB
Go
136 lines
3.7 KiB
Go
// Package buffer implement methods for efficiently writing and reading values
|
|
// to and from io.Writer and io.Reader that also expose their internal buffers.
|
|
package buffer
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
)
|
|
|
|
// Writer is an interface for writers that expose their internal
|
|
// buffers.
|
|
// This interface is notably implemented by the bufio.Writer type
|
|
// (see https://pkg.go.dev/bufio#Writer) and by the Buffer type.
|
|
type Writer interface {
|
|
io.Writer
|
|
Flush() (err error)
|
|
AvailableBuffer() []byte
|
|
Available() int
|
|
}
|
|
|
|
// Reader is an interface for readers that expose their internal
|
|
// buffers.
|
|
// This interface is notably implemented by the bufio.Reader type
|
|
// (see https://pkg.go.dev/bufio#Reader) and by the Buffer type.
|
|
type Reader interface {
|
|
io.Reader
|
|
Size() int
|
|
Peek(n int) ([]byte, error)
|
|
Discard(n int) (discarded int, err error)
|
|
}
|
|
|
|
// Buffer is a simple []byte-based buffer that complies to the
|
|
// Writer and Reader interfaces. This type assumes that its
|
|
// backing slice has a fixed size and won't attempt to extend
|
|
// it. Instead, writes beyond capacity will result in an error.
|
|
type Buffer struct {
|
|
buf []byte
|
|
n int
|
|
off int
|
|
}
|
|
|
|
// NewBuffer creates a new Buffer struct with buff as a backing
|
|
// []byte. The read and write offset are initialized at buff[0].
|
|
// Hence, writing new data will overwrite the content of buff.
|
|
func NewBuffer(buff []byte) *Buffer {
|
|
b := new(Buffer)
|
|
b.buf = buff
|
|
return b
|
|
}
|
|
|
|
// NewBufferSize creates a new Buffer with size capacity.
|
|
func NewBufferSize(size int) *Buffer {
|
|
b := new(Buffer)
|
|
b.buf = make([]byte, size)
|
|
return b
|
|
}
|
|
|
|
// Write writes p into b. It returns the number of bytes written
|
|
// and an error if attempting to write passed the initial capacity
|
|
// of the buffer. Note that the case where p shares the same backing
|
|
// memory as b is optimized.
|
|
func (b *Buffer) Write(p []byte) (n int, err error) {
|
|
if len(p)+b.n > cap(b.buf) {
|
|
return 0, fmt.Errorf("buffer too small")
|
|
}
|
|
inc := copy(b.buf[b.n:], p) // This is optimized if &b.buf[b.n:][0] == &p[0]
|
|
b.n += inc
|
|
return inc, nil
|
|
}
|
|
|
|
// Flush doesn't do anything on this slice-based buffer.
|
|
func (b *Buffer) Flush() (err error) {
|
|
return nil
|
|
}
|
|
|
|
// AvailableBuffer returns an empty buffer with b.Available() capacity, to be
|
|
// directly appended to and passed to a Write call. The buffer is only valid
|
|
// until the next write operation on b.
|
|
func (b *Buffer) AvailableBuffer() []byte {
|
|
return b.buf[b.n:][:0]
|
|
}
|
|
|
|
// Available returns the number of bytes available for writes on the buffer.
|
|
func (b *Buffer) Available() int {
|
|
return len(b.buf) - b.n
|
|
}
|
|
|
|
// Bytes returns the backing slice.
|
|
func (b *Buffer) Bytes() []byte {
|
|
return b.buf
|
|
}
|
|
|
|
// Reset re-initializes the read and write offsets of b.
|
|
func (b *Buffer) Reset() {
|
|
b.n = 0
|
|
b.off = 0
|
|
}
|
|
|
|
// Read reads len(p) bytes from the read offset of b into p. It returns the
|
|
// number n of bytes read and an error if n < len(p).
|
|
func (b *Buffer) Read(p []byte) (n int, err error) {
|
|
n = copy(p, b.buf[b.off:])
|
|
b.off += n
|
|
if n < len(p) {
|
|
return n, io.EOF
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
// Size returns the size of the buffer available for read.
|
|
func (b *Buffer) Size() int {
|
|
return len(b.buf) - b.off
|
|
}
|
|
|
|
// Peek returns the next n bytes without advancing the read offset, directly
|
|
// as a reslice of the internal buffer. It returns an error if the number of
|
|
// returned bytes is smaller than n.
|
|
func (b *Buffer) Peek(n int) ([]byte, error) {
|
|
if b.off+n > len(b.buf) {
|
|
return b.buf[b.off:], io.EOF
|
|
}
|
|
return b.buf[b.off : b.off+n], nil
|
|
}
|
|
|
|
// Discard skips the next n bytes, returning the number of bytes discarded. If
|
|
// Discard skips fewer than n bytes, it also returns an error.
|
|
func (b *Buffer) Discard(n int) (discarded int, err error) {
|
|
remain := len(b.buf) - b.off
|
|
if n > remain {
|
|
b.off = len(b.buf)
|
|
return remain, io.EOF
|
|
}
|
|
b.off += n
|
|
return n, nil
|
|
}
|