decode.decodeUnmarshalerStorage - Code Metrics - Inspection of "Fix unmarshaler decoder" - et-nik/binngo - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( fd8660...f4d29e )

by Nikita

created 2021-06-05 11:14 UTC

decode.decodeUnmarshalerStorage A

↳ Parent: decode/decode.go

Complexity

Conditions

Size

Total Lines	21
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	4.128

Importance

Changes

Metric	Value
cc	4
eloc	16
dl	0
loc	21
ccs	12
cts	15
cp	0.8
crap	4.128
rs	9.6
c	0
b	0
f	0
nop	3

package decode

import (
	"bytes"
	"io"
	"reflect"
	"sync"

	"github.com/cstockton/go-conv"
	"github.com/et-nik/binngo/binn"
	"github.com/et-nik/binngo/encode"
)

const (
	maxOneByteSize = 127
)

type decodeFunc func(reader io.Reader, v interface{}) error

var decoderCache sync.Map // map[binn.Type]decodeFunc

type readLen int

func decode(reader io.Reader, v interface{}) error {
	rv := reflect.ValueOf(v)
	rt := reflect.TypeOf(v)
	if rv.Kind() != reflect.Ptr || rv.IsNil() {
		return &InvalidUnmarshalError{rt}
	}

	containerType, _, err := readType(reader)
	if err != nil {
		return err
	}

	if rt.Implements(unmarshalerType) && isStorageContainer(containerType) {
		return decodeUnmarshalerStorage(containerType, reader, v)
	}

	return decodeStorage(containerType, reader, v)
}

func decodeUnmarshalerStorage(containerType binn.Type, reader io.Reader, v interface{}) error {
	size, _, err := readSize(reader)
	if err != nil {
		return err
	}
	buf := make([]byte, size)
	_, err = reader.Read(buf)
	if err != nil {
		return err
	}
	var data []byte
	data = append(data, encode.Uint8(uint8(containerType))...)
	data = append(data, encode.Size(size, true)...)
	data = append(data, buf...)

	err = decodeUnmarshaler(data, v)
	if err != nil {
		return err
	}

	return nil
}

func decodeStorage(containerType binn.Type, reader io.Reader, v interface{}) error {
	decoder := loadDecodeFunc(containerType)
	return decoder(reader, v)
}

func decodeItem(rt reflect.Type, btype binn.Type, bval []byte) (interface{}, error) {
	var v interface{}
	var err error

	switch btype {
	case binn.Null:
		return nil, nil
	case binn.True:
		return true, nil
	case binn.False:
		return false, nil
	case binn.Uint8Type:
		v = Uint8(bval)
	case binn.Uint16Type:
		v = Uint16(bval)
	case binn.Uint32Type:
		v = Uint32(bval)
	case binn.Uint64Type:
		v = Uint64(bval)
	case binn.Int8Type:
		v = Int8(bval)
	case binn.Int16Type:
		v = Int16(bval)
	case binn.Int32Type:
		v = Int32(bval)
	case binn.Int64Type:
		v = Int64(bval)
	case binn.Float32Type:
		v = Float32(bval)
	case binn.Float64Type:
		v = Float64(bval)
	case binn.StringType:
		v = String(bval[:len(bval)-1])
	case binn.BlobType:
		v = bval
	case binn.ListType:
		var l []interface{}
		br := bytes.NewReader(bval)
		_, wasReadLen, _ := readSize(br)
		cnt, wasReadCnt, _ := readSize(br)
		wasRead := wasReadLen + wasReadCnt

		err = decodeListItems(br, &l, len(bval)-int(wasRead), wasRead, cnt)
		if err != nil {
			return nil, err
		}

		return l, nil
	case binn.MapType:
		br := bytes.NewReader(bval)
		sz, rlsize, _ := readSize(br)
		cnt, rlcnt, _ := readSize(br)

		mapType := reflect.MapOf(reflect.TypeOf(int(0)), rt.Elem())
		ptr := reflect.New(mapType)
		ptr.Elem().Set(reflect.MakeMap(mapType))
		m := ptr.Interface()

		err = decodeMapItems(br, m, sz, rlsize+rlcnt, cnt)
		if err != nil {
			return nil, err
		}

		return reflect.ValueOf(m).Elem().Interface(), nil
	case binn.ObjectType:
		var obj interface{}
		if rt.Kind() == reflect.Interface {
			obj = map[string]interface{}{}
		} else {
			ptr := reflect.New(rt)
			obj = ptr.Interface()
		}

		br := bytes.NewReader(bval)

		err = decodeStorage(btype, br, &obj)

		if err != nil {
			return nil, err
		}

		return obj, nil
	}

	if rt.Kind() == reflect.Interface {
		v, err = convertToKind(kindMapper[btype], v)
		if err != nil {
			return nil, err
		}
	} else {
		v, err = convertToType(rt, v)
		if err != nil {
			return nil, err
		}
	}

	return v, nil
}

