Update stream ext encoder interface

codecov.yml

@@ -0,0 +1,4 @@
+coverage:
+  status:
+    project: off
+    patch: off

ext/decoder_stream.go

@@ -1,60 +1,11 @@
 package ext
 
 import (
-	"github.com/shamaton/msgpack/v2/internal/common"
-	"io"
 	"reflect"
 )
 
-var emptyBytes []byte
-
 type StreamDecoder interface {
 	Code() int8
 	IsType(code byte, innerType int8, dataLength int) bool
 	ToValue(code byte, data []byte, k reflect.Kind) (any, error)
 }
-
-type DecoderStreamCommon struct {
-}
-
-func (d *DecoderStreamCommon) ReadSize1(r io.Reader, buf *common.Buffer) (byte, error) {
-	if _, err := r.Read(buf.B1); err != nil {
-		return 0, err
-	}
-	return buf.B1[0], nil
-}
-
-func (d *DecoderStreamCommon) ReadSize2(r io.Reader, buf *common.Buffer) ([]byte, error) {
-	if _, err := r.Read(buf.B2); err != nil {
-		return emptyBytes, err
-	}
-	return buf.B2, nil
-}
-
-func (d *DecoderStreamCommon) ReadSize4(r io.Reader, buf *common.Buffer) ([]byte, error) {
-	if _, err := r.Read(buf.B4); err != nil {
-		return emptyBytes, err
-	}
-	return buf.B4, nil
-}
-
-func (d *DecoderStreamCommon) ReadSize8(r io.Reader, buf *common.Buffer) ([]byte, error) {
-	if _, err := r.Read(buf.B8); err != nil {
-		return emptyBytes, err
-	}
-	return buf.B8, nil
-}
-
-func (d *DecoderStreamCommon) ReadSizeN(r io.Reader, buf *common.Buffer, n int) ([]byte, error) {
-	var b []byte
-	if len(buf.Data) <= n {
-		b = buf.Data[:n]
-	} else {
-		buf.Data = append(buf.Data, make([]byte, n-len(buf.Data))...)
-		b = buf.Data
-	}
-	if _, err := r.Read(b); err != nil {
-		return emptyBytes, err
-	}
-	return b, nil
-}

ext/encode_stream.go

@@ -1,43 +1,53 @@
 package ext
 
 import (
-	"github.com/shamaton/msgpack/v2/internal/common"
 	"io"
 	"reflect"
+
+	"github.com/shamaton/msgpack/v2/internal/common"
 )
 
+// StreamEncoder is interface that extended encoder should implement
 type StreamEncoder interface {
 	Code() int8
 	Type() reflect.Type
-	Write(w io.Writer, value reflect.Value, buf *common.Buffer) error
+	Write(w StreamWriter, value reflect.Value) error
 }
 
-type StreamEncoderCommon struct{}
+// StreamWriter is provided some writing functions for extended format by user
+type StreamWriter struct {
+	w   io.Writer
+	buf *common.Buffer
+}
+
+func CreateStreamWriter(w io.Writer, buf *common.Buffer) StreamWriter {
+	return StreamWriter{w, buf}
+}
 
