orbyte/pbuf/bytes.go

package pbuf

import (
	"bytes"

	"github.com/fumiama/orbyte"
)

// Bytes wrap pooled buffer into []byte
// while sharing the same pool.
type Bytes struct {
	buf *orbyte.Item[bytes.Buffer]
	dat []byte
}

// BufferItemToBytes convert between *orbyte.Item[bytes.Buffer]
// and Bytes.
//
// Please notice that Bytes cannnot convert back to
// *orbyte.Item[bytes.Buffer] again.
func BufferItemToBytes(buf *orbyte.Item[bytes.Buffer]) Bytes {
	return Bytes{buf: buf, dat: buf.Pointer().Bytes()}
}

// NewBytes alloc sz bytes.
func (bufferPool BufferPool) NewBytes(sz int) Bytes {
	buf := bufferPool.p.New(sz)
	return Bytes{buf: buf, dat: buf.Pointer().Bytes()[:sz]}
}

// InvolveBytes involve outside buf into pool.
func (bufferPool BufferPool) InvolveBytes(b ...byte) Bytes {
	buf := bufferPool.p.Involve(len(b), bytes.NewBuffer(b))
	return Bytes{buf: buf, dat: buf.Pointer().Bytes()[:len(b)]}
}

// ParseBytes convert outside bytes to Bytes safely
// without adding it into pool.
func (bufferPool BufferPool) ParseBytes(b ...byte) Bytes {
	buf := bufferPool.p.Parse(len(b), bytes.NewBuffer(b))
	return Bytes{buf: buf, dat: buf.Pointer().Bytes()[:len(b)]}
}

// Trans please refer to Item.Trans().
func (b Bytes) Trans() (tb Bytes) {
	if b.buf == nil {
		return
	}
	tb.buf = b.buf.Trans()
	tb.dat = b.dat
	return
}

// Len of slice.
func (b Bytes) Len() int {
	if b.buf == nil {
		return 0
	}
	return len(b.dat)
}

// Cap of slice.
func (b Bytes) Cap() int {
	if b.buf == nil {
		return 0
	}
	return cap(b.dat)
}

// Bytes is the inner value.
func (b Bytes) Bytes() []byte {
	return b.dat
}

// Ref please refer to Item.Ref().
func (b Bytes) Ref() (rb Bytes) {
	if b.buf == nil {
		return
	}
	rb.buf = b.buf.Ref()
	rb.dat = b.dat
	return
}

// Copy please refer to Item.Copy().
func (b Bytes) Copy() (cb Bytes) {
	if b.buf == nil {
		return
	}
	cb.buf = b.buf.Copy()
	cb.dat = b.dat
	return
}

// SliceFrom dat[from:] with Ref.
func (b Bytes) SliceFrom(from int) Bytes {
	nb := b.Ref()
	nb.dat = b.dat[from:]
	return nb
}

// SliceTo dat[:to] with Ref.
func (b Bytes) SliceTo(to int) Bytes {
	nb := b.Ref()
	nb.dat = b.dat[:to]
	return nb
}

// Slice dat[from:to] with Ref.
func (b Bytes) Slice(from, to int) Bytes {
	nb := b.Ref()
	nb.dat = b.dat[from:to]
	return nb
}

// Destroy please refer to Item.Destroy().
func (b Bytes) Destroy() {
	if b.buf != nil {
		b.buf.Destroy()
	}
}