func loadDecodeFunc(bt binn.Type) decodeFunc {
	if fi, ok := decoderCache.Load(bt); ok {
		return fi.(decodeFunc)
	}

	var (
		wg sync.WaitGroup
		f  decodeFunc
	)
	wg.Add(1)
	fi, loaded := decoderCache.LoadOrStore(bt, decodeFunc(func(reader io.Reader, v interface{}) error {
		wg.Wait()
		return f(reader, v)
	}))
	if loaded {
		return fi.(decodeFunc)
	}

	f = newTypeDecoder(bt)
	wg.Done()
	decoderCache.Store(bt, f)
	return f
}

func newTypeDecoder(bt binn.Type) decodeFunc {
	switch bt {
	case binn.ListType:
		return decodeList
	case binn.MapType:
		return decodeMap
	case binn.ObjectType:
		return decodeObject
	case binn.Null:
		return func(_ io.Reader, _ interface{}) error {
			return nil
		}
	}

	decoder := newValueDecoder(bt)
	return decoder.DecodeValue
}

func convertToType(rt reflect.Type, val interface{}) (interface{}, error) {
	switch rt.Kind() {
	case reflect.Interface:
		return val, nil
	case reflect.Ptr:
		return convertToType(rt.Elem(), val)
	default:
		return convertToKind(rt.Kind(), val)
	}
}

func convertToKind(rk reflect.Kind, v interface{}) (interface{}, error) {
	switch rk {
	case reflect.Int:
		return conv.Int(v)
	case reflect.Int8:
		return conv.Int8(v)
	case reflect.Int16:
		return conv.Int16(v)
	case reflect.Int32:
		return conv.Int32(v)
	case reflect.Int64:
		return conv.Int64(v)
	case reflect.Uint:
		return conv.Uint(v)
	case reflect.Uint8:
		return conv.Uint8(v)
	case reflect.Uint16:
		return conv.Uint16(v)
	case reflect.Uint32:
		return conv.Int32(v)
	case reflect.Uint64:
		return conv.Uint64(v)
	case reflect.Bool:
		return conv.Bool(v)
	case reflect.String:
		return conv.String(v)
	}

	return v, nil
}


