7816848764

Committed 07 Feb 2024 03:05PM UTC coverage: 85.675% (+0.1%) from 85.565%

Build # 7816848764

Build Type

push

github

Committed by

andot

Commit Message

add StructType & ListType support for decoder

Run Details

36 of 39 new or added lines in 3 files covered. (92.31%)

27 existing lines in 8 files now uncovered.

9982 of 11651 relevant lines covered (85.68%)

208432.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.54

/io/bytes_decoder.go

/*--------------------------------------------------------*\
|                                                          |
|                          hprose                          |
|                                                          |
| Official WebSite: https://hprose.com                     |
|                                                          |
| io/bytes_decoder.go                                      |
|                                                          |
| LastModified: Mar 5, 2022                                |
| Author: Ma Bingyao <andot@hprose.com>                    |
|                                                          |
\*________________________________________________________*/

package io

import (
        "reflect"

        "github.com/hprose/hprose-golang/v3/internal/convert"
        "github.com/modern-go/reflect2"
)

func (dec *Decoder) readUnsafeBytes() []byte {
        bytes := dec.UnsafeNext(dec.ReadInt())
        dec.Skip()
        return bytes
}

func (dec *Decoder) readBytes() []byte {
        bytes := dec.Next(dec.ReadInt())
        dec.Skip()
        return bytes
}

// ReadBytes reads bytes and add reference.
func (dec *Decoder) ReadBytes() []byte {
        bytes := dec.readBytes()
        if !dec.IsSimple() {
                dec.refer.Add(bytes)
        }
        return bytes
}

func (dec *Decoder) readUint8Slice(et reflect.Type) []byte {
        count := dec.ReadInt()
        slice := make([]byte, count)
        dec.AddReference(slice)
        for i := 0; i < count; i++ {
                dec.decodeUint8(et, dec.NextByte(), &slice[i])
        }
        dec.Skip()
        return slice
}

func (dec *Decoder) decodeBytes(t reflect.Type, tag byte, p *[]byte) {
        switch tag {
        case TagNull:
                *p = nil
        case TagEmpty:
                *p = []byte{}
        case TagBytes:
                *p = dec.ReadBytes()
        case TagList:
                *p = dec.readUint8Slice(t.Elem())
        case TagUTF8Char:
                *p = dec.readStringAsSafeBytes(1)
        case TagString:
                if dec.IsSimple() {
                        *p = dec.ReadStringAsBytes()
                } else {
                        *p = convert.ToUnsafeBytes(dec.ReadString())
                }
        case TagGUID:
                *p, _ = dec.ReadUUID().MarshalBinary()
        default:
                dec.defaultDecode(t, p, tag)
        }
}

func (dec *Decoder) decodeBytesPtr(t reflect.Type, tag byte, p **[]byte) {
        if tag == TagNull {
                *p = nil
                return
        }
        var bytes []byte
        dec.decodeBytes(t, tag, &bytes)
        *p = &bytes
}

// bytesDecoder is the implementation of ValueDecoder for []byte.
type bytesDecoder struct {
        t reflect.Type
}

func (valdec bytesDecoder) Decode(dec *Decoder, p interface{}, tag byte) {
        dec.decodeBytes(valdec.t, tag, (*[]byte)(reflect2.PtrOf(p)))
}

// bytesPtrDecoder is the implementation of ValueDecoder for *[]byte.
type bytesPtrDecoder struct {
        t reflect.Type
}

func (valdec bytesPtrDecoder) Decode(dec *Decoder, p interface{}, tag byte) {
        dec.decodeBytesPtr(valdec.t, tag, (**[]byte)(reflect2.PtrOf(p)))
}

func init() {
        registerValueDecoder(bytesType, bytesDecoder{bytesType})
        registerValueDecoder(bytesPtrType, bytesPtrDecoder{bytesPtrType})
}

