mirror of
https://github.com/cwinfo/matterbridge.git
synced 2024-11-22 23:00:28 +00:00
112 lines
2.3 KiB
Go
112 lines
2.3 KiB
Go
package bytebufferpool
|
|
|
|
import "io"
|
|
|
|
// ByteBuffer provides byte buffer, which can be used for minimizing
|
|
// memory allocations.
|
|
//
|
|
// ByteBuffer may be used with functions appending data to the given []byte
|
|
// slice. See example code for details.
|
|
//
|
|
// Use Get for obtaining an empty byte buffer.
|
|
type ByteBuffer struct {
|
|
|
|
// B is a byte buffer to use in append-like workloads.
|
|
// See example code for details.
|
|
B []byte
|
|
}
|
|
|
|
// Len returns the size of the byte buffer.
|
|
func (b *ByteBuffer) Len() int {
|
|
return len(b.B)
|
|
}
|
|
|
|
// ReadFrom implements io.ReaderFrom.
|
|
//
|
|
// The function appends all the data read from r to b.
|
|
func (b *ByteBuffer) ReadFrom(r io.Reader) (int64, error) {
|
|
p := b.B
|
|
nStart := int64(len(p))
|
|
nMax := int64(cap(p))
|
|
n := nStart
|
|
if nMax == 0 {
|
|
nMax = 64
|
|
p = make([]byte, nMax)
|
|
} else {
|
|
p = p[:nMax]
|
|
}
|
|
for {
|
|
if n == nMax {
|
|
nMax *= 2
|
|
bNew := make([]byte, nMax)
|
|
copy(bNew, p)
|
|
p = bNew
|
|
}
|
|
nn, err := r.Read(p[n:])
|
|
n += int64(nn)
|
|
if err != nil {
|
|
b.B = p[:n]
|
|
n -= nStart
|
|
if err == io.EOF {
|
|
return n, nil
|
|
}
|
|
return n, err
|
|
}
|
|
}
|
|
}
|
|
|
|
// WriteTo implements io.WriterTo.
|
|
func (b *ByteBuffer) WriteTo(w io.Writer) (int64, error) {
|
|
n, err := w.Write(b.B)
|
|
return int64(n), err
|
|
}
|
|
|
|
// Bytes returns b.B, i.e. all the bytes accumulated in the buffer.
|
|
//
|
|
// The purpose of this function is bytes.Buffer compatibility.
|
|
func (b *ByteBuffer) Bytes() []byte {
|
|
return b.B
|
|
}
|
|
|
|
// Write implements io.Writer - it appends p to ByteBuffer.B
|
|
func (b *ByteBuffer) Write(p []byte) (int, error) {
|
|
b.B = append(b.B, p...)
|
|
return len(p), nil
|
|
}
|
|
|
|
// WriteByte appends the byte c to the buffer.
|
|
//
|
|
// The purpose of this function is bytes.Buffer compatibility.
|
|
//
|
|
// The function always returns nil.
|
|
func (b *ByteBuffer) WriteByte(c byte) error {
|
|
b.B = append(b.B, c)
|
|
return nil
|
|
}
|
|
|
|
// WriteString appends s to ByteBuffer.B.
|
|
func (b *ByteBuffer) WriteString(s string) (int, error) {
|
|
b.B = append(b.B, s...)
|
|
return len(s), nil
|
|
}
|
|
|
|
// Set sets ByteBuffer.B to p.
|
|
func (b *ByteBuffer) Set(p []byte) {
|
|
b.B = append(b.B[:0], p...)
|
|
}
|
|
|
|
// SetString sets ByteBuffer.B to s.
|
|
func (b *ByteBuffer) SetString(s string) {
|
|
b.B = append(b.B[:0], s...)
|
|
}
|
|
|
|
// String returns string representation of ByteBuffer.B.
|
|
func (b *ByteBuffer) String() string {
|
|
return string(b.B)
|
|
}
|
|
|
|
// Reset makes ByteBuffer.B empty.
|
|
func (b *ByteBuffer) Reset() {
|
|
b.B = b.B[:0]
|
|
}
|