|
|
// Copyright 2021, Chef. All rights reserved.
|
|
|
// https://github.com/q191201771/lal
|
|
|
//
|
|
|
// Use of this source code is governed by a MIT-style license
|
|
|
// that can be found in the License file.
|
|
|
//
|
|
|
// Author: Chef (191201771@qq.com)
|
|
|
|
|
|
package nazabytes
|
|
|
|
|
|
import (
|
|
|
"fmt"
|
|
|
"io"
|
|
|
|
|
|
"github.com/q191201771/naza/pkg/nazalog"
|
|
|
)
|
|
|
|
|
|
// TODO(chef): 增加options: growRoundThreshold; 是否做检查
|
|
|
// TODO(chef): 扩容策略函数可由外部传入
|
|
|
|
|
|
const growMinThreshold = 128
|
|
|
const growRoundThreshold = 1048576 // 1MB
|
|
|
|
|
|
// Buffer 先进先出可扩容流式buffer，可直接读写内部切片避免拷贝
|
|
|
//
|
|
|
// 部分Api示例:
|
|
|
// 读取方式1
|
|
|
// buf := Bytes()
|
|
|
// ... // 读取buf的内容
|
|
|
// Skip(n)
|
|
|
//
|
|
|
// 读取方式2
|
|
|
// buf := Peek(n)
|
|
|
// ...
|
|
|
//
|
|
|
// 读取方式3
|
|
|
// buf := make([]byte, n)
|
|
|
// nn, err := Read(buf)
|
|
|
//
|
|
|
// 读取方式4
|
|
|
// ... String() ...
|
|
|
//
|
|
|
// 写入方式1
|
|
|
// Grow(n)
|
|
|
// buf := WritableBytes()[:n]
|
|
|
// ... // 向buf中写入内容
|
|
|
// Flush(n)
|
|
|
// // 或者直接
|
|
|
// buf := ReserveBytes(n)
|
|
|
// ... // 向buf中写入内容
|
|
|
// Flush(n)
|
|
|
//
|
|
|
// 写入方式2
|
|
|
// n, err := Write(buf)
|
|
|
//
|
|
|
// 写入方式3
|
|
|
// ... WriteString() ...
|
|
|
//
|
|
|
type Buffer struct {
|
|
|
core []byte
|
|
|
rpos int
|
|
|
wpos int
|
|
|
}
|
|
|
|
|
|
func NewBuffer(initCap int) *Buffer {
|
|
|
b := &Buffer{}
|
|
|
if initCap > 0 {
|
|
|
b.core = make([]byte, initCap, initCap)
|
|
|
}
|
|
|
return b
|
|
|
}
|
|
|
|
|
|
// NewBufferRefBytes
|
|
|
//
|
|
|
// 注意，不拷贝参数`b`的内存块，仅持有
|
|
|
//
|
|
|
func NewBufferRefBytes(b []byte) *Buffer {
|
|
|
return &Buffer{
|
|
|
core: b,
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
// Bytes Buffer中所有未读数据，类似于PeekAll，不拷贝
|
|
|
//
|
|
|
func (b *Buffer) Bytes() []byte {
|
|
|
if b.rpos == b.wpos {
|
|
|
return nil
|
|
|
}
|
|
|
return b.core[b.rpos:b.wpos]
|
|
|
}
|
|
|
|
|
|
// Peek 查看指定长度的未读数据，不拷贝，类似于Next，但是不会修改读取偏移位置
|
|
|
//
|
|
|
func (b *Buffer) Peek(n int) []byte {
|
|
|
if b.rpos == b.wpos {
|
|
|
return nil
|
|
|
}
|
|
|
if b.Len() < n {
|
|
|
return b.Bytes()
|
|
|
}
|
|
|
return b.core[b.rpos : b.rpos+n]
|
|
|
}
|
|
|
|
|
|
// Skip 将前`n`未读数据标记为已读（也即消费完成）
|
|
|
//
|
|
|
func (b *Buffer) Skip(n int) {
|
|
|
if n > b.wpos-b.rpos {
|
|
|
nazalog.Warnf("[%p] Buffer::Skip too large. n=%d, %s", b, n, b.DebugString())
|
|
|
b.Reset()
|
|
|
return
|
|
|
}
|
|
|
b.rpos += n
|
|
|
b.resetIfEmpty()
|
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
// Grow 确保Buffer中至少有`n`大小的空间可写，类似于Reserve
|
|
|
//
|
|
|
func (b *Buffer) Grow(n int) {
|
|
|
//nazalog.Debugf("[%p] > Buffer::Grow. n=%d, %s", b, n, b.DebugString())
|
|
|
tail := len(b.core) - b.wpos
|
|
|
if tail >= n {
|
|
|
// 尾部空闲空间足够
|
|
|
return
|
|
|
}
|
|
|
|
|
|
if b.rpos+tail >= n {
|
|
|
// 头部加上尾部空闲空间足够，将可读数据移动到头部，回收头部空闲空间
|
|
|
nazalog.Debugf("[%p] Buffer::Grow. move, this round need=%d, copy=%d", b, n, b.Len())
|
|
|
copy(b.core, b.core[b.rpos:b.wpos])
|
|
|
b.wpos -= b.rpos
|
|
|
b.rpos = 0
|
|
|
return
|
|
|
}
|
|
|
|
|
|
// 预分配一些
|
|
|
if n <= growMinThreshold {
|
|
|
n = growMinThreshold
|
|
|
} else if n < growRoundThreshold {
|
|
|
n = roundUpPowerOfTwo(n)
|
|
|
}
|
|
|
|
|
|
// 扩容后总共需要的大小
|
|
|
needed := b.Len() + n
|
|
|
|
|
|
if len(b.core) != 0 {
|
|
|
nazalog.Debugf("[%p] Buffer::Grow. realloc, this round need=%d, copy=%d, cap=(%d -> %d)", b, n, b.Len(), b.Cap(), needed)
|
|
|
}
|
|
|
core := make([]byte, needed, needed)
|
|
|
copy(core, b.core[b.rpos:b.wpos])
|
|
|
b.core = core
|
|
|
b.wpos -= b.rpos
|
|
|
b.rpos = 0
|
|
|
}
|
|
|
|
|
|
// WritableBytes 返回当前可写入的字节切片
|
|
|
//
|
|
|
func (b *Buffer) WritableBytes() []byte {
|
|
|
if len(b.core) == b.wpos {
|
|
|
return nil
|
|
|
}
|
|
|
return b.core[b.wpos:]
|
|
|
}
|
|
|
|
|
|
// ReserveBytes
|
|
|
//
|
|
|
// 返回可写入`n`大小的字节切片，如果空闲空间不够，内部会进行扩容。
|
|
|
//
|
|
|
// 注意，一般在完成写入后，需要调用 Flush。
|
|
|
//
|
|
|
// @return: 注意，返回值空间大小只会为`n`。
|
|
|
//
|
|
|
func (b *Buffer) ReserveBytes(n int) []byte {
|
|
|
b.Grow(n)
|
|
|
return b.WritableBytes()[:n]
|
|
|
}
|
|
|
|
|
|
// Flush 写入完成，更新写入位置
|
|
|
//
|
|
|
func (b *Buffer) Flush(n int) {
|
|
|
if len(b.core)-b.wpos < n {
|
|
|
nazalog.Warnf("[%p] Buffer::Flush too large. n=%d, %s", b, n, b.DebugString())
|
|
|
b.wpos = len(b.core)
|
|
|
return
|
|
|
}
|
|
|
b.wpos += n
|
|
|
}
|
|
|
|
|
|
// ----- implement io.Reader interface ---------------------------------------------------------------------------------
|
|
|
|
|
|
// Read 拷贝，`p`空间由外部申请
|
|
|
//
|
|
|
func (b *Buffer) Read(p []byte) (n int, err error) {
|
|
|
if len(p) == 0 {
|
|
|
return 0, nil
|
|
|
}
|
|
|
if b.Len() == 0 {
|
|
|
return 0, io.EOF
|
|
|
}
|
|
|
n = copy(p, b.core[b.rpos:b.wpos])
|
|
|
b.Skip(n)
|
|
|
return n, nil
|
|
|
}
|
|
|
|
|
|
// ----- implement io.Writer interface ---------------------------------------------------------------------------------
|
|
|
|
|
|
// Write 拷贝。内部空间不够时，会自动扩容
|
|
|
//
|
|
|
// @return n: 目前恒等于`len(p)`
|
|
|
//
|
|
|
// @return err: 目前恒等于nil
|
|
|
//
|
|
|
func (b *Buffer) Write(p []byte) (n int, err error) {
|
|
|
b.Grow(len(p))
|
|
|
copy(b.core[b.wpos:], p)
|
|
|
b.wpos += len(p)
|
|
|
return len(p), nil
|
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
// Truncate 丢弃可读数据的末尾`n`大小的数据，或者理解为取消写
|
|
|
//
|
|
|
func (b *Buffer) Truncate(n int) {
|
|
|
if b.Len() < n {
|
|
|
nazalog.Warnf("[%p] Buffer::Truncate too large. n=%d, %s", b, n, b.DebugString())
|
|
|
b.Reset()
|
|
|
return
|
|
|
}
|
|
|
b.wpos -= n
|
|
|
b.resetIfEmpty()
|
|
|
}
|
|
|
|
|
|
// Reset 重置。注意，并不会释放内存块，可复用
|
|
|
//
|
|
|
func (b *Buffer) Reset() {
|
|
|
b.rpos = 0
|
|
|
b.wpos = 0
|
|
|
}
|
|
|
|
|
|
// ResetAndFree 重置并不再持有底层内存块
|
|
|
//
|
|
|
func (b *Buffer) ResetAndFree() {
|
|
|
b.core = nil
|
|
|
b.rpos = 0
|
|
|
b.wpos = 0
|
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
// Len Buffer中还没有读的数据的长度
|
|
|
//
|
|
|
func (b *Buffer) Len() int {
|
|
|
return b.wpos - b.rpos
|
|
|
}
|
|
|
|
|
|
// Cap 整个Buffer占用的空间
|
|
|
//
|
|
|
func (b *Buffer) Cap() int {
|
|
|
return cap(b.core)
|
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
func (b *Buffer) WriteString(s string) (n int, err error) {
|
|
|
return b.Write(String2BytesRef(s))
|
|
|
}
|
|
|
|
|
|
func (b *Buffer) String() string {
|
|
|
return string(b.Bytes())
|
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
func (b *Buffer) DebugString() string {
|
|
|
return fmt.Sprintf("len(core)=%d, rpos=%d, wpos=%d", len(b.core), b.rpos, b.wpos)
|
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
func (b *Buffer) resetIfEmpty() {
|
|
|
if b.rpos == b.wpos {
|
|
|
b.Reset()
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// TODO(chef): refactor 移入naza中
|
|
|
func roundUpPowerOfTwo(n int) int {
|
|
|
if n <= 2 {
|
|
|
return 2
|
|
|
}
|
|
|
|
|
|
n--
|
|
|
n |= n >> 1
|
|
|
n |= n >> 2
|
|
|
n |= n >> 4
|
|
|
n |= n >> 8
|
|
|
n |= n >> 16
|
|
|
n |= n >> 32
|
|
|
n++
|
|
|
return n
|
|
|
}
|