refactor(*): Refactoring ProtoCodec (#48)

- Merging Unmarshal
- Removing interface methods that are not used externally
- Adding control over Inform
- NewCodec switch to streamingCodec implementation
close #47

Author: chenjunbiao

pkg/codes/proto.go

@@ -18,21 +18,15 @@ type ProtoCodec interface {
 
 	// UnmarshalStruct: Unmarshal struct to interface
 	UnmarshalStruct(data []byte, mold interface{}) error
-	// UnmarshalStructNative: Unmarshal struct to interface by native data, No Outside Nodes
-	UnmarshalStructNative(data []byte, mold interface{}) error
 
 	// UnmarshalBasic: Unmarshal basic type to interface
 	UnmarshalBasic(data []byte, mold *interface{}) error
-	// UnmarshalBasicNative: Unmarshal basic type to interface by native data, No Outside Nodes
-	UnmarshalBasicNative(data []byte, mold *interface{}) error
 
-	// IsStruct: mold is Struct?
-	IsStruct(mold interface{}) bool
+	// UnmarshalStruct: Unmarshal []byte to interface
+	Unmarshal(data []byte, moldInfo *MoldInfo) error
 
-	// @deprecated
-	UnmarshalStructByNodePacket(node *y3.NodePacket, mold interface{}) error
-	// @deprecated
-	UnmarshalBasicByNodePacket(node *y3.NodePacket, mold *interface{}) error
+	// UnmarshalByNodePacket: Unmarshal NodePacket to interface
+	UnmarshalByNodePacket(node *y3.NodePacket, moldInfo *MoldInfo) error
 }
 
 // protoCodec: Implementation of the ProtoCodec Interface
@@ -50,16 +44,21 @@ func NewProtoCodec(observe byte) ProtoCodec {
 	}
 }
 
