refine buffer usage

common/alloc/buffer.go

@@ -117,11 +117,39 @@ func (b *Buffer) PrependHash(h hash.Hash) *Buffer {
 	return b
 }
 
+func (b *Buffer) Byte(index int) byte {
+	return b.Value[index]
+}
+
 // Bytes returns the content bytes of this Buffer.
 func (b *Buffer) Bytes() []byte {
 	return b.Value
 }
 
+func (b *Buffer) BytesRange(from, to int) []byte {
+	if from < 0 {
+		from += len(b.Value)
+	}
+	if to < 0 {
+		to += len(b.Value)
+	}
+	return b.Value[from:to]
+}
+
+func (b *Buffer) BytesFrom(from int) []byte {
+	if from < 0 {
+		from += len(b.Value)
+	}
+	return b.Value[from:]
+}
+
+func (b *Buffer) BytesTo(to int) []byte {
+	if to < 0 {
+		to += len(b.Value)
+	}
+	return b.Value[:to]
+}
+
 // Slice cuts the buffer at the given position.
 func (b *Buffer) Slice(from, to int) *Buffer {
 	b.offset += from

common/alloc/buffer_test.go

@@ -43,10 +43,10 @@ func TestBufferPrepend(t *testing.T) {
 	buffer.Prepend([]byte{'x', 'y', 'z'})
 
 	assert.Int(buffer.Len()).Equals(6)
-	assert.Bytes(buffer.Value).Equals([]byte("xyzabc"))
+	assert.String(buffer.String()).Equals("xyzabc")
 
 	buffer.Prepend([]byte{'u', 'v', 'w'})
-	assert.Bytes(buffer.Value).Equals([]byte("uvwxyzabc"))
+	assert.String(buffer.String()).Equals("uvwxyzabc")
 }
 
 func TestBufferString(t *testing.T) {

common/io/buffered_writer.go

@@ -87,7 +87,7 @@ func (v *BufferedWriter) Flush() error {
 func (v *BufferedWriter) FlushWithoutLock() error {
 	defer v.buffer.Clear()
 	for !v.buffer.IsEmpty() {
-		nBytes, err := v.writer.Write(v.buffer.Value)
+		nBytes, err := v.writer.Write(v.buffer.Bytes())
 		if err != nil {
 			return err
 		}

common/io/buffered_writer_test.go

@@ -49,5 +49,5 @@ func TestBufferedWriterLargePayload(t *testing.T) {
 	nBytes, err = writer.Write(payload[1024:])
 	assert.Error(err).IsNil()
 	assert.Int(nBytes).Equals(63 * 1024)
-	assert.Bytes(content.Value).Equals(payload)
+	assert.Bytes(content.Bytes()).Equals(payload)
 }

common/io/writer.go

@@ -30,7 +30,7 @@ func NewAdaptiveWriter(writer io.Writer) *AdaptiveWriter {
 func (v *AdaptiveWriter) Write(buffer *alloc.Buffer) error {
 	defer buffer.Release()
 	for !buffer.IsEmpty() {
-		nBytes, err := v.writer.Write(buffer.Value)
+		nBytes, err := v.writer.Write(buffer.Bytes())
 		if err != nil {
 			return err
 		}

common/io/writer_test.go

@@ -13,8 +13,8 @@ import (
 func TestAdaptiveWriter(t *testing.T) {
 	assert := assert.On(t)
 
-	lb := alloc.NewBuffer()
-	rand.Read(lb.Value)
+	lb := alloc.NewBuffer().Clear()
+	lb.FillFrom(rand.Reader)
 
 	writeBuffer := make([]byte, 0, 1024*1024)