build(deps): bump github.com/shamaton/msgpack/v2 from 2.1.1 to 2.2.0
Bumps [github.com/shamaton/msgpack/v2](https://github.com/shamaton/msgpack) from 2.1.1 to 2.2.0. - [Release notes](https://github.com/shamaton/msgpack/releases) - [Commits](https://github.com/shamaton/msgpack/compare/v2.1.1...v2.2.0) --- updated-dependencies: - dependency-name: github.com/shamaton/msgpack/v2 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>
This commit is contained in:
dependabot[bot]
committed by
Ralf Haferkamp
Ralf Haferkamp
parent
09fad45811
commit
c2c740592d
+50
@@ -0,0 +1,50 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"reflect"
|
||||
"unsafe"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
func (d *decoder) isCodeBin(v byte) bool {
|
||||
switch v {
|
||||
case def.Bin8, def.Bin16, def.Bin32:
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (d *decoder) asBinWithCode(code byte, k reflect.Kind) ([]byte, error) {
|
||||
|
||||
switch code {
|
||||
case def.Bin8:
|
||||
l, err := d.readSize1()
|
||||
if err != nil {
|
||||
return emptyBytes, err
|
||||
}
|
||||
return d.readSizeN(int(l))
|
||||
|
||||
case def.Bin16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return emptyBytes, err
|
||||
}
|
||||
return d.readSizeN(int(binary.BigEndian.Uint16(bs)))
|
||||
|
||||
case def.Bin32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return emptyBytes, err
|
||||
}
|
||||
return d.readSizeN(int(binary.BigEndian.Uint32(bs)))
|
||||
}
|
||||
|
||||
return emptyBytes, d.errorTemplate(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asBinStringWithCode(code byte, k reflect.Kind) (string, error) {
|
||||
bs, err := d.asBinWithCode(code, k)
|
||||
return *(*string)(unsafe.Pointer(&bs)), err
|
||||
}
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
func (d *decoder) asBool(k reflect.Kind) (bool, error) {
|
||||
code, err := d.readSize1()
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return d.asBoolWithCode(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asBoolWithCode(code byte, k reflect.Kind) (bool, error) {
|
||||
switch code {
|
||||
case def.True:
|
||||
return true, nil
|
||||
case def.False:
|
||||
return false, nil
|
||||
}
|
||||
return false, d.errorTemplate(code, k)
|
||||
}
|
||||
+108
@@ -0,0 +1,108 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"math"
|
||||
"reflect"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
func (d *decoder) asComplex64(code byte, k reflect.Kind) (complex64, error) {
|
||||
switch code {
|
||||
case def.Fixext8:
|
||||
t, err := d.readSize1()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
if int8(t) != def.ComplexTypeCode() {
|
||||
return complex(0, 0), fmt.Errorf("fixext8. complex type is diffrent %d, %d", t, def.ComplexTypeCode())
|
||||
}
|
||||
rb, err := d.readSize4()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
r := math.Float32frombits(binary.BigEndian.Uint32(rb))
|
||||
|
||||
ib, err := d.readSize4()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
i := math.Float32frombits(binary.BigEndian.Uint32(ib))
|
||||
return complex(r, i), nil
|
||||
|
||||
case def.Fixext16:
|
||||
t, err := d.readSize1()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
if int8(t) != def.ComplexTypeCode() {
|
||||
return complex(0, 0), fmt.Errorf("fixext16. complex type is diffrent %d, %d", t, def.ComplexTypeCode())
|
||||
}
|
||||
rb, err := d.readSize8()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
r := math.Float64frombits(binary.BigEndian.Uint64(rb))
|
||||
|
||||
ib, err := d.readSize8()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
i := math.Float64frombits(binary.BigEndian.Uint64(ib))
|
||||
return complex64(complex(r, i)), nil
|
||||
|
||||
}
|
||||
|
||||
return complex(0, 0), fmt.Errorf("should not reach this line!! code %x decoding %v", code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asComplex128(code byte, k reflect.Kind) (complex128, error) {
|
||||
switch code {
|
||||
case def.Fixext8:
|
||||
t, err := d.readSize1()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
if int8(t) != def.ComplexTypeCode() {
|
||||
return complex(0, 0), fmt.Errorf("fixext8. complex type is diffrent %d, %d", t, def.ComplexTypeCode())
|
||||
}
|
||||
rb, err := d.readSize4()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
r := math.Float32frombits(binary.BigEndian.Uint32(rb))
|
||||
|
||||
ib, err := d.readSize4()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
i := math.Float32frombits(binary.BigEndian.Uint32(ib))
|
||||
return complex128(complex(r, i)), nil
|
||||
|
||||
case def.Fixext16:
|
||||
t, err := d.readSize1()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
if int8(t) != def.ComplexTypeCode() {
|
||||
return complex(0, 0), fmt.Errorf("fixext16. complex type is diffrent %d, %d", t, def.ComplexTypeCode())
|
||||
}
|
||||
rb, err := d.readSize8()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
r := math.Float64frombits(binary.BigEndian.Uint64(rb))
|
||||
|
||||
ib, err := d.readSize8()
|
||||
if err != nil {
|
||||
return complex(0, 0), err
|
||||
}
|
||||
i := math.Float64frombits(binary.BigEndian.Uint64(ib))
|
||||
return complex(r, i), nil
|
||||
|
||||
}
|
||||
|
||||
return complex(0, 0), fmt.Errorf("should not reach this line!! code %x decoding %v", code, k)
|
||||
}
|
||||
+324
@@ -0,0 +1,324 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"reflect"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/internal/common"
|
||||
)
|
||||
|
||||
type decoder struct {
|
||||
r io.Reader
|
||||
asArray bool
|
||||
buf *common.Buffer
|
||||
common.Common
|
||||
}
|
||||
|
||||
// Decode analyzes the MessagePack-encoded data and stores
|
||||
// the result into the pointer of v.
|
||||
func Decode(r io.Reader, v interface{}, asArray bool) error {
|
||||
|
||||
if r == nil {
|
||||
return fmt.Errorf("reader is nil")
|
||||
}
|
||||
rv := reflect.ValueOf(v)
|
||||
if rv.Kind() != reflect.Ptr {
|
||||
return fmt.Errorf("holder must set pointer value. but got: %t", v)
|
||||
}
|
||||
|
||||
rv = rv.Elem()
|
||||
|
||||
d := decoder{r: r,
|
||||
buf: common.GetBuffer(),
|
||||
asArray: asArray,
|
||||
}
|
||||
err := d.decode(rv)
|
||||
common.PutBuffer(d.buf)
|
||||
return err
|
||||
}
|
||||
|
||||
func (d *decoder) decode(rv reflect.Value) error {
|
||||
code, err := d.readSize1()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return d.decodeWithCode(code, rv)
|
||||
}
|
||||
|
||||
func (d *decoder) decodeWithCode(code byte, rv reflect.Value) error {
|
||||
k := rv.Kind()
|
||||
switch k {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
v, err := d.asIntWithCode(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetInt(v)
|
||||
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
v, err := d.asUintWithCode(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetUint(v)
|
||||
|
||||
case reflect.Float32:
|
||||
v, err := d.asFloat32WithCode(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetFloat(float64(v))
|
||||
|
||||
case reflect.Float64:
|
||||
v, err := d.asFloat64WithCode(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetFloat(v)
|
||||
|
||||
case reflect.String:
|
||||
// byte slice
|
||||
if d.isCodeBin(code) {
|
||||
v, err := d.asBinStringWithCode(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetString(v)
|
||||
return nil
|
||||
}
|
||||
v, err := d.asStringWithCode(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetString(v)
|
||||
|
||||
case reflect.Bool:
|
||||
v, err := d.asBoolWithCode(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetBool(v)
|
||||
|
||||
case reflect.Slice:
|
||||
// nil
|
||||
if d.isCodeNil(code) {
|
||||
return nil
|
||||
}
|
||||
// byte slice
|
||||
if d.isCodeBin(code) {
|
||||
bs, err := d.asBinWithCode(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetBytes(bs)
|
||||
return nil
|
||||
}
|
||||
// string to bytes
|
||||
if d.isCodeString(code) {
|
||||
l, err := d.stringByteLength(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bs, err := d.asStringByteByLength(l, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetBytes(bs)
|
||||
return nil
|
||||
}
|
||||
|
||||
// get slice length
|
||||
l, err := d.sliceLength(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// check fixed type
|
||||
found, err := d.asFixedSlice(rv, l)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if found {
|
||||
return nil
|
||||
}
|
||||
|
||||
// create slice dynamically
|
||||
tmpSlice := reflect.MakeSlice(rv.Type(), l, l)
|
||||
for i := 0; i < l; i++ {
|
||||
v := tmpSlice.Index(i)
|
||||
if v.Kind() == reflect.Struct {
|
||||
structCode, err := d.readSize1()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err = d.setStruct(structCode, v, k); err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
if err = d.decode(v); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
rv.Set(tmpSlice)
|
||||
|
||||
case reflect.Complex64:
|
||||
v, err := d.asComplex64(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetComplex(complex128(v))
|
||||
|
||||
case reflect.Complex128:
|
||||
v, err := d.asComplex128(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rv.SetComplex(v)
|
||||
|
||||
case reflect.Array:
|
||||
// nil
|
||||
if d.isCodeNil(code) {
|
||||
return nil
|
||||
}
|
||||
// byte slice
|
||||
if d.isCodeBin(code) {
|
||||
bs, err := d.asBinWithCode(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(bs) > rv.Len() {
|
||||
return fmt.Errorf("%v len is %d, but msgpack has %d elements", rv.Type(), rv.Len(), len(bs))
|
||||
}
|
||||
for i, b := range bs {
|
||||
rv.Index(i).SetUint(uint64(b))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
// string to bytes
|
||||
if d.isCodeString(code) {
|
||||
l, err := d.stringByteLength(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if l > rv.Len() {
|
||||
return fmt.Errorf("%v len is %d, but msgpack has %d elements", rv.Type(), rv.Len(), l)
|
||||
}
|
||||
bs, err := d.asStringByteByLength(l, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for i, b := range bs {
|
||||
rv.Index(i).SetUint(uint64(b))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// get slice length
|
||||
l, err := d.sliceLength(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if l > rv.Len() {
|
||||
return fmt.Errorf("%v len is %d, but msgpack has %d elements", rv.Type(), rv.Len(), l)
|
||||
}
|
||||
|
||||
// create array dynamically
|
||||
for i := 0; i < l; i++ {
|
||||
err = d.decode(rv.Index(i))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
case reflect.Map:
|
||||
// nil
|
||||
if d.isCodeNil(code) {
|
||||
return nil
|
||||
}
|
||||
|
||||
// get map length
|
||||
l, err := d.mapLength(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// check fixed type
|
||||
found, err := d.asFixedMap(rv, l)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if found {
|
||||
return nil
|
||||
}
|
||||
|
||||
// create dynamically
|
||||
key := rv.Type().Key()
|
||||
value := rv.Type().Elem()
|
||||
if rv.IsNil() {
|
||||
rv.Set(reflect.MakeMapWithSize(rv.Type(), l))
|
||||
}
|
||||
for i := 0; i < l; i++ {
|
||||
k := reflect.New(key).Elem()
|
||||
v := reflect.New(value).Elem()
|
||||
err = d.decode(k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = d.decode(v)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
rv.SetMapIndex(k, v)
|
||||
}
|
||||
|
||||
case reflect.Struct:
|
||||
err := d.setStruct(code, rv, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
case reflect.Ptr:
|
||||
// nil
|
||||
if d.isCodeNil(code) {
|
||||
return nil
|
||||
}
|
||||
|
||||
if rv.Elem().Kind() == reflect.Invalid {
|
||||
n := reflect.New(rv.Type().Elem())
|
||||
rv.Set(n)
|
||||
}
|
||||
|
||||
err := d.decodeWithCode(code, rv.Elem())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
case reflect.Interface:
|
||||
if rv.Elem().Kind() == reflect.Ptr {
|
||||
err := d.decode(rv.Elem())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
v, err := d.asInterfaceWithCode(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if v != nil {
|
||||
rv.Set(reflect.ValueOf(v))
|
||||
}
|
||||
}
|
||||
|
||||
default:
|
||||
return fmt.Errorf("type(%v) is unsupported", rv.Kind())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *decoder) errorTemplate(code byte, k reflect.Kind) error {
|
||||
return fmt.Errorf("msgpack : invalid code %x decoding %v", code, k)
|
||||
}
|
||||
+160
@@ -0,0 +1,160 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
"github.com/shamaton/msgpack/v2/ext"
|
||||
"github.com/shamaton/msgpack/v2/time"
|
||||
)
|
||||
|
||||
var extCoderMap = map[int8]ext.StreamDecoder{time.StreamDecoder.Code(): time.StreamDecoder}
|
||||
var extCoders = []ext.StreamDecoder{time.StreamDecoder}
|
||||
|
||||
// AddExtDecoder adds decoders for extension types.
|
||||
func AddExtDecoder(f ext.StreamDecoder) {
|
||||
// ignore time
|
||||
if f.Code() == time.Decoder.Code() {
|
||||
return
|
||||
}
|
||||
|
||||
_, ok := extCoderMap[f.Code()]
|
||||
if !ok {
|
||||
extCoderMap[f.Code()] = f
|
||||
updateExtCoders()
|
||||
}
|
||||
}
|
||||
|
||||
// RemoveExtDecoder removes decoders for extension types.
|
||||
func RemoveExtDecoder(f ext.StreamDecoder) {
|
||||
// ignore time
|
||||
if f.Code() == time.Decoder.Code() {
|
||||
return
|
||||
}
|
||||
|
||||
_, ok := extCoderMap[f.Code()]
|
||||
if ok {
|
||||
delete(extCoderMap, f.Code())
|
||||
updateExtCoders()
|
||||
}
|
||||
}
|
||||
|
||||
func updateExtCoders() {
|
||||
extCoders = make([]ext.StreamDecoder, len(extCoderMap))
|
||||
i := 0
|
||||
for k := range extCoderMap {
|
||||
extCoders[i] = extCoderMap[k]
|
||||
i++
|
||||
}
|
||||
}
|
||||
|
||||
func (d *decoder) readIfExtType(code byte) (innerType int8, data []byte, err error) {
|
||||
switch code {
|
||||
case def.Fixext1:
|
||||
typ, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
v, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
return int8(typ), []byte{v}, nil
|
||||
|
||||
case def.Fixext2:
|
||||
typ, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
data, err = d.readSize2()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
return int8(typ), data, nil
|
||||
|
||||
case def.Fixext4:
|
||||
typ, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
data, err = d.readSize4()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
return int8(typ), data, nil
|
||||
|
||||
case def.Fixext8:
|
||||
typ, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
data, err = d.readSize8()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
return int8(typ), data, nil
|
||||
|
||||
case def.Fixext16:
|
||||
typ, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
data, err = d.readSize16()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
return int8(typ), data, nil
|
||||
|
||||
case def.Ext8:
|
||||
bs, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
size := int(bs)
|
||||
|
||||
typ, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
data, err = d.readSizeN(size)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
return int8(typ), data, nil
|
||||
|
||||
case def.Ext16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
size := int(binary.BigEndian.Uint16(bs))
|
||||
|
||||
typ, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
data, err = d.readSizeN(size)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
return int8(typ), data, nil
|
||||
|
||||
case def.Ext32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
size := int(binary.BigEndian.Uint32(bs))
|
||||
|
||||
typ, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
data, err = d.readSizeN(size)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
return int8(typ), data, nil
|
||||
}
|
||||
|
||||
return 0, nil, nil
|
||||
}
|
||||
+93
@@ -0,0 +1,93 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"math"
|
||||
"reflect"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
func (d *decoder) asFloat32(k reflect.Kind) (float32, error) {
|
||||
code, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return d.asFloat32WithCode(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asFloat32WithCode(code byte, k reflect.Kind) (float32, error) {
|
||||
switch {
|
||||
case code == def.Float32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := math.Float32frombits(binary.BigEndian.Uint32(bs))
|
||||
return v, nil
|
||||
|
||||
case d.isPositiveFixNum(code), code == def.Uint8, code == def.Uint16, code == def.Uint32, code == def.Uint64:
|
||||
v, err := d.asUintWithCode(code, k)
|
||||
if err != nil {
|
||||
break
|
||||
}
|
||||
return float32(v), nil
|
||||
|
||||
case d.isNegativeFixNum(code), code == def.Int8, code == def.Int16, code == def.Int32, code == def.Int64:
|
||||
v, err := d.asIntWithCode(code, k)
|
||||
if err != nil {
|
||||
break
|
||||
}
|
||||
return float32(v), nil
|
||||
|
||||
case code == def.Nil:
|
||||
return 0, nil
|
||||
}
|
||||
return 0, d.errorTemplate(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asFloat64(k reflect.Kind) (float64, error) {
|
||||
code, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return d.asFloat64WithCode(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asFloat64WithCode(code byte, k reflect.Kind) (float64, error) {
|
||||
switch {
|
||||
case code == def.Float64:
|
||||
bs, err := d.readSize8()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := math.Float64frombits(binary.BigEndian.Uint64(bs))
|
||||
return v, nil
|
||||
|
||||
case code == def.Float32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := math.Float32frombits(binary.BigEndian.Uint32(bs))
|
||||
return float64(v), nil
|
||||
|
||||
case d.isPositiveFixNum(code), code == def.Uint8, code == def.Uint16, code == def.Uint32, code == def.Uint64:
|
||||
v, err := d.asUintWithCode(code, k)
|
||||
if err != nil {
|
||||
break
|
||||
}
|
||||
return float64(v), nil
|
||||
|
||||
case d.isNegativeFixNum(code), code == def.Int8, code == def.Int16, code == def.Int32, code == def.Int64:
|
||||
v, err := d.asIntWithCode(code, k)
|
||||
if err != nil {
|
||||
break
|
||||
}
|
||||
return float64(v), nil
|
||||
|
||||
case code == def.Nil:
|
||||
return 0, nil
|
||||
}
|
||||
return 0, d.errorTemplate(code, k)
|
||||
}
|
||||
+113
@@ -0,0 +1,113 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"reflect"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
func (d *decoder) isPositiveFixNum(v byte) bool {
|
||||
return def.PositiveFixIntMin <= v && v <= def.PositiveFixIntMax
|
||||
}
|
||||
|
||||
func (d *decoder) isNegativeFixNum(v byte) bool {
|
||||
return def.NegativeFixintMin <= int8(v) && int8(v) <= def.NegativeFixintMax
|
||||
}
|
||||
|
||||
func (d *decoder) asInt(k reflect.Kind) (int64, error) {
|
||||
code, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return d.asIntWithCode(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asIntWithCode(code byte, k reflect.Kind) (int64, error) {
|
||||
switch {
|
||||
case d.isPositiveFixNum(code):
|
||||
return int64(code), nil
|
||||
|
||||
case d.isNegativeFixNum(code):
|
||||
return int64(int8(code)), nil
|
||||
|
||||
case code == def.Uint8:
|
||||
b, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int64(b), nil
|
||||
|
||||
case code == def.Int8:
|
||||
b, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int64(int8(b)), nil
|
||||
|
||||
case code == def.Uint16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := binary.BigEndian.Uint16(bs)
|
||||
return int64(v), nil
|
||||
|
||||
case code == def.Int16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := int16(binary.BigEndian.Uint16(bs))
|
||||
return int64(v), nil
|
||||
|
||||
case code == def.Uint32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := binary.BigEndian.Uint32(bs)
|
||||
return int64(v), nil
|
||||
|
||||
case code == def.Int32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := int32(binary.BigEndian.Uint32(bs))
|
||||
return int64(v), nil
|
||||
|
||||
case code == def.Uint64:
|
||||
bs, err := d.readSize8()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int64(binary.BigEndian.Uint64(bs)), nil
|
||||
|
||||
case code == def.Int64:
|
||||
bs, err := d.readSize8()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int64(binary.BigEndian.Uint64(bs)), nil
|
||||
|
||||
case code == def.Float32:
|
||||
v, err := d.asFloat32WithCode(code, k)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int64(v), nil
|
||||
|
||||
case code == def.Float64:
|
||||
v, err := d.asFloat64WithCode(code, k)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int64(v), nil
|
||||
|
||||
case code == def.Nil:
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
return 0, d.errorTemplate(code, k)
|
||||
}
|
||||
+177
@@ -0,0 +1,177 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
func (d *decoder) asInterface(k reflect.Kind) (interface{}, error) {
|
||||
code, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return d.asInterfaceWithCode(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asInterfaceWithCode(code byte, k reflect.Kind) (interface{}, error) {
|
||||
switch {
|
||||
case code == def.Nil:
|
||||
return nil, nil
|
||||
|
||||
case code == def.True, code == def.False:
|
||||
v, err := d.asBoolWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v, nil
|
||||
|
||||
case d.isPositiveFixNum(code), code == def.Uint8:
|
||||
v, err := d.asUintWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return uint8(v), err
|
||||
case code == def.Uint16:
|
||||
v, err := d.asUintWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return uint16(v), err
|
||||
case code == def.Uint32:
|
||||
v, err := d.asUintWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return uint32(v), err
|
||||
case code == def.Uint64:
|
||||
v, err := d.asUintWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v, err
|
||||
|
||||
case d.isNegativeFixNum(code), code == def.Int8:
|
||||
v, err := d.asIntWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return int8(v), err
|
||||
case code == def.Int16:
|
||||
v, err := d.asIntWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return int16(v), err
|
||||
case code == def.Int32:
|
||||
v, err := d.asIntWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return int32(v), err
|
||||
case code == def.Int64:
|
||||
v, err := d.asIntWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v, err
|
||||
|
||||
case code == def.Float32:
|
||||
v, err := d.asFloat32WithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v, err
|
||||
case code == def.Float64:
|
||||
v, err := d.asFloat64WithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v, err
|
||||
|
||||
case d.isFixString(code), code == def.Str8, code == def.Str16, code == def.Str32:
|
||||
v, err := d.asStringWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v, err
|
||||
|
||||
case code == def.Bin8, code == def.Bin16, code == def.Bin32:
|
||||
v, err := d.asBinWithCode(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v, err
|
||||
|
||||
case d.isFixSlice(code), code == def.Array16, code == def.Array32:
|
||||
l, err := d.sliceLength(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
v := make([]interface{}, l)
|
||||
for i := 0; i < l; i++ {
|
||||
vv, err := d.asInterface(k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v[i] = vv
|
||||
}
|
||||
return v, nil
|
||||
|
||||
case d.isFixMap(code), code == def.Map16, code == def.Map32:
|
||||
l, err := d.mapLength(code, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
v := make(map[interface{}]interface{}, l)
|
||||
for i := 0; i < l; i++ {
|
||||
keyCode, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
if d.canSetAsMapKey(keyCode) != nil {
|
||||
return nil, err
|
||||
}
|
||||
key, err := d.asInterfaceWithCode(keyCode, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
value, err := d.asInterface(k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v[key] = value
|
||||
}
|
||||
return v, nil
|
||||
}
|
||||
|
||||
// ext
|
||||
extInnerType, extData, err := d.readIfExtType(code)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for i := range extCoders {
|
||||
if extCoders[i].IsType(code, extInnerType, len(extData)) {
|
||||
v, err := extCoders[i].ToValue(code, extData, k)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v, nil
|
||||
}
|
||||
}
|
||||
return nil, d.errorTemplate(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) canSetAsMapKey(code byte) error {
|
||||
switch {
|
||||
case d.isFixSlice(code), code == def.Array16, code == def.Array32:
|
||||
return fmt.Errorf("can not use slice code for map key/ code: %x", code)
|
||||
case d.isFixMap(code), code == def.Map16, code == def.Map32:
|
||||
return fmt.Errorf("can not use map code for map key/ code: %x", code)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
+698
@@ -0,0 +1,698 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"reflect"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
var (
|
||||
typeMapStringInt = reflect.TypeOf(map[string]int{})
|
||||
typeMapStringInt8 = reflect.TypeOf(map[string]int8{})
|
||||
typeMapStringInt16 = reflect.TypeOf(map[string]int16{})
|
||||
typeMapStringInt32 = reflect.TypeOf(map[string]int32{})
|
||||
typeMapStringInt64 = reflect.TypeOf(map[string]int64{})
|
||||
|
||||
typeMapStringUint = reflect.TypeOf(map[string]uint{})
|
||||
typeMapStringUint8 = reflect.TypeOf(map[string]uint8{})
|
||||
typeMapStringUint16 = reflect.TypeOf(map[string]uint16{})
|
||||
typeMapStringUint32 = reflect.TypeOf(map[string]uint32{})
|
||||
typeMapStringUint64 = reflect.TypeOf(map[string]uint64{})
|
||||
|
||||
typeMapStringFloat32 = reflect.TypeOf(map[string]float32{})
|
||||
typeMapStringFloat64 = reflect.TypeOf(map[string]float64{})
|
||||
|
||||
typeMapStringBool = reflect.TypeOf(map[string]bool{})
|
||||
typeMapStringString = reflect.TypeOf(map[string]string{})
|
||||
|
||||
typeMapIntString = reflect.TypeOf(map[int]string{})
|
||||
typeMapInt8String = reflect.TypeOf(map[int8]string{})
|
||||
typeMapInt16String = reflect.TypeOf(map[int16]string{})
|
||||
typeMapInt32String = reflect.TypeOf(map[int32]string{})
|
||||
typeMapInt64String = reflect.TypeOf(map[int64]string{})
|
||||
typeMapIntBool = reflect.TypeOf(map[int]bool{})
|
||||
typeMapInt8Bool = reflect.TypeOf(map[int8]bool{})
|
||||
typeMapInt16Bool = reflect.TypeOf(map[int16]bool{})
|
||||
typeMapInt32Bool = reflect.TypeOf(map[int32]bool{})
|
||||
typeMapInt64Bool = reflect.TypeOf(map[int64]bool{})
|
||||
|
||||
typeMapUintString = reflect.TypeOf(map[uint]string{})
|
||||
typeMapUint8String = reflect.TypeOf(map[uint8]string{})
|
||||
typeMapUint16String = reflect.TypeOf(map[uint16]string{})
|
||||
typeMapUint32String = reflect.TypeOf(map[uint32]string{})
|
||||
typeMapUint64String = reflect.TypeOf(map[uint64]string{})
|
||||
typeMapUintBool = reflect.TypeOf(map[uint]bool{})
|
||||
typeMapUint8Bool = reflect.TypeOf(map[uint8]bool{})
|
||||
typeMapUint16Bool = reflect.TypeOf(map[uint16]bool{})
|
||||
typeMapUint32Bool = reflect.TypeOf(map[uint32]bool{})
|
||||
typeMapUint64Bool = reflect.TypeOf(map[uint64]bool{})
|
||||
|
||||
typeMapFloat32String = reflect.TypeOf(map[float32]string{})
|
||||
typeMapFloat64String = reflect.TypeOf(map[float64]string{})
|
||||
typeMapFloat32Bool = reflect.TypeOf(map[float32]bool{})
|
||||
typeMapFloat64Bool = reflect.TypeOf(map[float64]bool{})
|
||||
)
|
||||
|
||||
func (d *decoder) isFixMap(v byte) bool {
|
||||
return def.FixMap <= v && v <= def.FixMap+0x0f
|
||||
}
|
||||
|
||||
func (d *decoder) mapLength(code byte, k reflect.Kind) (int, error) {
|
||||
switch {
|
||||
case d.isFixMap(code):
|
||||
return int(code - def.FixMap), nil
|
||||
case code == def.Map16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int(binary.BigEndian.Uint16(bs)), nil
|
||||
case code == def.Map32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int(binary.BigEndian.Uint32(bs)), nil
|
||||
}
|
||||
|
||||
return 0, d.errorTemplate(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asFixedMap(rv reflect.Value, l int) (bool, error) {
|
||||
t := rv.Type()
|
||||
|
||||
keyKind := t.Key().Kind()
|
||||
valueKind := t.Elem().Kind()
|
||||
|
||||
switch t {
|
||||
case typeMapStringInt:
|
||||
m := make(map[string]int, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asInt(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = int(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringUint:
|
||||
m := make(map[string]uint, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asUint(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = uint(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringFloat32:
|
||||
m := make(map[string]float32, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asFloat32(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringFloat64:
|
||||
m := make(map[string]float64, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asFloat64(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringBool:
|
||||
m := make(map[string]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringString:
|
||||
m := make(map[string]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringInt8:
|
||||
m := make(map[string]int8, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asInt(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = int8(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringInt16:
|
||||
m := make(map[string]int16, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asInt(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = int16(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringInt32:
|
||||
m := make(map[string]int32, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asInt(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = int32(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringInt64:
|
||||
m := make(map[string]int64, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asInt(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringUint8:
|
||||
m := make(map[string]uint8, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asUint(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = uint8(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
case typeMapStringUint16:
|
||||
m := make(map[string]uint16, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asUint(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = uint16(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringUint32:
|
||||
m := make(map[string]uint32, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asUint(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = uint32(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapStringUint64:
|
||||
m := make(map[string]uint64, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asString(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asUint(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapIntString:
|
||||
m := make(map[int]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asInt(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[int(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapInt8String:
|
||||
m := make(map[int8]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asInt(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[int8(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapInt16String:
|
||||
m := make(map[int16]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asInt(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[int16(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapInt32String:
|
||||
m := make(map[int32]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asInt(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[int32(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapInt64String:
|
||||
m := make(map[int64]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asInt(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapIntBool:
|
||||
m := make(map[int]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asInt(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[int(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapInt8Bool:
|
||||
m := make(map[int8]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asInt(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[int8(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapInt16Bool:
|
||||
m := make(map[int16]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asInt(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[int16(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapInt32Bool:
|
||||
m := make(map[int32]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asInt(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[int32(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapInt64Bool:
|
||||
m := make(map[int64]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asInt(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapUintString:
|
||||
m := make(map[uint]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asUint(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[uint(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapUint8String:
|
||||
m := make(map[uint8]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asUint(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[uint8(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapUint16String:
|
||||
m := make(map[uint16]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asUint(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[uint16(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapUint32String:
|
||||
m := make(map[uint32]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asUint(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[uint32(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapUint64String:
|
||||
m := make(map[uint64]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asUint(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapUintBool:
|
||||
m := make(map[uint]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asUint(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[uint(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapUint8Bool:
|
||||
m := make(map[uint8]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asUint(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[uint8(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapUint16Bool:
|
||||
m := make(map[uint16]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asUint(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[uint16(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapUint32Bool:
|
||||
m := make(map[uint32]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asUint(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[uint32(k)] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapUint64Bool:
|
||||
m := make(map[uint64]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asUint(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapFloat32String:
|
||||
m := make(map[float32]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asFloat32(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapFloat64String:
|
||||
m := make(map[float64]string, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asFloat64(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asString(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapFloat32Bool:
|
||||
m := make(map[float32]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asFloat32(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
|
||||
case typeMapFloat64Bool:
|
||||
m := make(map[float64]bool, l)
|
||||
for i := 0; i < l; i++ {
|
||||
k, err := d.asFloat64(keyKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
v, err := d.asBool(valueKind)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
m[k] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(m))
|
||||
return true, nil
|
||||
}
|
||||
|
||||
return false, nil
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
package decoding
|
||||
|
||||
import "github.com/shamaton/msgpack/v2/def"
|
||||
|
||||
func (d *decoder) isCodeNil(v byte) bool {
|
||||
return def.Nil == v
|
||||
}
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
package decoding
|
||||
|
||||
func (d *decoder) readSize1() (byte, error) {
|
||||
if _, err := d.r.Read(d.buf.B1); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return d.buf.B1[0], nil
|
||||
}
|
||||
|
||||
func (d *decoder) readSize2() ([]byte, error) {
|
||||
if _, err := d.r.Read(d.buf.B2); err != nil {
|
||||
return emptyBytes, err
|
||||
}
|
||||
return d.buf.B2, nil
|
||||
}
|
||||
|
||||
func (d *decoder) readSize4() ([]byte, error) {
|
||||
if _, err := d.r.Read(d.buf.B4); err != nil {
|
||||
return emptyBytes, err
|
||||
}
|
||||
return d.buf.B4, nil
|
||||
}
|
||||
|
||||
func (d *decoder) readSize8() ([]byte, error) {
|
||||
if _, err := d.r.Read(d.buf.B8); err != nil {
|
||||
return emptyBytes, err
|
||||
}
|
||||
return d.buf.B8, nil
|
||||
}
|
||||
|
||||
func (d *decoder) readSize16() ([]byte, error) {
|
||||
if _, err := d.r.Read(d.buf.B16); err != nil {
|
||||
return emptyBytes, err
|
||||
}
|
||||
return d.buf.B16, nil
|
||||
}
|
||||
|
||||
func (d *decoder) readSizeN(n int) ([]byte, error) {
|
||||
var b []byte
|
||||
if n <= len(d.buf.Data) {
|
||||
b = d.buf.Data[:n]
|
||||
} else {
|
||||
d.buf.Data = append(d.buf.Data, make([]byte, n-len(d.buf.Data))...)
|
||||
b = d.buf.Data
|
||||
}
|
||||
if _, err := d.r.Read(b); err != nil {
|
||||
return emptyBytes, err
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
+230
@@ -0,0 +1,230 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"reflect"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
var (
|
||||
typeIntSlice = reflect.TypeOf([]int{})
|
||||
typeInt8Slice = reflect.TypeOf([]int8{})
|
||||
typeInt16Slice = reflect.TypeOf([]int16{})
|
||||
typeInt32Slice = reflect.TypeOf([]int32{})
|
||||
typeInt64Slice = reflect.TypeOf([]int64{})
|
||||
|
||||
typeUintSlice = reflect.TypeOf([]uint{})
|
||||
typeUint8Slice = reflect.TypeOf([]uint8{})
|
||||
typeUint16Slice = reflect.TypeOf([]uint16{})
|
||||
typeUint32Slice = reflect.TypeOf([]uint32{})
|
||||
typeUint64Slice = reflect.TypeOf([]uint64{})
|
||||
|
||||
typeFloat32Slice = reflect.TypeOf([]float32{})
|
||||
typeFloat64Slice = reflect.TypeOf([]float64{})
|
||||
|
||||
typeStringSlice = reflect.TypeOf([]string{})
|
||||
|
||||
typeBoolSlice = reflect.TypeOf([]bool{})
|
||||
)
|
||||
|
||||
func (d *decoder) isFixSlice(v byte) bool {
|
||||
return def.FixArray <= v && v <= def.FixArray+0x0f
|
||||
}
|
||||
|
||||
func (d *decoder) sliceLength(code byte, k reflect.Kind) (int, error) {
|
||||
switch {
|
||||
case d.isFixSlice(code):
|
||||
return int(code - def.FixArray), nil
|
||||
case code == def.Array16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int(binary.BigEndian.Uint16(bs)), nil
|
||||
case code == def.Array32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int(binary.BigEndian.Uint32(bs)), nil
|
||||
}
|
||||
return 0, d.errorTemplate(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asFixedSlice(rv reflect.Value, l int) (bool, error) {
|
||||
t := rv.Type()
|
||||
k := t.Elem().Kind()
|
||||
|
||||
switch t {
|
||||
case typeIntSlice:
|
||||
sli := make([]int, l)
|
||||
for i := range sli {
|
||||
v, err := d.asInt(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = int(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeUintSlice:
|
||||
sli := make([]uint, l)
|
||||
for i := range sli {
|
||||
v, err := d.asUint(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = uint(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeStringSlice:
|
||||
sli := make([]string, l)
|
||||
for i := range sli {
|
||||
v, err := d.asString(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeBoolSlice:
|
||||
sli := make([]bool, l)
|
||||
for i := range sli {
|
||||
v, err := d.asBool(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeFloat32Slice:
|
||||
sli := make([]float32, l)
|
||||
for i := range sli {
|
||||
v, err := d.asFloat32(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeFloat64Slice:
|
||||
sli := make([]float64, l)
|
||||
for i := range sli {
|
||||
v, err := d.asFloat64(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeInt8Slice:
|
||||
sli := make([]int8, l)
|
||||
for i := range sli {
|
||||
v, err := d.asInt(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = int8(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeInt16Slice:
|
||||
sli := make([]int16, l)
|
||||
for i := range sli {
|
||||
v, err := d.asInt(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = int16(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeInt32Slice:
|
||||
sli := make([]int32, l)
|
||||
for i := range sli {
|
||||
v, err := d.asInt(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = int32(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeInt64Slice:
|
||||
sli := make([]int64, l)
|
||||
for i := range sli {
|
||||
v, err := d.asInt(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeUint8Slice:
|
||||
sli := make([]uint8, l)
|
||||
for i := range sli {
|
||||
v, err := d.asUint(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = uint8(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeUint16Slice:
|
||||
sli := make([]uint16, l)
|
||||
for i := range sli {
|
||||
v, err := d.asUint(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = uint16(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeUint32Slice:
|
||||
sli := make([]uint32, l)
|
||||
for i := range sli {
|
||||
v, err := d.asUint(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = uint32(v)
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
|
||||
case typeUint64Slice:
|
||||
sli := make([]uint64, l)
|
||||
for i := range sli {
|
||||
v, err := d.asUint(k)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
sli[i] = v
|
||||
}
|
||||
rv.Set(reflect.ValueOf(sli))
|
||||
return true, nil
|
||||
}
|
||||
|
||||
return false, nil
|
||||
}
|
||||
+88
@@ -0,0 +1,88 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"reflect"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
var emptyString = ""
|
||||
var emptyBytes = []byte{}
|
||||
|
||||
func (d *decoder) isCodeString(code byte) bool {
|
||||
return d.isFixString(code) || code == def.Str8 || code == def.Str16 || code == def.Str32
|
||||
}
|
||||
|
||||
func (d *decoder) isFixString(v byte) bool {
|
||||
return def.FixStr <= v && v <= def.FixStr+0x1f
|
||||
}
|
||||
|
||||
func (d *decoder) stringByteLength(code byte, k reflect.Kind) (int, error) {
|
||||
if def.FixStr <= code && code <= def.FixStr+0x1f {
|
||||
l := int(code - def.FixStr)
|
||||
return l, nil
|
||||
} else if code == def.Str8 {
|
||||
b, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int(b), nil
|
||||
} else if code == def.Str16 {
|
||||
b, err := d.readSize2()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int(binary.BigEndian.Uint16(b)), nil
|
||||
} else if code == def.Str32 {
|
||||
b, err := d.readSize4()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return int(binary.BigEndian.Uint32(b)), nil
|
||||
} else if code == def.Nil {
|
||||
return 0, nil
|
||||
}
|
||||
return 0, d.errorTemplate(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asString(k reflect.Kind) (string, error) {
|
||||
code, err := d.readSize1()
|
||||
if err != nil {
|
||||
return emptyString, err
|
||||
}
|
||||
return d.asStringWithCode(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asStringWithCode(code byte, k reflect.Kind) (string, error) {
|
||||
bs, err := d.asStringByteWithCode(code, k)
|
||||
if err != nil {
|
||||
return emptyString, err
|
||||
}
|
||||
return string(bs), nil
|
||||
}
|
||||
|
||||
func (d *decoder) asStringByte(k reflect.Kind) ([]byte, error) {
|
||||
code, err := d.readSize1()
|
||||
if err != nil {
|
||||
return emptyBytes, err
|
||||
}
|
||||
return d.asStringByteWithCode(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asStringByteWithCode(code byte, k reflect.Kind) ([]byte, error) {
|
||||
l, err := d.stringByteLength(code, k)
|
||||
if err != nil {
|
||||
return emptyBytes, err
|
||||
}
|
||||
|
||||
return d.asStringByteByLength(l, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asStringByteByLength(l int, _ reflect.Kind) ([]byte, error) {
|
||||
if l < 1 {
|
||||
return emptyBytes, nil
|
||||
}
|
||||
|
||||
return d.readSizeN(l)
|
||||
}
|
||||
+302
@@ -0,0 +1,302 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"reflect"
|
||||
"sync"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
type structCacheTypeMap struct {
|
||||
keys [][]byte
|
||||
indexes []int
|
||||
}
|
||||
|
||||
type structCacheTypeArray struct {
|
||||
m []int
|
||||
}
|
||||
|
||||
// struct cache map
|
||||
var mapSCTM = sync.Map{}
|
||||
var mapSCTA = sync.Map{}
|
||||
|
||||
func (d *decoder) setStruct(code byte, rv reflect.Value, k reflect.Kind) error {
|
||||
if len(extCoders) > 0 {
|
||||
innerType, data, err := d.readIfExtType(code)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if data != nil {
|
||||
for i := range extCoders {
|
||||
if extCoders[i].IsType(code, innerType, len(data)) {
|
||||
v, err := extCoders[i].ToValue(code, data, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Validate that the receptacle is of the right value type.
|
||||
if rv.Type() == reflect.TypeOf(v) {
|
||||
rv.Set(reflect.ValueOf(v))
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if d.asArray {
|
||||
return d.setStructFromArray(code, rv, k)
|
||||
}
|
||||
return d.setStructFromMap(code, rv, k)
|
||||
}
|
||||
|
||||
func (d *decoder) setStructFromArray(code byte, rv reflect.Value, k reflect.Kind) error {
|
||||
// get length
|
||||
l, err := d.sliceLength(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// find or create reference
|
||||
var scta *structCacheTypeArray
|
||||
cache, findCache := mapSCTA.Load(rv.Type())
|
||||
if !findCache {
|
||||
scta = &structCacheTypeArray{}
|
||||
for i := 0; i < rv.NumField(); i++ {
|
||||
if ok, _ := d.CheckField(rv.Type().Field(i)); ok {
|
||||
scta.m = append(scta.m, i)
|
||||
}
|
||||
}
|
||||
mapSCTA.Store(rv.Type(), scta)
|
||||
} else {
|
||||
scta = cache.(*structCacheTypeArray)
|
||||
}
|
||||
// set value
|
||||
for i := 0; i < l; i++ {
|
||||
if i < len(scta.m) {
|
||||
err = d.decode(rv.Field(scta.m[i]))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
err = d.jumpOffset()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *decoder) setStructFromMap(code byte, rv reflect.Value, k reflect.Kind) error {
|
||||
// get length
|
||||
l, err := d.mapLength(code, k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
var sctm *structCacheTypeMap
|
||||
cache, cacheFind := mapSCTM.Load(rv.Type())
|
||||
if !cacheFind {
|
||||
sctm = &structCacheTypeMap{}
|
||||
for i := 0; i < rv.NumField(); i++ {
|
||||
if ok, name := d.CheckField(rv.Type().Field(i)); ok {
|
||||
sctm.keys = append(sctm.keys, []byte(name))
|
||||
sctm.indexes = append(sctm.indexes, i)
|
||||
}
|
||||
}
|
||||
mapSCTM.Store(rv.Type(), sctm)
|
||||
} else {
|
||||
sctm = cache.(*structCacheTypeMap)
|
||||
}
|
||||
|
||||
for i := 0; i < l; i++ {
|
||||
dataKey, err := d.asStringByte(k)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
fieldIndex := -1
|
||||
for keyIndex, keyBytes := range sctm.keys {
|
||||
if len(keyBytes) != len(dataKey) {
|
||||
continue
|
||||
}
|
||||
|
||||
fieldIndex = sctm.indexes[keyIndex]
|
||||
for dataIndex := range dataKey {
|
||||
if dataKey[dataIndex] != keyBytes[dataIndex] {
|
||||
fieldIndex = -1
|
||||
break
|
||||
}
|
||||
}
|
||||
if fieldIndex >= 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if fieldIndex >= 0 {
|
||||
err = d.decode(rv.Field(fieldIndex))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
err = d.jumpOffset()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *decoder) jumpOffset() error {
|
||||
code, err := d.readSize1()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
switch {
|
||||
case code == def.True, code == def.False, code == def.Nil:
|
||||
// do nothing
|
||||
|
||||
case d.isPositiveFixNum(code) || d.isNegativeFixNum(code):
|
||||
// do nothing
|
||||
case code == def.Uint8, code == def.Int8:
|
||||
_, err = d.readSize1()
|
||||
return err
|
||||
case code == def.Uint16, code == def.Int16:
|
||||
_, err = d.readSize2()
|
||||
return err
|
||||
case code == def.Uint32, code == def.Int32, code == def.Float32:
|
||||
_, err = d.readSize4()
|
||||
return err
|
||||
case code == def.Uint64, code == def.Int64, code == def.Float64:
|
||||
_, err = d.readSize8()
|
||||
return err
|
||||
|
||||
case d.isFixString(code):
|
||||
_, err = d.readSizeN(int(code - def.FixStr))
|
||||
return err
|
||||
case code == def.Str8, code == def.Bin8:
|
||||
b, err := d.readSize1()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = d.readSizeN(int(b))
|
||||
return err
|
||||
case code == def.Str16, code == def.Bin16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = d.readSizeN(int(binary.BigEndian.Uint16(bs)))
|
||||
return err
|
||||
case code == def.Str32, code == def.Bin32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = d.readSizeN(int(binary.BigEndian.Uint32(bs)))
|
||||
return err
|
||||
|
||||
case d.isFixSlice(code):
|
||||
l := int(code - def.FixArray)
|
||||
for i := 0; i < l; i++ {
|
||||
if err = d.jumpOffset(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
case code == def.Array16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
l := int(binary.BigEndian.Uint16(bs))
|
||||
for i := 0; i < l; i++ {
|
||||
if err = d.jumpOffset(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
case code == def.Array32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
l := int(binary.BigEndian.Uint32(bs))
|
||||
for i := 0; i < l; i++ {
|
||||
if err = d.jumpOffset(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
case d.isFixMap(code):
|
||||
l := int(code - def.FixMap)
|
||||
for i := 0; i < l*2; i++ {
|
||||
if err = d.jumpOffset(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
case code == def.Map16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
l := int(binary.BigEndian.Uint16(bs))
|
||||
for i := 0; i < l*2; i++ {
|
||||
if err = d.jumpOffset(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
case code == def.Map32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
l := int(binary.BigEndian.Uint32(bs))
|
||||
for i := 0; i < l*2; i++ {
|
||||
if err = d.jumpOffset(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
case code == def.Fixext1:
|
||||
_, err = d.readSizeN(def.Byte1 + def.Byte1)
|
||||
return err
|
||||
case code == def.Fixext2:
|
||||
_, err = d.readSizeN(def.Byte1 + def.Byte2)
|
||||
return err
|
||||
case code == def.Fixext4:
|
||||
_, err = d.readSizeN(def.Byte1 + def.Byte4)
|
||||
return err
|
||||
case code == def.Fixext8:
|
||||
_, err = d.readSizeN(def.Byte1 + def.Byte8)
|
||||
return err
|
||||
case code == def.Fixext16:
|
||||
_, err = d.readSizeN(def.Byte1 + def.Byte16)
|
||||
return err
|
||||
|
||||
case code == def.Ext8:
|
||||
b, err := d.readSize1()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = d.readSizeN(def.Byte1 + int(b))
|
||||
return err
|
||||
case code == def.Ext16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = d.readSizeN(def.Byte1 + int(binary.BigEndian.Uint16(bs)))
|
||||
return err
|
||||
case code == def.Ext32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = d.readSizeN(def.Byte1 + int(binary.BigEndian.Uint32(bs)))
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
+91
@@ -0,0 +1,91 @@
|
||||
package decoding
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"reflect"
|
||||
|
||||
"github.com/shamaton/msgpack/v2/def"
|
||||
)
|
||||
|
||||
func (d *decoder) asUint(k reflect.Kind) (uint64, error) {
|
||||
code, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return d.asUintWithCode(code, k)
|
||||
}
|
||||
|
||||
func (d *decoder) asUintWithCode(code byte, k reflect.Kind) (uint64, error) {
|
||||
switch {
|
||||
case d.isPositiveFixNum(code):
|
||||
return uint64(code), nil
|
||||
|
||||
case d.isNegativeFixNum(code):
|
||||
return uint64(int8(code)), nil
|
||||
|
||||
case code == def.Uint8:
|
||||
b, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return uint64(b), nil
|
||||
|
||||
case code == def.Int8:
|
||||
b, err := d.readSize1()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return uint64(int8(b)), nil
|
||||
|
||||
case code == def.Uint16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := binary.BigEndian.Uint16(bs)
|
||||
return uint64(v), nil
|
||||
|
||||
case code == def.Int16:
|
||||
bs, err := d.readSize2()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := int16(binary.BigEndian.Uint16(bs))
|
||||
return uint64(v), nil
|
||||
|
||||
case code == def.Uint32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := binary.BigEndian.Uint32(bs)
|
||||
return uint64(v), nil
|
||||
|
||||
case code == def.Int32:
|
||||
bs, err := d.readSize4()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := int32(binary.BigEndian.Uint32(bs))
|
||||
return uint64(v), nil
|
||||
|
||||
case code == def.Uint64:
|
||||
bs, err := d.readSize8()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return binary.BigEndian.Uint64(bs), nil
|
||||
|
||||
case code == def.Int64:
|
||||
bs, err := d.readSize8()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return binary.BigEndian.Uint64(bs), nil
|
||||
|
||||
case code == def.Nil:
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
return 0, d.errorTemplate(code, k)
|
||||
}
|
||||
Reference in New Issue
Block a user