rewrite alloc.buffer

common/alloc/buffer.go

@@ -2,32 +2,32 @@
 package alloc
 
 import (
-	"hash"
 	"io"
-
-	"v2ray.com/core/common/serial"
 )
 
 const (
 	defaultOffset = 16
 )
 
+type BytesWriter func([]byte) int
+
 // 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   Pool
-	Value  []byte
-	offset int
+	head []byte
+	pool Pool
+
+	start int
+	end   int
 }
 
 func CreateBuffer(container []byte, parent Pool) *Buffer {
 	b := new(Buffer)
 	b.head = container
 	b.pool = parent
-	b.Value = b.head[defaultOffset:]
-	b.offset = defaultOffset
+	b.start = defaultOffset
+	b.end = defaultOffset
 	return b
 }
 
@@ -40,140 +40,117 @@ func (b *Buffer) Release() {
 		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
+func (b *Buffer) Clear() {
+	b.start = defaultOffset
+	b.end = defaultOffset
 }
 
 // Reset resets this Buffer into its original state.
-func (b *Buffer) Reset() *Buffer {
-	b.offset = defaultOffset
-	b.Value = b.head[b.offset:]
-	return b
+func (b *Buffer) Reset() {
+	b.start = defaultOffset
+	b.end = len(b.head)
 }
 
 // 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
+func (b *Buffer) AppendBytes(bytes ...byte) {
+	b.Append(bytes)
 }
 
 // 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) Append(data []byte) {
+	nBytes := copy(b.head[b.end:], data)
+	b.end += nBytes
 }
 
-// AppendString appends a given string to the end of the buffer.
-func (b *Buffer) AppendString(s string) *Buffer {
-	b.Value = append(b.Value, s...)
-	return b
-}
-
-func (b *Buffer) AppendUint16(val uint16) *Buffer {
-	b.Value = serial.Uint16ToBytes(val, b.Value)
-	return b
-}
-
-func (b *Buffer) AppendUint32(val uint32) *Buffer {
-	b.Value = serial.Uint32ToBytes(val, b.Value)
-	return b
+func (b *Buffer) AppendFunc(writer BytesWriter) {
+	nBytes := writer(b.head[b.end:])
+	b.end += nBytes
 }
 
 // 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 {
+func (b *Buffer) Prepend(data []byte) {
 	b.SliceBack(len(data))
-	copy(b.Value, data)
-	return b
+	copy(b.head[b.start:], data)
 }
 
-func (b *Buffer) PrependBytes(data ...byte) *Buffer {
-	return b.Prepend(data)
+func (b *Buffer) PrependBytes(data ...byte) {
+	b.Prepend(data)
 }
 
-func (b *Buffer) PrependUint16(val uint16) *Buffer {
-	b.SliceBack(2)
-	serial.Uint16ToBytes(val, b.Value[:0])
-	return b
-}
-
-func (b *Buffer) PrependUint32(val uint32) *Buffer {
-	b.SliceBack(4)
-	serial.Uint32ToBytes(val, b.Value[:0])
-	return b
-}
-
-func (b *Buffer) PrependHash(h hash.Hash) *Buffer {
-	b.SliceBack(h.Size())
-	h.Sum(b.Value[:0])
-	return b
+func (b *Buffer) PrependFunc(offset int, writer BytesWriter) {
+	b.SliceBack(offset)
+	writer(b.head[b.start:])
 }
 
 func (b *Buffer) Byte(index int) byte {
-	return b.Value[index]
+	return b.head[b.start+index]
 }
 
 // Bytes returns the content bytes of this Buffer.
 func (b *Buffer) Bytes() []byte {
-	return b.Value
+	return b.head[b.start:b.end]
 }
 
 func (b *Buffer) BytesRange(from, to int) []byte {
 	if from < 0 {
-		from += len(b.Value)
+		from += b.Len()
 	}
 	if to < 0 {
-		to += len(b.Value)
+		to += b.Len()
 	}
-	return b.Value[from:to]
+	return b.head[b.start+from : b.start+to]
 }
 
 func (b *Buffer) BytesFrom(from int) []byte {
 	if from < 0 {
-		from += len(b.Value)
+		from += b.Len()
 	}
-	return b.Value[from:]
+	return b.head[b.start+from : b.end]
 }
 
 func (b *Buffer) BytesTo(to int) []byte {
 	if to < 0 {
-		to += len(b.Value)
+		to += b.Len()
 	}
-	return b.Value[:to]
+	return b.head[b.start : b.start+to]
 }
 
 // Slice cuts the buffer at the given position.
-func (b *Buffer) Slice(from, to int) *Buffer {
-	b.offset += from
-	b.Value = b.Value[from:to]
-	return b
+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
 }
 
 // SliceFrom cuts the buffer at the given position.
-func (b *Buffer) SliceFrom(from int) *Buffer {
-	b.offset += from
-	b.Value = b.Value[from:]
-	return b
+func (b *Buffer) SliceFrom(from int) {
+	if from < 0 {
+		from += b.Len()
+	}
+	b.start += from
 }
 
 // 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 {
+func (b *Buffer) SliceBack(offset int) {
+	b.start -= offset
+	if b.start < 0 {
 		panic("Negative buffer offset.")
 	}
-	b.Value = b.head[newoffset : b.offset+len(b.Value)]
-	b.offset = newoffset
-	return b
 }
 
 // Len returns the length of the buffer content.
@@ -181,7 +158,7 @@ func (b *Buffer) Len() int {
 	if b == nil {
 		return 0
 	}
-	return len(b.Value)
+	return b.end - b.start
 }
 
 func (b *Buffer) IsEmpty() bool {
@@ -190,15 +167,13 @@ func (b *Buffer) IsEmpty() bool {
 
 // IsFull returns true if the buffer has no more room to grow.
 func (b *Buffer) IsFull() bool {
-	return len(b.Value) == cap(b.Value)
+	return b.end == len(b.head)
 }
 
 // Write implements Write method in io.Writer.
 func (b *Buffer) Write(data []byte) (int, error) {
-	begin := b.Len()
-	b.Value = b.Value[:cap(b.Value)]
-	nBytes := copy(b.Value[begin:], data)
-	b.Value = b.Value[:begin+nBytes]
+	nBytes := copy(b.head[b.end:], data)
+	b.end += nBytes
 	return nBytes, nil
 }
 
@@ -207,32 +182,29 @@ func (b *Buffer) Read(data []byte) (int, error) {
 	if b.Len() == 0 {
 		return 0, io.EOF
 	}
-	nBytes := copy(data, b.Value)
+	nBytes := copy(data, b.head[b.start:b.end])
 	if nBytes == b.Len() {
 		b.Clear()
 	} else {
-		b.Value = b.Value[nBytes:]
-		b.offset += nBytes
+		b.start += nBytes
 	}
 	return nBytes, nil
 }
 
 func (b *Buffer) FillFrom(reader io.Reader) (int, error) {
-	begin := b.Len()
-	nBytes, err := reader.Read(b.head[b.offset+begin:])
-	b.Value = b.head[b.offset : b.offset+begin+nBytes]
+	nBytes, err := reader.Read(b.head[b.end:])
+	b.end += nBytes
 	return nBytes, err
 }
 
 func (b *Buffer) FillFullFrom(reader io.Reader, amount int) (int, error) {
-	begin := b.Len()
-	nBytes, err := io.ReadFull(reader, b.head[b.offset+begin:b.offset+begin+amount])
-	b.Value = b.head[b.offset : b.offset+begin+nBytes]
+	nBytes, err := io.ReadFull(reader, b.head[b.end:b.end+amount])
+	b.end += nBytes
 	return nBytes, err
 }
 
 func (b *Buffer) String() string {
-	return string(b.Value)
+	return string(b.head[b.start:b.end])
 }
 
 // NewBuffer creates a Buffer with 8K bytes of arbitrary content.

common/alloc/buffer_test.go

@@ -4,13 +4,14 @@ import (
 	"testing"
 
 	. "v2ray.com/core/common/alloc"
+	"v2ray.com/core/common/serial"
 	"v2ray.com/core/testing/assert"
 )
 
 func TestBufferClear(t *testing.T) {
 	assert := assert.On(t)
 
-	buffer := NewBuffer().Clear()
+	buffer := NewBuffer()
 	defer buffer.Release()
 
 	payload := "Bytes"
@@ -21,22 +22,19 @@ func TestBufferClear(t *testing.T) {
 	assert.Int(buffer.Len()).Equals(0)
 }
 
-func TestBufferIsFull(t *testing.T) {
+func TestBufferIsEmpty(t *testing.T) {
 	assert := assert.On(t)
 
 	buffer := NewBuffer()
 	defer buffer.Release()
 
-	assert.Bool(buffer.IsFull()).IsTrue()
-
-	buffer.Clear()
-	assert.Bool(buffer.IsFull()).IsFalse()
+	assert.Bool(buffer.IsEmpty()).IsTrue()
 }
 
 func TestBufferPrepend(t *testing.T) {
 	assert := assert.On(t)
 
-	buffer := NewBuffer().Clear()
+	buffer := NewBuffer()
 	defer buffer.Release()
 
 	buffer.Append([]byte{'a', 'b', 'c'})
@@ -52,17 +50,17 @@ func TestBufferPrepend(t *testing.T) {
 func TestBufferString(t *testing.T) {
 	assert := assert.On(t)
 
-	buffer := NewBuffer().Clear()
+	buffer := NewBuffer()
 	defer buffer.Release()
 
-	buffer.AppendString("Test String")
+	buffer.AppendFunc(serial.WriteString("Test String"))
 	assert.String(buffer.String()).Equals("Test String")
 }
 
 func TestBufferWrite(t *testing.T) {
 	assert := assert.On(t)
 
-	buffer := NewLocalBuffer(24).Clear() // 16 + 8
+	buffer := NewLocalBuffer(24) // 16 + 8
 	nBytes, err := buffer.Write([]byte("abcd"))
 	assert.Error(err).IsNil()
 	assert.Int(nBytes).Equals(4)

common/io/buffered_reader.go

@@ -17,7 +17,7 @@ type BufferedReader struct {
 func NewBufferedReader(rawReader io.Reader) *BufferedReader {
 	return &BufferedReader{
 		reader: rawReader,
-		buffer: alloc.NewBuffer().Clear(),
+		buffer: alloc.NewBuffer(),
 		cached: true,
 	}
 }

common/io/buffered_reader_test.go

@@ -3,6 +3,7 @@ package io_test
 import (
 	"testing"
 
+	"crypto/rand"
 	"v2ray.com/core/common/alloc"
 	. "v2ray.com/core/common/io"
 	"v2ray.com/core/testing/assert"
@@ -12,6 +13,8 @@ func TestBufferedReader(t *testing.T) {
 	assert := assert.On(t)
 
 	content := alloc.NewBuffer()
+	content.FillFrom(rand.Reader)
+
 	len := content.Len()
 
 	reader := NewBufferedReader(content)

common/io/buffered_writer.go

@@ -17,7 +17,7 @@ type BufferedWriter struct {
 func NewBufferedWriter(rawWriter io.Writer) *BufferedWriter {
 	return &BufferedWriter{
 		writer: rawWriter,
-		buffer: alloc.NewSmallBuffer().Clear(),
+		buffer: alloc.NewSmallBuffer(),
 		cached: true,
 	}
 }

common/io/buffered_writer_test.go

@@ -12,7 +12,7 @@ import (
 func TestBufferedWriter(t *testing.T) {
 	assert := assert.On(t)
 
-	content := alloc.NewBuffer().Clear()
+	content := alloc.NewBuffer()
 
 	writer := NewBufferedWriter(content)
 	assert.Bool(writer.Cached()).IsTrue()
@@ -32,7 +32,7 @@ func TestBufferedWriter(t *testing.T) {
 func TestBufferedWriterLargePayload(t *testing.T) {
 	assert := assert.On(t)
 
-	content := alloc.NewLocalBuffer(128 * 1024).Clear()
+	content := alloc.NewLocalBuffer(128 * 1024)
 
 	writer := NewBufferedWriter(content)
 	assert.Bool(writer.Cached()).IsTrue()

common/io/chain_writer.go

@@ -28,7 +28,7 @@ func (v *ChainWriter) Write(payload []byte) (int, error) {
 	bytesWritten := 0
 	size := len(payload)
 	for size > 0 {
-		buffer := alloc.NewBuffer().Clear()
+		buffer := alloc.NewBuffer()
 		if size > alloc.BufferSize {
 			buffer.Append(payload[:alloc.BufferSize])
 			size -= alloc.BufferSize

common/io/reader.go

@@ -33,7 +33,7 @@ func NewAdaptiveReader(reader io.Reader) *AdaptiveReader {
 func (v *AdaptiveReader) Read() (*alloc.Buffer, error) {
 	if v.highVolumn && v.largeBuffer.IsEmpty() {
 		if v.largeBuffer == nil {
-			v.largeBuffer = alloc.NewLocalBuffer(256 * 1024).Clear()
+			v.largeBuffer = alloc.NewLocalBuffer(256 * 1024)
 		}
 		nBytes, err := v.largeBuffer.FillFrom(v.reader)
 		if err != nil {
@@ -44,7 +44,7 @@ func (v *AdaptiveReader) Read() (*alloc.Buffer, error) {
 		}
 	}
 
-	buffer := alloc.NewBuffer().Clear()
+	buffer := alloc.NewBuffer()
 	if !v.largeBuffer.IsEmpty() {
 		buffer.FillFrom(v.largeBuffer)
 		return buffer, nil

common/io/writer_test.go

@@ -13,13 +13,15 @@ import (
 func TestAdaptiveWriter(t *testing.T) {
 	assert := assert.On(t)
 
-	lb := alloc.NewBuffer().Clear()
+	lb := alloc.NewBuffer()
 	lb.FillFrom(rand.Reader)
 
-	writeBuffer := make([]byte, 0, 1024*1024)
+	expectedBytes := append([]byte(nil), lb.Bytes()...)
 
-	writer := NewAdaptiveWriter(NewBufferedWriter(bytes.NewBuffer(writeBuffer)))
+	writeBuffer := bytes.NewBuffer(make([]byte, 0, 1024*1024))
+
+	writer := NewAdaptiveWriter(NewBufferedWriter(writeBuffer))
 	err := writer.Write(lb)
 	assert.Error(err).IsNil()
-	assert.Bytes(lb.Bytes()).Equals(writeBuffer)
+	assert.Bytes(expectedBytes).Equals(writeBuffer.Bytes())
 }

common/serial/hash.go

@@ -0,0 +1,13 @@
+package serial
+
+import (
+	"hash"
+	"v2ray.com/core/common/alloc"
+)
+
+func WriteHash(h hash.Hash) alloc.BytesWriter {
+	return func(b []byte) int {
+		h.Sum(b[:0])
+		return h.Size()
+	}
+}

common/serial/numbers.go

@@ -2,6 +2,7 @@ package serial
 
 import (
 	"strconv"
+	"v2ray.com/core/common/alloc"
 )
 
 func Uint16ToBytes(value uint16, b []byte) []byte {
@@ -12,6 +13,13 @@ func Uint16ToString(value uint16) string {
 	return strconv.Itoa(int(value))
 }
 
+func WriteUint16(value uint16) alloc.BytesWriter {
+	return func(b []byte) int {
+		b = Uint16ToBytes(value, b[:0])
+		return 2
+	}
+}
+
 func Uint32ToBytes(value uint32, b []byte) []byte {
 	return append(b, byte(value>>24), byte(value>>16), byte(value>>8), byte(value))
 }
@@ -20,6 +28,13 @@ func Uint32ToString(value uint32) string {
 	return strconv.FormatUint(uint64(value), 10)
 }
 
+func WriteUint32(value uint32) alloc.BytesWriter {
+	return func(b []byte) int {
+		b = Uint32ToBytes(value, b[:0])
+		return 4
+	}
+}
+
 func IntToBytes(value int, b []byte) []byte {
 	return append(b, byte(value>>24), byte(value>>16), byte(value>>8), byte(value))
 }

common/serial/string.go

@@ -3,6 +3,7 @@ package serial
 import (
 	"fmt"
 	"strings"
+	"v2ray.com/core/common/alloc"
 )
 
 func ToString(v interface{}) string {
@@ -33,3 +34,10 @@ func Concat(v ...interface{}) string {
 	}
 	return strings.Join(values, "")
 }
+
+func WriteString(s string) alloc.BytesWriter {
+	return func(b []byte) int {
+		copy(b, []byte(s))
+		return len(s)
+	}
+}