1		package decode
2
3		import (
4		"bytes"
5		"io"
6		"reflect"
7		"sync"
8
9		"github.com/cstockton/go-conv"
10		"github.com/et-nik/binngo/binn"
11		"github.com/et-nik/binngo/encode"
12		)
13
14		const (
15		maxOneByteSize = 127
16		)
17
18		type decodeFunc func(reader io.Reader, v interface{}) error
19
20		var decoderCache sync.Map // map[binn.Type]decodeFunc
21
22		type readLen int
23
24		func decode(reader io.Reader, v interface{}) error {
25	1	rv := reflect.ValueOf(v)
26	1	rt := reflect.TypeOf(v)
27	1	if rv.Kind() != reflect.Ptr \|\| rv.IsNil() {
28		return &InvalidUnmarshalError{rt}
29		}
30
31	1	containerType, _, err := readType(reader)
32	1	if err != nil {
33		return err
34		}
35
36	1	if rt.Implements(unmarshalerType) && isStorageContainer(containerType) {
37	1	return decodeUnmarshalerStorage(containerType, reader, v)
38		}
39
40	1	return decodeStorage(containerType, reader, v)
41		}
42
43		func decodeUnmarshalerStorage(containerType binn.Type, reader io.Reader, v interface{}) error {
44	1	size, _, err := readSize(reader)
45	1	if err != nil {
46		return err
47		}
48	1	buf := make([]byte, size)
49	1	_, err = reader.Read(buf)
50	1	if err != nil {
51		return err
52		}
53	1	var data []byte
54	1	data = append(data, encode.Uint8(uint8(containerType))...)
55	1	data = append(data, encode.Size(size, true)...)
56	1	data = append(data, buf...)
57
58	1	err = decodeUnmarshaler(data, v)
59	1	if err != nil {
60		return err
61		}
62
63	1	return nil
64		}
65
66		func decodeStorage(containerType binn.Type, reader io.Reader, v interface{}) error {
67	1	decoder := loadDecodeFunc(containerType)
68	1	return decoder(reader, v)
69		}
70
71		func decodeItem(rt reflect.Type, btype binn.Type, bval []byte) (interface{}, error) {
72	1	var v interface{}
73	1	var err error
74
75	1	switch btype {
76		case binn.Null:
77		return nil, nil
78		case binn.True:
79	1	return true, nil
80		case binn.False:
81	1	return false, nil
82		case binn.Uint8Type:
83	1	v = Uint8(bval)
84		case binn.Uint16Type:
85	1	v = Uint16(bval)
86		case binn.Uint32Type:
87	1	v = Uint32(bval)
88		case binn.Uint64Type:
89	1	v = Uint64(bval)
90		case binn.Int8Type:
91	1	v = Int8(bval)
92		case binn.Int16Type:
93	1	v = Int16(bval)
94		case binn.Int32Type:
95	1	v = Int32(bval)
96		case binn.Int64Type:
97	1	v = Int64(bval)
98		case binn.Float32Type:
99	1	v = Float32(bval)
100		case binn.Float64Type:
101	1	v = Float64(bval)
102		case binn.StringType:
103	1	v = String(bval[:len(bval)-1])
104		case binn.BlobType:
105	1	v = bval
106		case binn.ListType:
107	1	var l []interface{}
108	1	br := bytes.NewReader(bval)
109	1	_, wasReadLen, _ := readSize(br)
110	1	cnt, wasReadCnt, _ := readSize(br)
111	1	wasRead := wasReadLen + wasReadCnt
112
113	1	err = decodeListItems(br, &l, len(bval)-int(wasRead), wasRead, cnt)
114	1	if err != nil {
115		return nil, err
116		}
117
118	1	return l, nil
119		case binn.MapType:
120	1	br := bytes.NewReader(bval)
121	1	sz, rlsize, _ := readSize(br)
122	1	cnt, rlcnt, _ := readSize(br)
123
124	1	mapType := reflect.MapOf(reflect.TypeOf(int(0)), rt.Elem())
125	1	ptr := reflect.New(mapType)
126	1	ptr.Elem().Set(reflect.MakeMap(mapType))
127	1	m := ptr.Interface()
128
129	1	err = decodeMapItems(br, m, sz, rlsize+rlcnt, cnt)
130	1	if err != nil {
131		return nil, err
132		}
133
134	1	return reflect.ValueOf(m).Elem().Interface(), nil
135		case binn.ObjectType:
136	1	var obj interface{}
137	1	if rt.Kind() == reflect.Interface {
138		obj = map[string]interface{}{}
139		} else {
140	1	ptr := reflect.New(rt)
141	1	obj = ptr.Interface()
142		}
143
144	1	br := bytes.NewReader(bval)
145
146	1	err = decodeStorage(btype, br, &obj)
147
148	1	if err != nil {
149		return nil, err
150		}
151
152	1	return obj, nil
153		}
154
155	1	if rt.Kind() == reflect.Interface {
156	1	v, err = convertToKind(kindMapper[btype], v)
157	1	if err != nil {
158		return nil, err
159		}
160		} else {
161	1	v, err = convertToType(rt, v)
162	1	if err != nil {
163		return nil, err
164		}
165		}
166
167	1	return v, nil
168		}
169
170		func loadDecodeFunc(bt binn.Type) decodeFunc {
171	1	if fi, ok := decoderCache.Load(bt); ok {
172	1	return fi.(decodeFunc)
173		}
174
175	1	var (
176		wg sync.WaitGroup
177		f decodeFunc
178		)
179	1	wg.Add(1)
180	1	fi, loaded := decoderCache.LoadOrStore(bt, decodeFunc(func(reader io.Reader, v interface{}) error {
181		wg.Wait()
182		return f(reader, v)
183		}))
184	1	if loaded {
185		return fi.(decodeFunc)
186		}
187
188	1	f = newTypeDecoder(bt)
189	1	wg.Done()
190	1	decoderCache.Store(bt, f)
191	1	return f
192		}
193
194		func newTypeDecoder(bt binn.Type) decodeFunc {
195	1	switch bt {
196		case binn.ListType:
197	1	return decodeList
198		case binn.MapType:
199	1	return decodeMap
200		case binn.ObjectType:
201	1	return decodeObject
202		case binn.Null:
203	1	return func(_ io.Reader, _ interface{}) error {
204	1	return nil
205		}
206		}
207
208	1	decoder := newValueDecoder(bt)
209	1	return decoder.DecodeValue
210		}
211
212		func convertToType(rt reflect.Type, val interface{}) (interface{}, error) {
213	1	switch rt.Kind() {
214		case reflect.Interface:
215		return val, nil
216		case reflect.Ptr:
217		return convertToType(rt.Elem(), val)
218		default:
219	1	return convertToKind(rt.Kind(), val)
220		}
221		}
222
223		func convertToKind(rk reflect.Kind, v interface{}) (interface{}, error) {
224	1	switch rk {
225		case reflect.Int:
226	1	return conv.Int(v)
227		case reflect.Int8:
228	1	return conv.Int8(v)
229		case reflect.Int16:
230	1	return conv.Int16(v)
231		case reflect.Int32:
232	1	return conv.Int32(v)
233		case reflect.Int64:
234	1	return conv.Int64(v)
235		case reflect.Uint:
236		return conv.Uint(v)
237		case reflect.Uint8:
238	1	return conv.Uint8(v)
239		case reflect.Uint16:
240	1	return conv.Uint16(v)
241		case reflect.Uint32:
242	1	return conv.Int32(v)
243		case reflect.Uint64:
244		return conv.Uint64(v)
245		case reflect.Bool:
246		return conv.Bool(v)
247		case reflect.String:
248	1	return conv.String(v)
249		}
250
251	1	return v, nil
252		}
253

et-nik / binngo

Push — master ( fd8660...f4d29e )

decode.decodeUnmarshalerStorage A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like