2016-06-19 10:55:50 -04:00
|
|
|
// Package alloc provides a light-weight memory allocation mechanism.
|
2015-10-08 08:46:18 -04:00
|
|
|
package alloc
|
|
|
|
|
2016-01-10 04:50:36 -05:00
|
|
|
import (
|
2016-01-28 15:30:05 -05:00
|
|
|
"io"
|
2016-01-10 04:50:36 -05:00
|
|
|
)
|
|
|
|
|
2016-01-31 15:24:40 -05:00
|
|
|
const (
|
2016-02-06 16:28:35 -05:00
|
|
|
defaultOffset = 16
|
2016-01-31 15:24:40 -05:00
|
|
|
)
|
|
|
|
|
2016-12-06 11:26:06 -05:00
|
|
|
// BytesWriter is a writer that writes contents into the given buffer.
|
2016-12-06 05:03:42 -05:00
|
|
|
type BytesWriter func([]byte) int
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// Buffer is a recyclable allocation of a byte array. Buffer.Release() recycles
|
|
|
|
// the buffer into an internal buffer pool, in order to recreate a buffer more
|
|
|
|
// quickly.
|
2015-10-08 08:46:18 -04:00
|
|
|
type Buffer struct {
|
2016-12-06 07:42:12 -05:00
|
|
|
v []byte
|
2016-12-06 05:03:42 -05:00
|
|
|
pool Pool
|
|
|
|
|
|
|
|
start int
|
|
|
|
end int
|
2015-10-08 08:46:18 -04:00
|
|
|
}
|
|
|
|
|
2016-12-06 11:26:06 -05:00
|
|
|
// CreateBuffer creates a new Buffer object based on given container and parent pool.
|
2016-11-19 15:13:00 -05:00
|
|
|
func CreateBuffer(container []byte, parent Pool) *Buffer {
|
2016-07-15 08:24:20 -04:00
|
|
|
b := new(Buffer)
|
2016-12-06 07:42:12 -05:00
|
|
|
b.v = container
|
2016-07-15 08:24:20 -04:00
|
|
|
b.pool = parent
|
2016-12-06 05:03:42 -05:00
|
|
|
b.start = defaultOffset
|
|
|
|
b.end = defaultOffset
|
2016-07-15 08:24:20 -04:00
|
|
|
return b
|
|
|
|
}
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// Release recycles the buffer into an internal buffer pool.
|
2015-10-08 08:46:18 -04:00
|
|
|
func (b *Buffer) Release() {
|
2016-12-06 07:42:12 -05:00
|
|
|
if b == nil || b.v == nil {
|
2016-02-01 06:22:29 -05:00
|
|
|
return
|
|
|
|
}
|
2016-07-16 07:22:08 -04:00
|
|
|
if b.pool != nil {
|
|
|
|
b.pool.Free(b)
|
|
|
|
}
|
2016-12-06 07:42:12 -05:00
|
|
|
b.v = nil
|
2015-10-08 11:41:38 -04:00
|
|
|
b.pool = nil
|
2015-10-08 08:46:18 -04:00
|
|
|
}
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// Clear clears the content of the buffer, results an empty buffer with
|
|
|
|
// Len() = 0.
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) Clear() {
|
|
|
|
b.start = defaultOffset
|
|
|
|
b.end = defaultOffset
|
2015-10-08 08:46:18 -04:00
|
|
|
}
|
|
|
|
|
2016-08-17 06:05:53 -04:00
|
|
|
// Reset resets this Buffer into its original state.
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) Reset() {
|
|
|
|
b.start = defaultOffset
|
2016-12-06 07:42:12 -05:00
|
|
|
b.end = len(b.v)
|
2016-07-12 08:32:17 -04:00
|
|
|
}
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// AppendBytes appends one or more bytes to the end of the buffer.
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) AppendBytes(bytes ...byte) {
|
|
|
|
b.Append(bytes)
|
2015-10-08 17:06:12 -04:00
|
|
|
}
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// Append appends a byte array to the end of the buffer.
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) Append(data []byte) {
|
2016-12-06 07:42:12 -05:00
|
|
|
nBytes := copy(b.v[b.end:], data)
|
2016-12-06 05:03:42 -05:00
|
|
|
b.end += nBytes
|
2016-06-26 16:34:48 -04:00
|
|
|
}
|
|
|
|
|
2016-12-06 11:26:06 -05:00
|
|
|
// AppendFunc appends the content of a BytesWriter to the buffer.
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) AppendFunc(writer BytesWriter) {
|
2016-12-06 07:42:12 -05:00
|
|
|
nBytes := writer(b.v[b.end:])
|
2016-12-06 05:03:42 -05:00
|
|
|
b.end += nBytes
|
2016-06-26 16:34:48 -04:00
|
|
|
}
|
|
|
|
|
2016-01-31 15:24:40 -05:00
|
|
|
// Prepend prepends bytes in front of the buffer. Caller must ensure total bytes prepended is
|
|
|
|
// no more than 16 bytes.
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) Prepend(data []byte) {
|
2016-01-31 15:37:00 -05:00
|
|
|
b.SliceBack(len(data))
|
2016-12-06 07:42:12 -05:00
|
|
|
copy(b.v[b.start:], data)
|
2016-06-26 16:34:48 -04:00
|
|
|
}
|
|
|
|
|
2016-12-06 11:26:06 -05:00
|
|
|
// PrependBytes prepends all data in front of the buffer.
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) PrependBytes(data ...byte) {
|
|
|
|
b.Prepend(data)
|
2016-06-26 16:34:48 -04:00
|
|
|
}
|
|
|
|
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) PrependFunc(offset int, writer BytesWriter) {
|
|
|
|
b.SliceBack(offset)
|
2016-12-06 07:42:12 -05:00
|
|
|
writer(b.v[b.start:])
|
2016-07-17 17:11:05 -04:00
|
|
|
}
|
|
|
|
|
2016-12-06 11:26:06 -05:00
|
|
|
// Byte returns the bytes at index.
|
2016-12-05 09:19:14 -05:00
|
|
|
func (b *Buffer) Byte(index int) byte {
|
2016-12-06 07:42:12 -05:00
|
|
|
return b.v[b.start+index]
|
2016-12-05 09:19:14 -05:00
|
|
|
}
|
|
|
|
|
2016-12-06 11:26:06 -05:00
|
|
|
// SetByte sets the byte value at index.
|
2016-12-06 05:31:19 -05:00
|
|
|
func (b *Buffer) SetByte(index int, value byte) {
|
2016-12-06 07:42:12 -05:00
|
|
|
b.v[b.start+index] = value
|
2016-12-06 05:31:19 -05:00
|
|
|
}
|
|
|
|
|
2016-02-06 16:28:35 -05:00
|
|
|
// Bytes returns the content bytes of this Buffer.
|
2015-12-14 18:53:27 -05:00
|
|
|
func (b *Buffer) Bytes() []byte {
|
2016-12-06 07:42:12 -05:00
|
|
|
return b.v[b.start:b.end]
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Buffer) SetBytesFunc(writer BytesWriter) {
|
2016-12-07 09:00:04 -05:00
|
|
|
b.start = defaultOffset
|
2016-12-06 07:42:12 -05:00
|
|
|
b.end = b.start + writer(b.v[b.start:])
|
2015-12-14 18:53:27 -05:00
|
|
|
}
|
|
|
|
|
2016-12-06 11:26:06 -05:00
|
|
|
// BytesRange returns a slice of this buffer with given from and to bounary.
|
2016-12-05 09:19:14 -05:00
|
|
|
func (b *Buffer) BytesRange(from, to int) []byte {
|
|
|
|
if from < 0 {
|
2016-12-06 05:03:42 -05:00
|
|
|
from += b.Len()
|
2016-12-05 09:19:14 -05:00
|
|
|
}
|
|
|
|
if to < 0 {
|
2016-12-06 05:03:42 -05:00
|
|
|
to += b.Len()
|
2016-12-05 09:19:14 -05:00
|
|
|
}
|
2016-12-06 07:42:12 -05:00
|
|
|
return b.v[b.start+from : b.start+to]
|
2016-12-05 09:19:14 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Buffer) BytesFrom(from int) []byte {
|
|
|
|
if from < 0 {
|
2016-12-06 05:03:42 -05:00
|
|
|
from += b.Len()
|
2016-12-05 09:19:14 -05:00
|
|
|
}
|
2016-12-06 07:42:12 -05:00
|
|
|
return b.v[b.start+from : b.end]
|
2016-12-05 09:19:14 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Buffer) BytesTo(to int) []byte {
|
|
|
|
if to < 0 {
|
2016-12-06 05:03:42 -05:00
|
|
|
to += b.Len()
|
2016-12-05 09:19:14 -05:00
|
|
|
}
|
2016-12-06 07:42:12 -05:00
|
|
|
return b.v[b.start : b.start+to]
|
2016-12-05 09:19:14 -05:00
|
|
|
}
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// Slice cuts the buffer at the given position.
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) Slice(from, to int) {
|
|
|
|
if from < 0 {
|
|
|
|
from += b.Len()
|
|
|
|
}
|
|
|
|
if to < 0 {
|
|
|
|
to += b.Len()
|
|
|
|
}
|
|
|
|
if to < from {
|
|
|
|
panic("Invalid slice")
|
|
|
|
}
|
|
|
|
b.end = b.start + to
|
|
|
|
b.start += from
|
2015-10-08 08:46:18 -04:00
|
|
|
}
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// SliceFrom cuts the buffer at the given position.
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) SliceFrom(from int) {
|
|
|
|
if from < 0 {
|
|
|
|
from += b.Len()
|
|
|
|
}
|
|
|
|
b.start += from
|
2015-10-08 08:46:18 -04:00
|
|
|
}
|
|
|
|
|
2016-02-06 16:28:35 -05:00
|
|
|
// SliceBack extends the Buffer to its front by offset bytes.
|
|
|
|
// Caller must ensure cumulated offset is no more than 16.
|
2016-12-06 05:03:42 -05:00
|
|
|
func (b *Buffer) SliceBack(offset int) {
|
|
|
|
b.start -= offset
|
|
|
|
if b.start < 0 {
|
2016-07-15 08:24:20 -04:00
|
|
|
panic("Negative buffer offset.")
|
2016-01-31 15:37:00 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// Len returns the length of the buffer content.
|
2015-10-08 08:46:18 -04:00
|
|
|
func (b *Buffer) Len() int {
|
2016-02-01 06:22:29 -05:00
|
|
|
if b == nil {
|
|
|
|
return 0
|
|
|
|
}
|
2016-12-06 05:03:42 -05:00
|
|
|
return b.end - b.start
|
2015-10-08 08:46:18 -04:00
|
|
|
}
|
|
|
|
|
2016-12-06 11:26:06 -05:00
|
|
|
// IsEmpty returns true if the buffer is empty.
|
2016-02-26 17:45:33 -05:00
|
|
|
func (b *Buffer) IsEmpty() bool {
|
|
|
|
return b.Len() == 0
|
|
|
|
}
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// IsFull returns true if the buffer has no more room to grow.
|
2015-10-08 17:06:12 -04:00
|
|
|
func (b *Buffer) IsFull() bool {
|
2016-12-06 07:42:12 -05:00
|
|
|
return b.end == len(b.v)
|
2015-10-08 17:06:12 -04:00
|
|
|
}
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// Write implements Write method in io.Writer.
|
2015-10-10 14:52:13 -04:00
|
|
|
func (b *Buffer) Write(data []byte) (int, error) {
|
2016-12-06 07:42:12 -05:00
|
|
|
nBytes := copy(b.v[b.end:], data)
|
2016-12-06 05:03:42 -05:00
|
|
|
b.end += nBytes
|
2016-12-02 08:35:28 -05:00
|
|
|
return nBytes, nil
|
2015-10-10 14:52:13 -04:00
|
|
|
}
|
|
|
|
|
2016-02-06 16:28:35 -05:00
|
|
|
// Read implements io.Reader.Read().
|
2016-01-28 15:30:05 -05:00
|
|
|
func (b *Buffer) Read(data []byte) (int, error) {
|
|
|
|
if b.Len() == 0 {
|
|
|
|
return 0, io.EOF
|
|
|
|
}
|
2016-12-06 07:42:12 -05:00
|
|
|
nBytes := copy(data, b.v[b.start:b.end])
|
2016-01-28 15:30:05 -05:00
|
|
|
if nBytes == b.Len() {
|
2016-05-12 20:20:07 -04:00
|
|
|
b.Clear()
|
2016-01-28 15:30:05 -05:00
|
|
|
} else {
|
2016-12-06 05:03:42 -05:00
|
|
|
b.start += nBytes
|
2016-01-28 15:30:05 -05:00
|
|
|
}
|
|
|
|
return nBytes, nil
|
|
|
|
}
|
|
|
|
|
2016-02-26 17:45:33 -05:00
|
|
|
func (b *Buffer) FillFrom(reader io.Reader) (int, error) {
|
2016-12-06 07:42:12 -05:00
|
|
|
nBytes, err := reader.Read(b.v[b.end:])
|
2016-12-06 05:03:42 -05:00
|
|
|
b.end += nBytes
|
2016-12-05 11:05:47 -05:00
|
|
|
return nBytes, err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Buffer) FillFullFrom(reader io.Reader, amount int) (int, error) {
|
2016-12-06 07:42:12 -05:00
|
|
|
nBytes, err := io.ReadFull(reader, b.v[b.end:b.end+amount])
|
2016-12-06 05:03:42 -05:00
|
|
|
b.end += nBytes
|
2016-02-26 17:45:33 -05:00
|
|
|
return nBytes, err
|
|
|
|
}
|
|
|
|
|
2016-04-29 17:40:28 -04:00
|
|
|
func (b *Buffer) String() string {
|
2016-12-06 07:42:12 -05:00
|
|
|
return string(b.v[b.start:b.end])
|
2016-04-29 17:40:28 -04:00
|
|
|
}
|
|
|
|
|
2015-10-11 08:46:12 -04:00
|
|
|
// NewBuffer creates a Buffer with 8K bytes of arbitrary content.
|
2015-10-08 17:06:12 -04:00
|
|
|
func NewBuffer() *Buffer {
|
2016-04-12 10:52:57 -04:00
|
|
|
return mediumPool.Allocate()
|
2015-10-08 17:06:12 -04:00
|
|
|
}
|
|
|
|
|
2016-12-06 11:26:06 -05:00
|
|
|
// NewSmallBuffer returns a buffer with 2K bytes capacity.
|
2016-11-21 16:08:34 -05:00
|
|
|
func NewSmallBuffer() *Buffer {
|
|
|
|
return smallPool.Allocate()
|
|
|
|
}
|
2016-07-16 07:22:08 -04:00
|
|
|
|
2016-12-06 11:26:06 -05:00
|
|
|
// NewLocalBuffer creates and returns a buffer on current thread.
|
2016-07-16 07:22:08 -04:00
|
|
|
func NewLocalBuffer(size int) *Buffer {
|
2016-11-19 15:13:00 -05:00
|
|
|
return CreateBuffer(make([]byte, size), nil)
|
2016-07-16 07:22:08 -04:00
|
|
|
}
|