-func (c *StreamEncoderCommon) WriteByte1Int64(w io.Writer, value int64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte1Int64(value int64) error {
+	return w.buf.Write(w.w,
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte2Int64(w io.Writer, value int64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte2Int64(value int64) error {
+	return w.buf.Write(w.w,
 		byte(value>>8),
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte4Int64(w io.Writer, value int64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte4Int64(value int64) error {
+	return w.buf.Write(w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte8Int64(w io.Writer, value int64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte8Int64(value int64) error {
+	return w.buf.Write(w.w,
 		byte(value>>56),
 		byte(value>>48),
 		byte(value>>40),
@@ -49,30 +59,30 @@ func (c *StreamEncoderCommon) WriteByte8Int64(w io.Writer, value int64, buf *com
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte1Uint64(w io.Writer, value uint64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte1Uint64(value uint64) error {
+	return w.buf.Write(w.w,
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte2Uint64(w io.Writer, value uint64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte2Uint64(value uint64) error {
+	return w.buf.Write(w.w,
 		byte(value>>8),
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte4Uint64(w io.Writer, value uint64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte4Uint64(value uint64) error {
+	return w.buf.Write(w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte8Uint64(w io.Writer, value uint64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte8Uint64(value uint64) error {
+	return w.buf.Write(w.w,
 		byte(value>>56),
 		byte(value>>48),
 		byte(value>>40),
@@ -84,37 +94,37 @@ func (c *StreamEncoderCommon) WriteByte8Uint64(w io.Writer, value uint64, buf *c
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte1Int(w io.Writer, value int, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte1Int(value int) error {
+	return w.buf.Write(w.w,
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte2Int(w io.Writer, value int, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte2Int(value int) error {
+	return w.buf.Write(w.w,
 		byte(value>>8),
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte4Int(w io.Writer, value int, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte4Int(value int) error {
+	return w.buf.Write(w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte4Uint32(w io.Writer, value uint32, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte4Uint32(value uint32) error {
+	return w.buf.Write(w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteBytes(w io.Writer, bs []byte, buf *common.Buffer) error {
-	return buf.Write(w, bs...)
+func (w *StreamWriter) WriteBytes(bs []byte) error {
+	return w.buf.Write(w.w, bs...)
 }

internal/stream/encoding/struct.go

@@ -6,6 +6,7 @@ import (
 	"sync"
 
 	"github.com/shamaton/msgpack/v2/def"
+	"github.com/shamaton/msgpack/v2/ext"
 	"github.com/shamaton/msgpack/v2/internal/common"
 )
 
@@ -24,7 +25,8 @@ func (e *encoder) getStructWriter(typ reflect.Type) structWriteFunc {
 	for i := range extCoders {
 		if extCoders[i].Type() == typ {
 			return func(rv reflect.Value) error {
-				return extCoders[i].Write(e.w, rv, e.buf)
+				w := ext.CreateStreamWriter(e.w, e.buf)
+				return extCoders[i].Write(w, rv)
 			}
 		}
 	}
@@ -39,7 +41,8 @@ func (e *encoder) writeStruct(rv reflect.Value) error {
 
 	for i := range extCoders {
 		if extCoders[i].Type() == rv.Type() {
-			return extCoders[i].Write(e.w, rv, e.buf)
+			w := ext.CreateStreamWriter(e.w, e.buf)
+			return extCoders[i].Write(w, rv)
 		}
 	}
 

msgpack_test.go

@@ -6,7 +6,6 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"io"
 	"math"
 	"math/rand"
 	"reflect"
@@ -17,7 +16,6 @@ import (
 	"github.com/shamaton/msgpack/v2"
 	"github.com/shamaton/msgpack/v2/def"
 	"github.com/shamaton/msgpack/v2/ext"
-	"github.com/shamaton/msgpack/v2/internal/common"
 	extTime "github.com/shamaton/msgpack/v2/time"
 )
 
@@ -2060,9 +2058,7 @@ func (td *testDecoder) AsValue(offset int, k reflect.Kind, d *[]byte) (interface
 
 var streamDecoder = new(testStreamDecoder)
 
-type testStreamDecoder struct {
-	ext.DecoderStreamCommon
-}
+type testStreamDecoder struct{}
 
 var _ ext.StreamDecoder = (*testStreamDecoder)(nil)
 
@@ -2158,9 +2154,7 @@ func (s *testEncoder) WriteToBytes(value reflect.Value, offset int, bytes *[]byt
 
 var streamEncoder = new(testStreamEncoder)
 
-type testStreamEncoder struct {
-	ext.StreamEncoderCommon
-}
+type testStreamEncoder struct{}
 
 var _ ext.StreamEncoder = (*testStreamEncoder)(nil)
 
@@ -2172,55 +2166,55 @@ func (s *testStreamEncoder) Type() reflect.Type {
 	return reflect.TypeOf(ExtInt{})
 }
 
-func (s *testStreamEncoder) Write(w io.Writer, value reflect.Value, buf *common.Buffer) error {
+func (s *testStreamEncoder) Write(w ext.StreamWriter, value reflect.Value) error {
 	t := value.Interface().(ExtInt)
-	if err := s.WriteByte1Int(w, def.Ext8, buf); err != nil {
+	if err := w.WriteByte1Int(def.Ext8); err != nil {
 		return err
 	}
-	if err := s.WriteByte1Int(w, 15+15+10+len(t.Bytes), buf); err != nil {
+	if err := w.WriteByte1Int(15 + 15 + 10 + len(t.Bytes)); err != nil {
 		return err
 	}
-	if err := s.WriteByte1Int(w, int(s.Code()), buf); err != nil {
+	if err := w.WriteByte1Int(int(s.Code())); err != nil {
 		return err
 	}
 
-	if err := s.WriteByte1Int64(w, int64(t.Int8), buf); err != nil {
+	if err := w.WriteByte1Int64(int64(t.Int8)); err != nil {
 		return err
 	}
-	if err := s.WriteByte2Int64(w, int64(t.Int16), buf); err != nil {
+	if err := w.WriteByte2Int64(int64(t.Int16)); err != nil {
 		return err
 	}
-	if err := s.WriteByte4Int64(w, int64(t.Int32), buf); err != nil {
+	if err := w.WriteByte4Int64(int64(t.Int32)); err != nil {
 		return err
 	}
-	if err := s.WriteByte8Int64(w, t.Int64, buf); err != nil {
+	if err := w.WriteByte8Int64(t.Int64); err != nil {
 		return err
 	}
 
-	if err := s.WriteByte1Uint64(w, uint64(t.Uint8), buf); err != nil {
+	if err := w.WriteByte1Uint64(uint64(t.Uint8)); err != nil {
 		return err
 	}
-	if err := s.WriteByte2Uint64(w, uint64(t.Uint16), buf); err != nil {
+	if err := w.WriteByte2Uint64(uint64(t.Uint16)); err != nil {
 		return err
 	}
-	if err := s.WriteByte4Uint64(w, uint64(t.Uint32), buf); err != nil {
+	if err := w.WriteByte4Uint64(uint64(t.Uint32)); err != nil {
 		return err
 	}
-	if err := s.WriteByte8Uint64(w, t.Uint64, buf); err != nil {
+	if err := w.WriteByte8Uint64(t.Uint64); err != nil {
 		return err
 	}
 
-	if err := s.WriteByte2Int(w, t.Byte2Int, buf); err != nil {
+	if err := w.WriteByte2Int(t.Byte2Int); err != nil {
 		return err
 	}
-	if err := s.WriteByte4Int(w, t.Byte4Int, buf); err != nil {
+	if err := w.WriteByte4Int(t.Byte4Int); err != nil {
 		return err
 	}
 
-	if err := s.WriteByte4Uint32(w, t.Byte4Uint32, buf); err != nil {
+	if err := w.WriteByte4Uint32(t.Byte4Uint32); err != nil {
 		return err
 	}
-	if err := s.WriteBytes(w, t.Bytes, buf); err != nil {
+	if err := w.WriteBytes(t.Bytes); err != nil {
 		return err
 	}
 	return nil
@@ -2304,7 +2298,7 @@ func (s *testExt2StreamEncoder) Type() reflect.Type {
 	return reflect.TypeOf(ExtInt{})
 }
 
-func (s *testExt2StreamEncoder) Write(_ io.Writer, _ reflect.Value, _ *common.Buffer) error {
+func (s *testExt2StreamEncoder) Write(_ ext.StreamWriter, _ reflect.Value) error {
 	return fmt.Errorf("should not reach this line!! code %x", s.Code())
 }