1	/--------------------------------------------------------\
2	\| \|
3	\| hprose \|
4	\| \|
5	\| Official WebSite: https://hprose.com \|
6	\| \|
7	\| io/bytes_decoder.go \|
8	\| \|
9	\| LastModified: Mar 5, 2022 \|
10	\| Author: Ma Bingyao <andot@hprose.com> \|
11	\| \|
12	\________________________________________________________/
13
14	package io
15
16	import (
17	"reflect"
18
19	"github.com/hprose/hprose-golang/v3/internal/convert"
20	"github.com/modern-go/reflect2"
21	)
22
UNCOV 23	func (dec *Decoder) readUnsafeBytes() []byte {	×
UNCOV 24	bytes := dec.UnsafeNext(dec.ReadInt())	×
UNCOV 25	dec.Skip()	×
UNCOV 26	return bytes	×
UNCOV 27	}	×
28
29	func (dec *Decoder) readBytes() []byte {	135✔
30	bytes := dec.Next(dec.ReadInt())	135✔
31	dec.Skip()	135✔
32	return bytes	135✔
33	}	135✔
34
35	// ReadBytes reads bytes and add reference.
36	func (dec *Decoder) ReadBytes() []byte {	135✔
37	bytes := dec.readBytes()	135✔
38	if !dec.IsSimple() {	162✔
39	dec.refer.Add(bytes)	27✔
40	}	27✔
41	return bytes	135✔
42	}
43
44	func (dec *Decoder) readUint8Slice(et reflect.Type) []byte {	18✔
45	count := dec.ReadInt()	18✔
46	slice := make([]byte, count)	18✔
47	dec.AddReference(slice)	18✔
48	for i := 0; i < count; i++ {	108✔
49	dec.decodeUint8(et, dec.NextByte(), &slice[i])	90✔
50	}	90✔
51	dec.Skip()	18✔
52	return slice	18✔
53	}
54
55	func (dec Decoder) decodeBytes(t reflect.Type, tag byte, p []byte) {	216✔
56	switch tag {	216✔
57	case TagNull:	9✔
58	*p = nil	9✔
59	case TagEmpty:	18✔
60	*p = []byte{}	18✔
61	case TagBytes:	27✔
62	*p = dec.ReadBytes()	27✔
63	case TagList:	18✔
64	*p = dec.readUint8Slice(t.Elem())	18✔
65	case TagUTF8Char:	18✔
66	*p = dec.readStringAsSafeBytes(1)	18✔
67	case TagString:	72✔
68	if dec.IsSimple() {	144✔
69	*p = dec.ReadStringAsBytes()	72✔
70	} else {	72✔
71	*p = convert.ToUnsafeBytes(dec.ReadString())	×
72	}	×
73	case TagGUID:	×
74	*p, _ = dec.ReadUUID().MarshalBinary()	×
75	default:	54✔
76	dec.defaultDecode(t, p, tag)	54✔
77	}
78	}
79
80	func (dec Decoder) decodeBytesPtr(t reflect.Type, tag byte, p *[]byte) {	117✔
81	if tag == TagNull {	126✔
82	*p = nil	9✔
83	return	9✔
84	}	9✔
85	var bytes []byte	108✔
86	dec.decodeBytes(t, tag, &bytes)	108✔
87	*p = &bytes	108✔
88	}
89
90	// bytesDecoder is the implementation of ValueDecoder for []byte.
91	type bytesDecoder struct {
92	t reflect.Type
93	}
94
95	func (valdec bytesDecoder) Decode(dec *Decoder, p interface{}, tag byte) {	×
96	dec.decodeBytes(valdec.t, tag, (*[]byte)(reflect2.PtrOf(p)))	×
97	}	×
98
99	// bytesPtrDecoder is the implementation of ValueDecoder for *[]byte.
100	type bytesPtrDecoder struct {
101	t reflect.Type
102	}
103
104	func (valdec bytesPtrDecoder) Decode(dec *Decoder, p interface{}, tag byte) {	9✔
105	dec.decodeBytesPtr(valdec.t, tag, (**[]byte)(reflect2.PtrOf(p)))	9✔
106	}	9✔
107
108	func init() {	90✔
109	registerValueDecoder(bytesType, bytesDecoder{bytesType})	90✔
110	registerValueDecoder(bytesPtrType, bytesPtrDecoder{bytesPtrType})	90✔
111	}	90✔

hprose / hprose-golang / 7816848764

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous