refactor

common/buf/buffered_writer.go

@@ -20,20 +20,20 @@ func NewBufferedWriter(rawWriter io.Writer) *BufferedWriter {
 }
 
 // Write implements io.Writer.
-func (v *BufferedWriter) Write(b []byte) (int, error) {
-	if !v.buffered || v.buffer == nil {
-		return v.writer.Write(b)
+func (w *BufferedWriter) Write(b []byte) (int, error) {
+	if !w.buffered || w.buffer == nil {
+		return w.writer.Write(b)
 	}
-	nBytes, err := v.buffer.Write(b)
+	nBytes, err := w.buffer.Write(b)
 	if err != nil {
 		return 0, err
 	}
-	if v.buffer.IsFull() {
-		if err := v.Flush(); err != nil {
+	if w.buffer.IsFull() {
+		if err := w.Flush(); err != nil {
 			return 0, err
 		}
 		if nBytes < len(b) {
-			if _, err := v.writer.Write(b[nBytes:]); err != nil {
+			if _, err := w.writer.Write(b[nBytes:]); err != nil {
 				return nBytes, err
 			}
 		}
@@ -42,28 +42,28 @@ func (v *BufferedWriter) Write(b []byte) (int, error) {
 }
 
 // Flush writes all buffered content into underlying writer, if any.
-func (v *BufferedWriter) Flush() error {
-	defer v.buffer.Clear()
-	for !v.buffer.IsEmpty() {
-		nBytes, err := v.writer.Write(v.buffer.Bytes())
+func (w *BufferedWriter) Flush() error {
+	defer w.buffer.Clear()
+	for !w.buffer.IsEmpty() {
+		nBytes, err := w.writer.Write(w.buffer.Bytes())
 		if err != nil {
 			return err
 		}
-		v.buffer.SliceFrom(nBytes)
+		w.buffer.SliceFrom(nBytes)
 	}
 	return nil
 }
 
 // IsBuffered returns true if this BufferedWriter holds a buffer.
-func (v *BufferedWriter) IsBuffered() bool {
-	return v.buffered
+func (w *BufferedWriter) IsBuffered() bool {
+	return w.buffered
 }
 
 // SetBuffered controls whether the BufferedWriter holds a buffer for writing. If not buffered, any write() calls into underlying writer directly.
-func (v *BufferedWriter) SetBuffered(cached bool) error {
-	v.buffered = cached
-	if !cached && !v.buffer.IsEmpty() {
-		return v.Flush()
+func (w *BufferedWriter) SetBuffered(cached bool) error {
+	w.buffered = cached
+	if !cached && !w.buffer.IsEmpty() {
+		return w.Flush()
 	}
 	return nil
 }

common/buf/multi_buffer.go

@@ -10,22 +10,25 @@ type MultiBufferReader interface {
 	ReadMultiBuffer() (MultiBuffer, error)
 }
 
+// MultiBuffer is a list of Buffers. The order of Buffer matters.
 type MultiBuffer []*Buffer
 
+// NewMultiBuffer creates a new MultiBuffer instance.
 func NewMultiBuffer() MultiBuffer {
 	return MultiBuffer(make([]*Buffer, 0, 128))
 }
 
+// NewMultiBufferValue wraps a list of Buffers into MultiBuffer.
 func NewMultiBufferValue(b ...*Buffer) MultiBuffer {
 	return MultiBuffer(b)
 }
 
-func (b *MultiBuffer) Append(buf *Buffer) {
-	*b = append(*b, buf)
+func (mb *MultiBuffer) Append(buf *Buffer) {
+	*mb = append(*mb, buf)
 }
 
-func (b *MultiBuffer) AppendMulti(mb MultiBuffer) {
-	*b = append(*b, mb...)
+func (mb *MultiBuffer) AppendMulti(buf MultiBuffer) {
+	*mb = append(*mb, buf...)
 }
 
 func (mb *MultiBuffer) Read(b []byte) (int, error) {
@@ -46,6 +49,7 @@ func (mb *MultiBuffer) Read(b []byte) (int, error) {
 	return totalBytes, nil
 }
 
+// Len returns the total number of bytes in the MultiBuffer.
 func (mb MultiBuffer) Len() int {
 	size := 0
 	for _, b := range mb {
@@ -54,6 +58,7 @@ func (mb MultiBuffer) Len() int {
 	return size
 }
 
+// IsEmpty return true if the MultiBuffer has no content.
 func (mb MultiBuffer) IsEmpty() bool {
 	for _, b := range mb {
 		if !b.IsEmpty() {
@@ -63,6 +68,7 @@ func (mb MultiBuffer) IsEmpty() bool {
 	return true
 }
 
+// Release releases all Buffers in the MultiBuffer.
 func (mb MultiBuffer) Release() {
 	for i, b := range mb {
 		b.Release()
@@ -70,6 +76,7 @@ func (mb MultiBuffer) Release() {
 	}
 }
 
+// ToNetBuffers converts this MultiBuffer to net.Buffers. The return net.Buffers points to the same content of the MultiBuffer.
 func (mb MultiBuffer) ToNetBuffers() net.Buffers {
 	bs := make([][]byte, len(mb))
 	for i, b := range mb {