From fc0ce203856d66600abaa8a89d125510f4a04781 Mon Sep 17 00:00:00 2001 From: chenjunbiao Date: Mon, 25 Jan 2021 15:21:14 +0800 Subject: [PATCH] refactor(*) fix for golint, etc. - fix for golint - rename Array to Slice - rename Y3Codec to Codec - set enabledTestPrintf to false --- basic.go | 44 +++++++++++++++++++-------------------- codec.go | 10 ++++----- encoder.go | 4 +++- examples/packet/decode.go | 4 ++-- observable.go | 2 ++ observable_test.go | 12 ++++------- structure_decoder.go | 7 ++++--- structure_decoder_test.go | 5 ++++- structure_encoder.go | 18 ++++++++-------- structure_encoder_test.go | 6 +++++- tester.go | 2 +- types.go | 2 +- 12 files changed, 62 insertions(+), 54 deletions(-) diff --git a/basic.go b/basic.go index 0879b3f..09be350 100644 --- a/basic.go +++ b/basic.go @@ -98,14 +98,14 @@ func (e *basicEncoderImpl) encodeBasic(input interface{}, signals []*PrimitivePa } root.AddPrimitivePacket(primitiveEncoder) return root.Encode(), nil - } else { - buf := make([][]byte, 0) - for _, signal := range signals { - buf = append(buf, signal.Encode()) - } - buf = append(buf, primitiveEncoder.Encode()) - return bytes.Join(buf, []byte{}), nil } + + buf := make([][]byte, 0) + for _, signal := range signals { + buf = append(buf, signal.Encode()) + } + buf = append(buf, primitiveEncoder.Encode()) + return bytes.Join(buf, []byte{}), nil } // encodeBasicSlice encode reflect.Value of slice, and inserting signals @@ -148,14 +148,14 @@ func (e *basicEncoderImpl) encodeBasicSlice(value reflect.Value, signals []*Prim } root.AddNodePacket(nodeEncoder) return root.Encode(), nil - } else { - buf := make([][]byte, 0) - for _, signal := range signals { - buf = append(buf, signal.Encode()) - } - buf = append(buf, nodeEncoder.Encode()) - return bytes.Join(buf, []byte{}), nil } + + buf := make([][]byte, 0) + for _, signal := range signals { + buf = append(buf, signal.Encode()) + } + buf = append(buf, nodeEncoder.Encode()) + return bytes.Join(buf, []byte{}), nil } // encodeBasicString encode string to PrimitivePacketEncoder @@ -216,7 +216,7 @@ func (e *basicEncoderImpl) encodeBasicBool(input interface{}) *PrimitivePacketEn // encodeBasicStringSlice encode reflect.Value of []string to NodePacketEncoder func (e *basicEncoderImpl) encodeBasicStringSlice(value reflect.Value) *NodePacketEncoder { - var node = NewNodeArrayPacketEncoder(int(e.observe)) + var node = NewNodeSlicePacketEncoder(int(e.observe)) if out, ok := utils.ToStringSliceArray(value.Interface()); ok { for _, v := range out { var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem) @@ -229,7 +229,7 @@ func (e *basicEncoderImpl) encodeBasicStringSlice(value reflect.Value) *NodePack // encodeBasicInt32Slice encode reflect.Value of []int32 to NodePacketEncoder func (e *basicEncoderImpl) encodeBasicInt32Slice(value reflect.Value) *NodePacketEncoder { - var node = NewNodeArrayPacketEncoder(int(e.observe)) + var node = NewNodeSlicePacketEncoder(int(e.observe)) if out, ok := utils.ToInt64SliceArray(value.Interface()); ok { for _, v := range out { var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem) @@ -242,7 +242,7 @@ func (e *basicEncoderImpl) encodeBasicInt32Slice(value reflect.Value) *NodePacke // encodeBasicUint32Slice encode reflect.Value of []uint32 to NodePacketEncoder func (e *basicEncoderImpl) encodeBasicUint32Slice(value reflect.Value) *NodePacketEncoder { - var node = NewNodeArrayPacketEncoder(int(e.observe)) + var node = NewNodeSlicePacketEncoder(int(e.observe)) if out, ok := utils.ToUInt64SliceArray(value.Interface()); ok { for _, v := range out { var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem) @@ -255,7 +255,7 @@ func (e *basicEncoderImpl) encodeBasicUint32Slice(value reflect.Value) *NodePack // encodeBasicInt64Slice encode reflect.Value of []int64 to NodePacketEncoder func (e *basicEncoderImpl) encodeBasicInt64Slice(value reflect.Value) *NodePacketEncoder { - var node = NewNodeArrayPacketEncoder(int(e.observe)) + var node = NewNodeSlicePacketEncoder(int(e.observe)) if out, ok := utils.ToInt64SliceArray(value.Interface()); ok { for _, v := range out { var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem) @@ -268,7 +268,7 @@ func (e *basicEncoderImpl) encodeBasicInt64Slice(value reflect.Value) *NodePacke // encodeBasicUint64Slice encode reflect.Value of []uint64 to NodePacketEncoder func (e *basicEncoderImpl) encodeBasicUint64Slice(value reflect.Value) *NodePacketEncoder { - var node = NewNodeArrayPacketEncoder(int(e.observe)) + var node = NewNodeSlicePacketEncoder(int(e.observe)) if out, ok := utils.ToUInt64SliceArray(value.Interface()); ok { for _, v := range out { var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem) @@ -281,7 +281,7 @@ func (e *basicEncoderImpl) encodeBasicUint64Slice(value reflect.Value) *NodePack // encodeBasicFloat32Slice encode reflect.Value of []float32 to NodePacketEncoder func (e *basicEncoderImpl) encodeBasicFloat32Slice(value reflect.Value) *NodePacketEncoder { - var node = NewNodeArrayPacketEncoder(int(e.observe)) + var node = NewNodeSlicePacketEncoder(int(e.observe)) if out, ok := utils.ToUFloat64SliceArray(value.Interface()); ok { for _, v := range out { var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem) @@ -294,7 +294,7 @@ func (e *basicEncoderImpl) encodeBasicFloat32Slice(value reflect.Value) *NodePac // encodeBasicFloat64Slice encode reflect.Value of []float64 to NodePacketEncoder func (e *basicEncoderImpl) encodeBasicFloat64Slice(value reflect.Value) *NodePacketEncoder { - var node = NewNodeArrayPacketEncoder(int(e.observe)) + var node = NewNodeSlicePacketEncoder(int(e.observe)) if out, ok := utils.ToUFloat64SliceArray(value.Interface()); ok { for _, v := range out { var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem) @@ -307,7 +307,7 @@ func (e *basicEncoderImpl) encodeBasicFloat64Slice(value reflect.Value) *NodePac // encodeBasicBoolSlice encode reflect.Value of []bool to NodePacketEncoder func (e *basicEncoderImpl) encodeBasicBoolSlice(value reflect.Value) *NodePacketEncoder { - var node = NewNodeArrayPacketEncoder(int(e.observe)) + var node = NewNodeSlicePacketEncoder(int(e.observe)) if out, ok := utils.ToBoolSliceArray(value.Interface()); ok { for _, v := range out { var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem) diff --git a/codec.go b/codec.go index f4e7232..384d9a6 100644 --- a/codec.go +++ b/codec.go @@ -4,20 +4,20 @@ import ( "reflect" ) -// Y3Codec encode the user's data according to the Y3 encoding rules -type Y3Codec interface { +// Codec encode the user's data according to the Y3 encoding rules +type Codec interface { // Marshal encode interface to []byte Marshal(input interface{}) ([]byte, error) } -// NewCodec create a Y3Codec interface -func NewCodec(observe byte) Y3Codec { +// NewCodec create a Codec interface +func NewCodec(observe byte) Codec { return &y3Codec{ observe: observe, } } -// y3Codec is implementation of the Y3Codec interface +// y3Codec is implementation of the Codec interface type y3Codec struct { observe byte } diff --git a/encoder.go b/encoder.go index a90fe85..eb19a56 100644 --- a/encoder.go +++ b/encoder.go @@ -135,6 +135,7 @@ func (enc *PrimitivePacketEncoder) SetStringValue(v string) { enc.valbuf = []byte(v) } +// SetBytes set bytes to internal buf variable func (enc *PrimitivePacketEncoder) SetBytes(buf []byte) { enc.valbuf = buf } @@ -157,7 +158,8 @@ func NewNodePacketEncoder(sid int) *NodePacketEncoder { return nodeEnc } -func NewNodeArrayPacketEncoder(sid int) *NodePacketEncoder { +// NewNodeSlicePacketEncoder returns an Encoder for node packet that is a slice +func NewNodeSlicePacketEncoder(sid int) *NodePacketEncoder { nodeEnc := &NodePacketEncoder{ encoder: encoder{ isNode: true, diff --git a/examples/packet/decode.go b/examples/packet/decode.go index 503a8c1..fe993aa 100644 --- a/examples/packet/decode.go +++ b/examples/packet/decode.go @@ -102,7 +102,7 @@ func encodeArrayPacket() { var club = y3.NewNodePacketEncoder(0x01) // 0xc2 - []*bar - var bars = y3.NewNodeArrayPacketEncoder(0x02) + var bars = y3.NewNodeSlicePacketEncoder(0x02) // 0x03 - Name="a1" var bar1 = y3.NewNodePacketEncoder(0x00) @@ -119,7 +119,7 @@ func encodeArrayPacket() { bars.AddNodePacket(bar2) // 0x44 - kinds - var kinds = y3.NewNodeArrayPacketEncoder(0x04) + var kinds = y3.NewNodeSlicePacketEncoder(0x04) // 0x44 - item1 var item1 = y3.NewPrimitivePacketEncoder(0x00) diff --git a/observable.go b/observable.go index 66a7177..3ebeb1e 100644 --- a/observable.go +++ b/observable.go @@ -7,10 +7,12 @@ import ( "github.com/yomorun/y3-codec-golang/pkg/encoding" ) +// Iterable iterate through and get the data of observe type Iterable interface { Observe() <-chan interface{} } +// Observable provide subscription and notification processing type Observable interface { Iterable Subscribe(key byte) Observable diff --git a/observable_test.go b/observable_test.go index 18223a9..37bbf94 100644 --- a/observable_test.go +++ b/observable_test.go @@ -20,22 +20,18 @@ func TestObservable(t *testing.T) { if (v[0] == 17) && (v[1] == 2) && (v[2] == 67) && (v[3] == 228) { count1++ return "ok1", nil - } else { - err1 = errors.New("fail") - return nil, errors.New("fail") } - + err1 = errors.New("fail") + return nil, errors.New("fail") } callback2 := func(v []byte) (interface{}, error) { if (v[0] == 19) && (v[1] == 2) && (v[2] == 65) && (v[3] == 240) { count2++ return "ok2", nil - } else { - err2 = errors.New("fail") - return nil, errors.New("fail") } - + err2 = errors.New("fail") + return nil, errors.New("fail") } reader := bytes.NewReader(buf) diff --git a/structure_decoder.go b/structure_decoder.go index 6a30966..a9b34d4 100644 --- a/structure_decoder.go +++ b/structure_decoder.go @@ -128,8 +128,9 @@ func (d *structDecoderImpl) decodeSlice(data *NodePacket, val reflect.Value) err elemType := val.Type().Elem() items := make([]reflect.Value, 0) - for _, node := range data.NodePackets { + for i := range data.NodePackets { elemValue := reflect.Indirect(reflect.New(elemType)) + node := data.NodePackets[i] err := d.decodeStruct(&node, elemValue) if err != nil { return err @@ -408,11 +409,11 @@ func (d *structDecoderImpl) matchingKey(key byte, node *NodePacket) (flag bool, } if len(node.NodePackets) > 0 { - for _, n := range node.NodePackets { + for i := range node.NodePackets { + n := node.NodePackets[i] if key == n.SeqID() { return true, true, n } - //return matchingKey(key, &n) flag, isNode, packet = d.matchingKey(key, &n) if flag { return diff --git a/structure_decoder_test.go b/structure_decoder_test.go index 3f3298f..8b56617 100644 --- a/structure_decoder_test.go +++ b/structure_decoder_test.go @@ -32,7 +32,10 @@ func TestBasic_Struct(t *testing.T) { } func runDecode(t *testing.T, inputBuf []byte, output interface{}) { - _, err := newStructDecoder(output).Decode(inputBuf) + _, err := newStructDecoder(output, structDecoderOptionConfig(&structDecoderConfig{ + ZeroFields: true, + TagName: "yomo", + })).Decode(inputBuf) if err != nil { t.Errorf("got an err: %s", err.Error()) t.FailNow() diff --git a/structure_encoder.go b/structure_encoder.go index a0d0048..c472ebe 100644 --- a/structure_encoder.go +++ b/structure_encoder.go @@ -110,14 +110,14 @@ func (e *structEncoderImpl) encode(input interface{}, signals []*PrimitivePacket } root.AddNodePacket(nodeEncoder) return root.Encode(), nil - } else { - buf := make([][]byte, 0) - for _, signal := range signals { - buf = append(buf, signal.Encode()) - } - buf = append(buf, nodeEncoder.Encode()) - return bytes.Join(buf, []byte{}), nil } + + buf := make([][]byte, 0) + for _, signal := range signals { + buf = append(buf, signal.Encode()) + } + buf = append(buf, nodeEncoder.Encode()) + return bytes.Join(buf, []byte{}), nil } // encodeSlice encode slice to NodePacketEncoder @@ -199,12 +199,12 @@ func (e *structEncoderImpl) encodeStructFromField(fieldType reflect.Type, fieldN case reflect.Bool: ppe.SetBoolValue(e.fieldValueToBool(fieldType, fieldValue)) case reflect.Array: - arrNode := NewNodeArrayPacketEncoder(int(utils.KeyOf(fieldName))) + arrNode := NewNodeSlicePacketEncoder(int(utils.KeyOf(fieldName))) e.encodeArrayFromField(fieldValue, arrNode) en.AddNodePacket(arrNode) return case reflect.Slice: - sliceNode := NewNodeArrayPacketEncoder(int(utils.KeyOf(fieldName))) + sliceNode := NewNodeSlicePacketEncoder(int(utils.KeyOf(fieldName))) e.encodeSliceFromField(fieldValue, sliceNode) en.AddNodePacket(sliceNode) return diff --git a/structure_encoder_test.go b/structure_encoder_test.go index 6bce113..1bbba8c 100644 --- a/structure_encoder_test.go +++ b/structure_encoder_test.go @@ -16,7 +16,11 @@ func TestStructEncoderWithSignals(t *testing.T) { Therm: thermometer{Temperature: float32(30), Humidity: float32(40)}, } - encoder := newStructEncoder(0x30, structEncoderOptionRoot(rootToken)) + encoder := newStructEncoder(0x30, structEncoderOptionRoot(rootToken), + structEncoderOptionConfig(&structEncoderConfig{ + ZeroFields: true, + TagName: "yomo", + })) inputBuf, _ := encoder.Encode(input, createSignal(0x02).SetString("a"), createSignal(0x03).SetString("b")) diff --git a/tester.go b/tester.go index 7d390f9..e3aaf20 100644 --- a/tester.go +++ b/tester.go @@ -7,7 +7,7 @@ import ( var ( // enabledTestPrintf set whether to print debug information in the test - enabledTestPrintf = true + enabledTestPrintf = false ) // observableTester use Observable to listen the node diff --git a/types.go b/types.go index b9b1a24..25c1f3a 100644 --- a/types.go +++ b/types.go @@ -8,7 +8,7 @@ import ( // ToObject decode bytes to interface func ToObject(v []byte, output interface{}) error { - output, err := newStructDecoder(output).Decode(v) + output, err := newStructDecoder(output).Decode(v) // nolint return err }