+// hold the model data
+type MoldInfo struct {
+	Mold interface{}
+}
+
 func (c *protoCodec) Marshal(input interface{}) ([]byte, error) {
-	if c.IsStruct(input) {
+	if c.isStruct(input) {
 		return packetstructure.EncodeToBytesWith(c.Observe, input)
 	}
 	//return marshalBasicNative(c.Observe, input)
 	return encodeBasic(c.Observe, input)
 }
 
 func (c *protoCodec) MarshalNative(input interface{}) ([]byte, error) {
-	if c.IsStruct(input) {
+	if c.isStruct(input) {
 		np, err := packetstructure.Encode(input)
 		if err != nil {
 			return nil, err
@@ -73,19 +72,19 @@ func (c *protoCodec) UnmarshalStruct(data []byte, mold interface{}) error {
 	return c.structDecoder.Unmarshal(data, mold)
 }
 
-func (c *protoCodec) UnmarshalStructNative(data []byte, mold interface{}) error {
+func (c *protoCodec) unmarshalStructNative(data []byte, mold interface{}) error {
 	return c.structDecoder.UnmarshalNative(data, mold)
 }
 
 func (c *protoCodec) UnmarshalBasic(data []byte, mold *interface{}) error {
 	return c.basicDecoder.Unmarshal(data, mold)
 }
 
-func (c *protoCodec) UnmarshalBasicNative(data []byte, mold *interface{}) error {
+func (c *protoCodec) unmarshalBasicNative(data []byte, mold *interface{}) error {
 	return c.basicDecoder.UnmarshalNative(data, mold)
 }
 
-func (c *protoCodec) IsStruct(mold interface{}) bool {
+func (c *protoCodec) isStruct(mold interface{}) bool {
 	isStruct := false
 
 	moldValue := reflect.Indirect(reflect.ValueOf(mold))
@@ -102,12 +101,41 @@ func (c *protoCodec) IsStruct(mold interface{}) bool {
 	return isStruct
 }
 
-// @deprecated
-func (c *protoCodec) UnmarshalStructByNodePacket(node *y3.NodePacket, mold interface{}) error {
+func (c *protoCodec) Unmarshal(data []byte, moldInfo *MoldInfo) error {
+	if c.isStruct(moldInfo.Mold) {
+		err := c.unmarshalStructNative(data, moldInfo.Mold)
+		if err != nil {
+			return err
+		}
+
+	} else {
+		err := c.unmarshalBasicNative(data, &moldInfo.Mold)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *protoCodec) unmarshalStructByNodePacket(node *y3.NodePacket, mold interface{}) error {
 	return c.structDecoder.UnmarshalByNodePacket(node, mold)
 }
 
-// @deprecated
-func (c *protoCodec) UnmarshalBasicByNodePacket(node *y3.NodePacket, mold *interface{}) error {
+func (c *protoCodec) unmarshalBasicByNodePacket(node *y3.NodePacket, mold *interface{}) error {
 	return c.basicDecoder.UnmarshalByNodePacket(node, mold)
 }
+
+func (c *protoCodec) UnmarshalByNodePacket(node *y3.NodePacket, moldInfo *MoldInfo) error {
+	if c.isStruct(moldInfo.Mold) {
+		err := c.unmarshalStructByNodePacket(node, moldInfo.Mold)
+		if err != nil {
+			return err
+		}
+	} else {
+		err := c.unmarshalBasicByNodePacket(node, &moldInfo.Mold)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

pkg/codes/yomo.go

@@ -21,11 +21,14 @@ type YomoCodec interface {
 	Refresh(w io.Writer) (int, error)
 }
 
+// NewCodec: create new `YomoCodec`
 func NewCodec(observe string) YomoCodec {
 	//return NewCollectingCodec(observe)
-	return NewMergingCodec(packetutils.KeyOf(observe))
+	//return NewMergingCodec(packetutils.KeyOf(observe))
+	return NewStreamingCodecNoInform(packetutils.KeyOf(observe))
 }
 
+// NewCodec: create new `YomoCodec` with channel inform
 func NewCodecWithInform(observe string) (YomoCodec, <-chan bool) {
 	return NewStreamingCodec(packetutils.KeyOf(observe))
 }

pkg/codes/yomo_collecting.go

@@ -128,18 +128,12 @@ func (codec *collectingCodec) Read(mold interface{}) (interface{}, error) {
 	result := codec.Result[0]
 	codec.Result = codec.Result[1:]
 
-	proto := codec.proto
-	if proto.IsStruct(mold) {
-		err := proto.UnmarshalStructByNodePacket(result, mold)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		err := proto.UnmarshalBasicByNodePacket(result, &mold)
-		if err != nil {
-			return nil, err
-		}
+	info := &MoldInfo{Mold: mold}
+	err := codec.proto.UnmarshalByNodePacket(result, info)
+	if err != nil {
+		return nil, err
 	}
+	mold = info.Mold
 
 	// for Encoder::merge
 	codec.Value = result

pkg/codes/yomo_merging.go

@@ -58,28 +58,6 @@ func NewMergingCodec(observe byte) YomoCodec {
 	return codec
 }
 
-type decoderStatus uint8
-
-const (
-	decoderInit     decoderStatus = 0
-	decoderTag      decoderStatus = 1
-	decoderLength   decoderStatus = 2
-	decoderValue    decoderStatus = 3
-	decoderMatching decoderStatus = 4
-	decoderFinished decoderStatus = 5
-)
-
-type collectedStatus uint8
-
-const (
-	collectedInit     collectedStatus = 0
-	collectedTag      collectedStatus = 1
-	collectedLength   collectedStatus = 2
-	collectedBody     collectedStatus = 3
-	collectedCaching  collectedStatus = 4
-	collectedFinished collectedStatus = 5
-)
-
 // Decoder: Collects bytes from buf and decodes them
 func (d *mergingCodec) Decoder(buf []byte) {
 
@@ -256,19 +234,12 @@ func (d *mergingCodec) Read(mold interface{}) (interface{}, error) {
 	result := d.Result[0]
 	d.Result = d.Result[1:]
 
-	proto := NewProtoCodec(d.Observe)
-	if proto.IsStruct(mold) {
-		err := proto.UnmarshalStructNative(matching, mold)
-		if err != nil {
-			return nil, err
-		}
-
-	} else {
-		err := proto.UnmarshalBasicNative(matching, &mold)
-		if err != nil {
-			return nil, err
-		}
+	info := &MoldInfo{Mold: mold}
+	err := d.proto.Unmarshal(matching, info)
+	if err != nil {
+		return nil, err
 	}
+	mold = info.Mold
 
 	// for Encoder::merge
 	d.Value = result

pkg/codes/yomo_streaming.go

@@ -10,7 +10,8 @@ import (
 )
 
 type streamingCodec struct {
-	inform chan bool
+	inform       chan bool
+	enableInform bool
 
 	Length int32
 	Size   int32
@@ -37,7 +38,8 @@ type streamingCodec struct {
 
 func NewStreamingCodec(observe byte) (YomoCodec, <-chan bool) {
 	codec := &streamingCodec{
-		inform: make(chan bool, 10),
+		inform:       make(chan bool, 10),
+		enableInform: true,
 
 		Observe:      observe,
 		SourceBuf:    make([]byte, 0),
@@ -58,6 +60,52 @@ func NewStreamingCodec(observe byte) (YomoCodec, <-chan bool) {
 	return codec, codec.inform
 }
 
+func NewStreamingCodecNoInform(observe byte) YomoCodec {
+	codec := &streamingCodec{
+		inform:       make(chan bool, 10),
+		enableInform: false,
+
+		Observe:      observe,
+		SourceBuf:    make([]byte, 0),
+		Status:       decoderInit,
+		Matching:     make([][]byte, 0),
+		OriginResult: make([][]byte, 0),
+
+		CollectedStatus:    collectedInit,
+		CollectedTag:       nil,
+		CollectedSize:      0,
+		CollectedLength:    0,
+		CollectedLengthBuf: make([]byte, 0),
+		CollectedBuffer:    make([]byte, 0),
+		CollectedResult:    make([][]byte, 0),
+
+		proto: NewProtoCodec(observe),
+	}
+	return codec
+}
+
+type decoderStatus uint8
+
+const (
+	decoderInit     decoderStatus = 0
+	decoderTag      decoderStatus = 1
+	decoderLength   decoderStatus = 2
+	decoderValue    decoderStatus = 3
+	decoderMatching decoderStatus = 4
+	decoderFinished decoderStatus = 5
+)
+
+type collectedStatus uint8
+
+const (
+	collectedInit     collectedStatus = 0
+	collectedTag      collectedStatus = 1
+	collectedLength   collectedStatus = 2
+	collectedBody     collectedStatus = 3
+	collectedCaching  collectedStatus = 4
+	collectedFinished collectedStatus = 5
+)
+
 // Decoder: Collects bytes from buf and decodes them
 func (d *streamingCodec) Decoder(buf []byte) {
 	for _, c := range buf {
@@ -188,7 +236,9 @@ func (d *streamingCodec) decode(buf []byte) {
 			d.matchingMutex.Lock()
 			d.Matching = append(d.Matching, curBuf)
 			d.matchingMutex.Unlock()
-			d.inform <- true
+			if d.enableInform {
+				d.inform <- true
+			}
 			d.Status = decoderMatching
 		}
 
@@ -234,19 +284,12 @@ func (d *streamingCodec) Read(mold interface{}) (interface{}, error) {
 	d.Matching = d.Matching[1:]
 	d.matchingMutex.Unlock()
 
-	proto := NewProtoCodec(d.Observe)
-	if proto.IsStruct(mold) {
-		err := proto.UnmarshalStructNative(matching, mold)
-		if err != nil {
-			return nil, err
-		}
-
-	} else {
-		err := proto.UnmarshalBasicNative(matching, &mold)
-		if err != nil {
-			return nil, err
-		}
+	info := &MoldInfo{Mold: mold}
+	err := d.proto.Unmarshal(matching, info)
+	if err != nil {
+		return nil, err
 	}
+	mold = info.Mold
 
 	return mold, nil
 }

pkg/codes/yomo_streaming_test.go

@@ -81,7 +81,7 @@ func TestInformByString(t *testing.T) {
 		var mold interface{} = ""
 		NewProtoCodec(0x10).UnmarshalBasic(buf, &mold)
 		if mold != "y-new!" {
-			t.Errorf("TestInformByString, The value should be %v", target)
+			t.Errorf("TestInformByString, The value should be %v, but mold=%v", target, mold)
 		}
 	}
 
@@ -114,7 +114,7 @@ func TestInformByStringSlice(t *testing.T) {
 		arr, _ := utils.ToStringSliceArray(mold)
 		for i, v := range arr {
 			if v != target[i] {
-				t.Errorf("TestInformByStringSlice, The value should be %v=%v", i, target[i])
+				t.Errorf("TestInformByStringSlice, The value should be %v=%v, but v=%v", i, target[i], v)
 			}
 		}
 
@@ -137,7 +137,9 @@ func testInformBy(t *testing.T, mold interface{}, input []byte, handle func(v in
 		case flag := <-inform:
 			if flag {
 				v, _ := codec.Read(mold)
+				//fmt.Printf("#4 v=%v\n", v)
 				vv := handle(v)
+				//fmt.Printf("#4 vv=%v\n", vv)
 				codec.Write(&verifier{Verify: verify}, vv, mold)
 			}
 			codec.Refresh(&verifier{Verify: verify})