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.