mirror of https://github.com/v2ray/v2ray-core
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
157 lines
3.4 KiB
157 lines
3.4 KiB
package alloc
|
|
|
|
import (
|
|
"io"
|
|
)
|
|
|
|
const (
|
|
defaultOffset = 16
|
|
)
|
|
|
|
// 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.
|
|
type Buffer struct {
|
|
head []byte
|
|
pool *BufferPool
|
|
Value []byte
|
|
offset int
|
|
}
|
|
|
|
// Release recycles the buffer into an internal buffer pool.
|
|
func (b *Buffer) Release() {
|
|
if b == nil {
|
|
return
|
|
}
|
|
b.pool.Free(b)
|
|
b.head = nil
|
|
b.Value = nil
|
|
b.pool = nil
|
|
}
|
|
|
|
// Clear clears the content of the buffer, results an empty buffer with
|
|
// Len() = 0.
|
|
func (b *Buffer) Clear() *Buffer {
|
|
b.offset = defaultOffset
|
|
b.Value = b.head[b.offset:b.offset]
|
|
return b
|
|
}
|
|
|
|
// AppendBytes appends one or more bytes to the end of the buffer.
|
|
func (b *Buffer) AppendBytes(bytes ...byte) *Buffer {
|
|
b.Value = append(b.Value, bytes...)
|
|
return b
|
|
}
|
|
|
|
// Append appends a byte array to the end of the buffer.
|
|
func (b *Buffer) Append(data []byte) *Buffer {
|
|
b.Value = append(b.Value, data...)
|
|
return b
|
|
}
|
|
|
|
func (b *Buffer) AppendString(s string) *Buffer {
|
|
b.Value = append(b.Value, s...)
|
|
return b
|
|
}
|
|
|
|
// Prepend prepends bytes in front of the buffer. Caller must ensure total bytes prepended is
|
|
// no more than 16 bytes.
|
|
func (b *Buffer) Prepend(data []byte) *Buffer {
|
|
b.SliceBack(len(data))
|
|
copy(b.Value, data)
|
|
return b
|
|
}
|
|
|
|
// Bytes returns the content bytes of this Buffer.
|
|
func (b *Buffer) Bytes() []byte {
|
|
return b.Value
|
|
}
|
|
|
|
// Slice cuts the buffer at the given position.
|
|
func (b *Buffer) Slice(from, to int) *Buffer {
|
|
b.Value = b.Value[from:to]
|
|
return b
|
|
}
|
|
|
|
// SliceFrom cuts the buffer at the given position.
|
|
func (b *Buffer) SliceFrom(from int) *Buffer {
|
|
b.Value = b.Value[from:]
|
|
return b
|
|
}
|
|
|
|
// SliceBack extends the Buffer to its front by offset bytes.
|
|
// Caller must ensure cumulated offset is no more than 16.
|
|
func (b *Buffer) SliceBack(offset int) *Buffer {
|
|
newoffset := b.offset - offset
|
|
if newoffset < 0 {
|
|
newoffset = 0
|
|
}
|
|
b.Value = b.head[newoffset : b.offset+len(b.Value)]
|
|
b.offset = newoffset
|
|
return b
|
|
}
|
|
|
|
// Len returns the length of the buffer content.
|
|
func (b *Buffer) Len() int {
|
|
if b == nil {
|
|
return 0
|
|
}
|
|
return len(b.Value)
|
|
}
|
|
|
|
func (b *Buffer) IsEmpty() bool {
|
|
return b.Len() == 0
|
|
}
|
|
|
|
// IsFull returns true if the buffer has no more room to grow.
|
|
func (b *Buffer) IsFull() bool {
|
|
return len(b.Value) == cap(b.Value)
|
|
}
|
|
|
|
// Write implements Write method in io.Writer.
|
|
func (b *Buffer) Write(data []byte) (int, error) {
|
|
b.Append(data)
|
|
return len(data), nil
|
|
}
|
|
|
|
// Read implements io.Reader.Read().
|
|
func (b *Buffer) Read(data []byte) (int, error) {
|
|
if b.Len() == 0 {
|
|
return 0, io.EOF
|
|
}
|
|
nBytes := copy(data, b.Value)
|
|
if nBytes == b.Len() {
|
|
b.Value = b.Value[:0]
|
|
} else {
|
|
b.Value = b.Value[nBytes:]
|
|
}
|
|
return nBytes, nil
|
|
}
|
|
|
|
func (b *Buffer) FillFrom(reader io.Reader) (int, error) {
|
|
begin := b.Len()
|
|
b.Value = b.Value[:cap(b.Value)]
|
|
nBytes, err := reader.Read(b.Value[begin:])
|
|
b.Value = b.Value[:begin+nBytes]
|
|
return nBytes, err
|
|
}
|
|
|
|
func (b *Buffer) String() string {
|
|
return string(b.Value)
|
|
}
|
|
|
|
// NewSmallBuffer creates a Buffer with 1K bytes of arbitrary content.
|
|
func NewSmallBuffer() *Buffer {
|
|
return smallPool.Allocate()
|
|
}
|
|
|
|
// NewBuffer creates a Buffer with 8K bytes of arbitrary content.
|
|
func NewBuffer() *Buffer {
|
|
return mediumPool.Allocate()
|
|
}
|
|
|
|
// NewLargeBuffer creates a Buffer with 64K bytes of arbitrary content.
|
|
func NewLargeBuffer() *Buffer {
|
|
return largePool.Allocate()
|
|
}
|