diff options
Diffstat (limited to 'vendor/github.com/ugorji/go/codec/msgpack.mono.generated.go')
| -rw-r--r-- | vendor/github.com/ugorji/go/codec/msgpack.mono.generated.go | 8046 |
1 files changed, 8046 insertions, 0 deletions
diff --git a/vendor/github.com/ugorji/go/codec/msgpack.mono.generated.go b/vendor/github.com/ugorji/go/codec/msgpack.mono.generated.go new file mode 100644 index 000000000..ff2fe4af9 --- /dev/null +++ b/vendor/github.com/ugorji/go/codec/msgpack.mono.generated.go @@ -0,0 +1,8046 @@ +//go:build !notmono && !codec.notmono + +// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved. +// Use of this source code is governed by a MIT license found in the LICENSE file. + +package codec + +import ( + "encoding" + + "io" + "math" + "reflect" + "slices" + "sort" + "strconv" + "sync" + "time" + "unicode/utf8" +) + +type helperEncDriverMsgpackBytes struct{} +type encFnMsgpackBytes struct { + i encFnInfo + fe func(*encoderMsgpackBytes, *encFnInfo, reflect.Value) +} +type encRtidFnMsgpackBytes struct { + rtid uintptr + fn *encFnMsgpackBytes +} +type encoderMsgpackBytes struct { + dh helperEncDriverMsgpackBytes + fp *fastpathEsMsgpackBytes + e msgpackEncDriverBytes + encoderBase +} +type helperDecDriverMsgpackBytes struct{} +type decFnMsgpackBytes struct { + i decFnInfo + fd func(*decoderMsgpackBytes, *decFnInfo, reflect.Value) +} +type decRtidFnMsgpackBytes struct { + rtid uintptr + fn *decFnMsgpackBytes +} +type decoderMsgpackBytes struct { + dh helperDecDriverMsgpackBytes + fp *fastpathDsMsgpackBytes + d msgpackDecDriverBytes + decoderBase +} +type msgpackEncDriverBytes struct { + noBuiltInTypes + encDriverNoopContainerWriter + encDriverNoState + encDriverContainerNoTrackerT + encInit2er + + h *MsgpackHandle + e *encoderBase + w bytesEncAppender +} +type msgpackDecDriverBytes struct { + decDriverNoopContainerReader + decDriverNoopNumberHelper + decInit2er + + h *MsgpackHandle + d *decoderBase + r bytesDecReader + + bdAndBdread + + noBuiltInTypes +} + +func (e *encoderMsgpackBytes) rawExt(_ *encFnInfo, rv reflect.Value) { + if re := rv2i(rv).(*RawExt); re == nil { + e.e.EncodeNil() + } else { + e.e.EncodeRawExt(re) + } +} + +func (e *encoderMsgpackBytes) ext(f *encFnInfo, rv reflect.Value) { + e.e.EncodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn) +} + +func (e *encoderMsgpackBytes) selferMarshal(_ *encFnInfo, rv reflect.Value) { + rv2i(rv).(Selfer).CodecEncodeSelf(&Encoder{e}) +} + +func (e *encoderMsgpackBytes) binaryMarshal(_ *encFnInfo, rv reflect.Value) { + bs, fnerr := rv2i(rv).(encoding.BinaryMarshaler).MarshalBinary() + e.marshalRaw(bs, fnerr) +} + +func (e *encoderMsgpackBytes) textMarshal(_ *encFnInfo, rv reflect.Value) { + bs, fnerr := rv2i(rv).(encoding.TextMarshaler).MarshalText() + e.marshalUtf8(bs, fnerr) +} + +func (e *encoderMsgpackBytes) jsonMarshal(_ *encFnInfo, rv reflect.Value) { + bs, fnerr := rv2i(rv).(jsonMarshaler).MarshalJSON() + e.marshalAsis(bs, fnerr) +} + +func (e *encoderMsgpackBytes) raw(_ *encFnInfo, rv reflect.Value) { + e.rawBytes(rv2i(rv).(Raw)) +} + +func (e *encoderMsgpackBytes) encodeComplex64(v complex64) { + if imag(v) != 0 { + halt.errorf("cannot encode complex number: %v, with imaginary values: %v", any(v), any(imag(v))) + } + e.e.EncodeFloat32(real(v)) +} + +func (e *encoderMsgpackBytes) encodeComplex128(v complex128) { + if imag(v) != 0 { + halt.errorf("cannot encode complex number: %v, with imaginary values: %v", any(v), any(imag(v))) + } + e.e.EncodeFloat64(real(v)) +} + +func (e *encoderMsgpackBytes) kBool(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeBool(rvGetBool(rv)) +} + +func (e *encoderMsgpackBytes) kTime(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeTime(rvGetTime(rv)) +} + +func (e *encoderMsgpackBytes) kString(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeString(rvGetString(rv)) +} + +func (e *encoderMsgpackBytes) kFloat32(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeFloat32(rvGetFloat32(rv)) +} + +func (e *encoderMsgpackBytes) kFloat64(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeFloat64(rvGetFloat64(rv)) +} + +func (e *encoderMsgpackBytes) kComplex64(_ *encFnInfo, rv reflect.Value) { + e.encodeComplex64(rvGetComplex64(rv)) +} + +func (e *encoderMsgpackBytes) kComplex128(_ *encFnInfo, rv reflect.Value) { + e.encodeComplex128(rvGetComplex128(rv)) +} + +func (e *encoderMsgpackBytes) kInt(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeInt(int64(rvGetInt(rv))) +} + +func (e *encoderMsgpackBytes) kInt8(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeInt(int64(rvGetInt8(rv))) +} + +func (e *encoderMsgpackBytes) kInt16(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeInt(int64(rvGetInt16(rv))) +} + +func (e *encoderMsgpackBytes) kInt32(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeInt(int64(rvGetInt32(rv))) +} + +func (e *encoderMsgpackBytes) kInt64(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeInt(int64(rvGetInt64(rv))) +} + +func (e *encoderMsgpackBytes) kUint(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUint(rv))) +} + +func (e *encoderMsgpackBytes) kUint8(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUint8(rv))) +} + +func (e *encoderMsgpackBytes) kUint16(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUint16(rv))) +} + +func (e *encoderMsgpackBytes) kUint32(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUint32(rv))) +} + +func (e *encoderMsgpackBytes) kUint64(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUint64(rv))) +} + +func (e *encoderMsgpackBytes) kUintptr(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUintptr(rv))) +} + +func (e *encoderMsgpackBytes) kSeqFn(rt reflect.Type) (fn *encFnMsgpackBytes) { + + if rt = baseRT(rt); rt.Kind() != reflect.Interface { + fn = e.fn(rt) + } + return +} + +func (e *encoderMsgpackBytes) kArrayWMbs(rv reflect.Value, ti *typeInfo, isSlice bool) { + var l int + if isSlice { + l = rvLenSlice(rv) + } else { + l = rv.Len() + } + if l == 0 { + e.e.WriteMapEmpty() + return + } + e.haltOnMbsOddLen(l) + e.mapStart(l >> 1) + + var fn *encFnMsgpackBytes + builtin := ti.tielem.flagEncBuiltin + if !builtin { + fn = e.kSeqFn(ti.elem) + } + + j := 0 + e.c = containerMapKey + e.e.WriteMapElemKey(true) + for { + rvv := rvArrayIndex(rv, j, ti, isSlice) + if builtin { + e.encodeIB(rv2i(baseRVRV(rvv))) + } else { + e.encodeValue(rvv, fn) + } + j++ + if j == l { + break + } + if j&1 == 0 { + e.c = containerMapKey + e.e.WriteMapElemKey(false) + } else { + e.mapElemValue() + } + } + e.c = 0 + e.e.WriteMapEnd() + +} + +func (e *encoderMsgpackBytes) kArrayW(rv reflect.Value, ti *typeInfo, isSlice bool) { + var l int + if isSlice { + l = rvLenSlice(rv) + } else { + l = rv.Len() + } + if l <= 0 { + e.e.WriteArrayEmpty() + return + } + e.arrayStart(l) + + var fn *encFnMsgpackBytes + if !ti.tielem.flagEncBuiltin { + fn = e.kSeqFn(ti.elem) + } + + j := 0 + e.c = containerArrayElem + e.e.WriteArrayElem(true) + builtin := ti.tielem.flagEncBuiltin + for { + rvv := rvArrayIndex(rv, j, ti, isSlice) + if builtin { + e.encodeIB(rv2i(baseRVRV(rvv))) + } else { + e.encodeValue(rvv, fn) + } + j++ + if j == l { + break + } + e.c = containerArrayElem + e.e.WriteArrayElem(false) + } + + e.c = 0 + e.e.WriteArrayEnd() +} + +func (e *encoderMsgpackBytes) kChan(f *encFnInfo, rv reflect.Value) { + if f.ti.chandir&uint8(reflect.RecvDir) == 0 { + halt.errorStr("send-only channel cannot be encoded") + } + if !f.ti.mbs && uint8TypId == rt2id(f.ti.elem) { + e.kSliceBytesChan(rv) + return + } + rtslice := reflect.SliceOf(f.ti.elem) + rv = chanToSlice(rv, rtslice, e.h.ChanRecvTimeout) + ti := e.h.getTypeInfo(rt2id(rtslice), rtslice) + if f.ti.mbs { + e.kArrayWMbs(rv, ti, true) + } else { + e.kArrayW(rv, ti, true) + } +} + +func (e *encoderMsgpackBytes) kSlice(f *encFnInfo, rv reflect.Value) { + if f.ti.mbs { + e.kArrayWMbs(rv, f.ti, true) + } else if f.ti.rtid == uint8SliceTypId || uint8TypId == rt2id(f.ti.elem) { + + e.e.EncodeBytes(rvGetBytes(rv)) + } else { + e.kArrayW(rv, f.ti, true) + } +} + +func (e *encoderMsgpackBytes) kArray(f *encFnInfo, rv reflect.Value) { + if f.ti.mbs { + e.kArrayWMbs(rv, f.ti, false) + } else if handleBytesWithinKArray && uint8TypId == rt2id(f.ti.elem) { + e.e.EncodeStringBytesRaw(rvGetArrayBytes(rv, nil)) + } else { + e.kArrayW(rv, f.ti, false) + } +} + +func (e *encoderMsgpackBytes) kSliceBytesChan(rv reflect.Value) { + + bs0 := e.blist.peek(32, true) + bs := bs0 + + irv := rv2i(rv) + ch, ok := irv.(<-chan byte) + if !ok { + ch = irv.(chan byte) + } + +L1: + switch timeout := e.h.ChanRecvTimeout; { + case timeout == 0: + for { + select { + case b := <-ch: + bs = append(bs, b) + default: + break L1 + } + } + case timeout > 0: + tt := time.NewTimer(timeout) + for { + select { + case b := <-ch: + bs = append(bs, b) + case <-tt.C: + + break L1 + } + } + default: + for b := range ch { + bs = append(bs, b) + } + } + + e.e.EncodeBytes(bs) + e.blist.put(bs) + if !byteSliceSameData(bs0, bs) { + e.blist.put(bs0) + } +} + +func (e *encoderMsgpackBytes) kStructFieldKey(keyType valueType, encName string) { + + if keyType == valueTypeString { + e.e.EncodeString(encName) + } else if keyType == valueTypeInt { + e.e.EncodeInt(must.Int(strconv.ParseInt(encName, 10, 64))) + } else if keyType == valueTypeUint { + e.e.EncodeUint(must.Uint(strconv.ParseUint(encName, 10, 64))) + } else if keyType == valueTypeFloat { + e.e.EncodeFloat64(must.Float(strconv.ParseFloat(encName, 64))) + } else { + halt.errorStr2("invalid struct key type: ", keyType.String()) + } + +} + +func (e *encoderMsgpackBytes) kStructSimple(f *encFnInfo, rv reflect.Value) { + _ = e.e + tisfi := f.ti.sfi.source() + + chkCirRef := e.h.CheckCircularRef + var si *structFieldInfo + var j int + + if f.ti.toArray || e.h.StructToArray { + if len(tisfi) == 0 { + e.e.WriteArrayEmpty() + return + } + e.arrayStart(len(tisfi)) + for j, si = range tisfi { + e.c = containerArrayElem + e.e.WriteArrayElem(j == 0) + if si.encBuiltin { + e.encodeIB(rv2i(si.fieldNoAlloc(rv, true))) + } else { + e.encodeValue(si.fieldNoAlloc(rv, !chkCirRef), nil) + } + } + e.c = 0 + e.e.WriteArrayEnd() + } else { + if len(tisfi) == 0 { + e.e.WriteMapEmpty() + return + } + if e.h.Canonical { + tisfi = f.ti.sfi.sorted() + } + e.mapStart(len(tisfi)) + for j, si = range tisfi { + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + e.e.EncodeStringNoEscape4Json(si.encName) + e.mapElemValue() + if si.encBuiltin { + e.encodeIB(rv2i(si.fieldNoAlloc(rv, true))) + } else { + e.encodeValue(si.fieldNoAlloc(rv, !chkCirRef), nil) + } + } + e.c = 0 + e.e.WriteMapEnd() + } +} + +func (e *encoderMsgpackBytes) kStruct(f *encFnInfo, rv reflect.Value) { + _ = e.e + ti := f.ti + toMap := !(ti.toArray || e.h.StructToArray) + var mf map[string]interface{} + if ti.flagMissingFielder { + toMap = true + mf = rv2i(rv).(MissingFielder).CodecMissingFields() + } else if ti.flagMissingFielderPtr { + toMap = true + if rv.CanAddr() { + mf = rv2i(rvAddr(rv, ti.ptr)).(MissingFielder).CodecMissingFields() + } else { + mf = rv2i(e.addrRV(rv, ti.rt, ti.ptr)).(MissingFielder).CodecMissingFields() + } + } + newlen := len(mf) + tisfi := ti.sfi.source() + newlen += len(tisfi) + + var fkvs = e.slist.get(newlen)[:newlen] + + recur := e.h.RecursiveEmptyCheck + chkCirRef := e.h.CheckCircularRef + + var xlen int + + var kv sfiRv + var j int + var sf encStructFieldObj + if toMap { + newlen = 0 + if e.h.Canonical { + tisfi = f.ti.sfi.sorted() + } + for _, si := range tisfi { + + if si.omitEmpty { + kv.r = si.fieldNoAlloc(rv, false) + if isEmptyValue(kv.r, e.h.TypeInfos, recur) { + continue + } + } else { + kv.r = si.fieldNoAlloc(rv, si.encBuiltin || !chkCirRef) + } + kv.v = si + fkvs[newlen] = kv + newlen++ + } + + var mf2s []stringIntf + if len(mf) != 0 { + mf2s = make([]stringIntf, 0, len(mf)) + for k, v := range mf { + if k == "" { + continue + } + if ti.infoFieldOmitempty && isEmptyValue(reflect.ValueOf(v), e.h.TypeInfos, recur) { + continue + } + mf2s = append(mf2s, stringIntf{k, v}) + } + } + + xlen = newlen + len(mf2s) + if xlen == 0 { + e.e.WriteMapEmpty() + goto END + } + + e.mapStart(xlen) + + if len(mf2s) != 0 && e.h.Canonical { + mf2w := make([]encStructFieldObj, newlen+len(mf2s)) + for j = 0; j < newlen; j++ { + kv = fkvs[j] + mf2w[j] = encStructFieldObj{kv.v.encName, kv.r, nil, true, + !kv.v.encNameEscape4Json, kv.v.encBuiltin} + } + for _, v := range mf2s { + mf2w[j] = encStructFieldObj{v.v, reflect.Value{}, v.i, false, false, false} + j++ + } + sort.Sort((encStructFieldObjSlice)(mf2w)) + for j, sf = range mf2w { + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + if ti.keyType == valueTypeString && sf.noEsc4json { + e.e.EncodeStringNoEscape4Json(sf.key) + } else { + e.kStructFieldKey(ti.keyType, sf.key) + } + e.mapElemValue() + if sf.isRv { + if sf.builtin { + e.encodeIB(rv2i(baseRVRV(sf.rv))) + } else { + e.encodeValue(sf.rv, nil) + } + } else { + if !e.encodeBuiltin(sf.intf) { + e.encodeR(reflect.ValueOf(sf.intf)) + } + + } + } + } else { + keytyp := ti.keyType + for j = 0; j < newlen; j++ { + kv = fkvs[j] + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + if ti.keyType == valueTypeString && !kv.v.encNameEscape4Json { + e.e.EncodeStringNoEscape4Json(kv.v.encName) + } else { + e.kStructFieldKey(keytyp, kv.v.encName) + } + e.mapElemValue() + if kv.v.encBuiltin { + e.encodeIB(rv2i(baseRVRV(kv.r))) + } else { + e.encodeValue(kv.r, nil) + } + } + for _, v := range mf2s { + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + e.kStructFieldKey(keytyp, v.v) + e.mapElemValue() + if !e.encodeBuiltin(v.i) { + e.encodeR(reflect.ValueOf(v.i)) + } + + j++ + } + } + + e.c = 0 + e.e.WriteMapEnd() + } else { + newlen = len(tisfi) + for i, si := range tisfi { + + if si.omitEmpty { + + kv.r = si.fieldNoAlloc(rv, false) + if isEmptyContainerValue(kv.r, e.h.TypeInfos, recur) { + kv.r = reflect.Value{} + } + } else { + kv.r = si.fieldNoAlloc(rv, si.encBuiltin || !chkCirRef) + } + kv.v = si + fkvs[i] = kv + } + + if newlen == 0 { + e.e.WriteArrayEmpty() + goto END + } + + e.arrayStart(newlen) + for j = 0; j < newlen; j++ { + e.c = containerArrayElem + e.e.WriteArrayElem(j == 0) + kv = fkvs[j] + if !kv.r.IsValid() { + e.e.EncodeNil() + } else if kv.v.encBuiltin { + e.encodeIB(rv2i(baseRVRV(kv.r))) + } else { + e.encodeValue(kv.r, nil) + } + } + e.c = 0 + e.e.WriteArrayEnd() + } + +END: + + e.slist.put(fkvs) +} + +func (e *encoderMsgpackBytes) kMap(f *encFnInfo, rv reflect.Value) { + _ = e.e + l := rvLenMap(rv) + if l == 0 { + e.e.WriteMapEmpty() + return + } + e.mapStart(l) + + var keyFn, valFn *encFnMsgpackBytes + + ktypeKind := reflect.Kind(f.ti.keykind) + vtypeKind := reflect.Kind(f.ti.elemkind) + + rtval := f.ti.elem + rtvalkind := vtypeKind + for rtvalkind == reflect.Ptr { + rtval = rtval.Elem() + rtvalkind = rtval.Kind() + } + if rtvalkind != reflect.Interface { + valFn = e.fn(rtval) + } + + var rvv = mapAddrLoopvarRV(f.ti.elem, vtypeKind) + + rtkey := f.ti.key + var keyTypeIsString = stringTypId == rt2id(rtkey) + if keyTypeIsString { + keyFn = e.fn(rtkey) + } else { + for rtkey.Kind() == reflect.Ptr { + rtkey = rtkey.Elem() + } + if rtkey.Kind() != reflect.Interface { + keyFn = e.fn(rtkey) + } + } + + if e.h.Canonical { + e.kMapCanonical(f.ti, rv, rvv, keyFn, valFn) + e.c = 0 + e.e.WriteMapEnd() + return + } + + var rvk = mapAddrLoopvarRV(f.ti.key, ktypeKind) + + var it mapIter + mapRange(&it, rv, rvk, rvv, true) + + kbuiltin := f.ti.tikey.flagEncBuiltin + vbuiltin := f.ti.tielem.flagEncBuiltin + for j := 0; it.Next(); j++ { + rv = it.Key() + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + if keyTypeIsString { + e.e.EncodeString(rvGetString(rv)) + } else if kbuiltin { + e.encodeIB(rv2i(baseRVRV(rv))) + } else { + e.encodeValue(rv, keyFn) + } + e.mapElemValue() + rv = it.Value() + if vbuiltin { + e.encodeIB(rv2i(baseRVRV(rv))) + } else { + e.encodeValue(it.Value(), valFn) + } + } + it.Done() + + e.c = 0 + e.e.WriteMapEnd() +} + +func (e *encoderMsgpackBytes) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, keyFn, valFn *encFnMsgpackBytes) { + _ = e.e + + rtkey := ti.key + rtkeydecl := rtkey.PkgPath() == "" && rtkey.Name() != "" + + mks := rv.MapKeys() + rtkeyKind := rtkey.Kind() + mparams := getMapReqParams(ti) + + switch rtkeyKind { + case reflect.Bool: + + if len(mks) == 2 && mks[0].Bool() { + mks[0], mks[1] = mks[1], mks[0] + } + for i := range mks { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeBool(mks[i].Bool()) + } else { + e.encodeValueNonNil(mks[i], keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mks[i], rvv, mparams), valFn) + } + case reflect.String: + mksv := make([]orderedRv[string], len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = rvGetString(k) + } + slices.SortFunc(mksv, cmpOrderedRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeString(mksv[i].v) + } else { + e.encodeValueNonNil(mksv[i].r, keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr: + mksv := make([]orderedRv[uint64], len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Uint() + } + slices.SortFunc(mksv, cmpOrderedRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeUint(mksv[i].v) + } else { + e.encodeValueNonNil(mksv[i].r, keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + mksv := make([]orderedRv[int64], len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Int() + } + slices.SortFunc(mksv, cmpOrderedRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeInt(mksv[i].v) + } else { + e.encodeValueNonNil(mksv[i].r, keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + case reflect.Float32: + mksv := make([]orderedRv[float64], len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Float() + } + slices.SortFunc(mksv, cmpOrderedRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeFloat32(float32(mksv[i].v)) + } else { + e.encodeValueNonNil(mksv[i].r, keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + case reflect.Float64: + mksv := make([]orderedRv[float64], len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Float() + } + slices.SortFunc(mksv, cmpOrderedRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeFloat64(mksv[i].v) + } else { + e.encodeValueNonNil(mksv[i].r, keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + default: + if rtkey == timeTyp { + mksv := make([]timeRv, len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = rv2i(k).(time.Time) + } + slices.SortFunc(mksv, cmpTimeRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + e.e.EncodeTime(mksv[i].v) + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + break + } + + bs0 := e.blist.get(len(mks) * 16) + mksv := bs0 + mksbv := make([]bytesRv, len(mks)) + + sideEncode(e.hh, &e.h.sideEncPool, func(se encoderI) { + se.ResetBytes(&mksv) + for i, k := range mks { + v := &mksbv[i] + l := len(mksv) + se.setContainerState(containerMapKey) + se.encodeR(baseRVRV(k)) + se.atEndOfEncode() + se.writerEnd() + v.r = k + v.v = mksv[l:] + } + }) + + slices.SortFunc(mksbv, cmpBytesRv) + for j := range mksbv { + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + e.e.writeBytesAsis(mksbv[j].v) + e.mapElemValue() + e.encodeValue(mapGet(rv, mksbv[j].r, rvv, mparams), valFn) + } + e.blist.put(mksv) + if !byteSliceSameData(bs0, mksv) { + e.blist.put(bs0) + } + } +} + +func (e *encoderMsgpackBytes) init(h Handle) { + initHandle(h) + callMake(&e.e) + e.hh = h + e.h = h.getBasicHandle() + + e.err = errEncoderNotInitialized + + e.fp = e.e.init(h, &e.encoderBase, e).(*fastpathEsMsgpackBytes) + + if e.bytes { + e.rtidFn = &e.h.rtidFnsEncBytes + e.rtidFnNoExt = &e.h.rtidFnsEncNoExtBytes + } else { + e.rtidFn = &e.h.rtidFnsEncIO + e.rtidFnNoExt = &e.h.rtidFnsEncNoExtIO + } + + e.reset() +} + +func (e *encoderMsgpackBytes) reset() { + e.e.reset() + if e.ci != nil { + e.ci = e.ci[:0] + } + e.c = 0 + e.calls = 0 + e.seq = 0 + e.err = nil +} + +func (e *encoderMsgpackBytes) Encode(v interface{}) (err error) { + + defer panicValToErr(e, callRecoverSentinel, &e.err, &err, debugging) + e.mustEncode(v) + return +} + +func (e *encoderMsgpackBytes) MustEncode(v interface{}) { + defer panicValToErr(e, callRecoverSentinel, &e.err, nil, true) + e.mustEncode(v) + return +} + +func (e *encoderMsgpackBytes) mustEncode(v interface{}) { + halt.onerror(e.err) + if e.hh == nil { + halt.onerror(errNoFormatHandle) + } + + e.calls++ + if !e.encodeBuiltin(v) { + e.encodeR(reflect.ValueOf(v)) + } + + e.calls-- + if e.calls == 0 { + e.e.atEndOfEncode() + e.e.writerEnd() + } +} + +func (e *encoderMsgpackBytes) encodeI(iv interface{}) { + if !e.encodeBuiltin(iv) { + e.encodeR(reflect.ValueOf(iv)) + } +} + +func (e *encoderMsgpackBytes) encodeIB(iv interface{}) { + if !e.encodeBuiltin(iv) { + + halt.errorStr("[should not happen] invalid type passed to encodeBuiltin") + } +} + +func (e *encoderMsgpackBytes) encodeR(base reflect.Value) { + e.encodeValue(base, nil) +} + +func (e *encoderMsgpackBytes) encodeBuiltin(iv interface{}) (ok bool) { + ok = true + switch v := iv.(type) { + case nil: + e.e.EncodeNil() + + case Raw: + e.rawBytes(v) + case string: + e.e.EncodeString(v) + case bool: + e.e.EncodeBool(v) + case int: + e.e.EncodeInt(int64(v)) + case int8: + e.e.EncodeInt(int64(v)) + case int16: + e.e.EncodeInt(int64(v)) + case int32: + e.e.EncodeInt(int64(v)) + case int64: + e.e.EncodeInt(v) + case uint: + e.e.EncodeUint(uint64(v)) + case uint8: + e.e.EncodeUint(uint64(v)) + case uint16: + e.e.EncodeUint(uint64(v)) + case uint32: + e.e.EncodeUint(uint64(v)) + case uint64: + e.e.EncodeUint(v) + case uintptr: + e.e.EncodeUint(uint64(v)) + case float32: + e.e.EncodeFloat32(v) + case float64: + e.e.EncodeFloat64(v) + case complex64: + e.encodeComplex64(v) + case complex128: + e.encodeComplex128(v) + case time.Time: + e.e.EncodeTime(v) + case []byte: + e.e.EncodeBytes(v) + default: + + ok = !skipFastpathTypeSwitchInDirectCall && e.dh.fastpathEncodeTypeSwitch(iv, e) + } + return +} + +func (e *encoderMsgpackBytes) encodeValue(rv reflect.Value, fn *encFnMsgpackBytes) { + + var ciPushes int + + var rvp reflect.Value + var rvpValid bool + +RV: + switch rv.Kind() { + case reflect.Ptr: + if rvIsNil(rv) { + e.e.EncodeNil() + goto END + } + rvpValid = true + rvp = rv + rv = rv.Elem() + + if e.h.CheckCircularRef && e.ci.canPushElemKind(rv.Kind()) { + e.ci.push(rv2i(rvp)) + ciPushes++ + } + goto RV + case reflect.Interface: + if rvIsNil(rv) { + e.e.EncodeNil() + goto END + } + rvpValid = false + rvp = reflect.Value{} + rv = rv.Elem() + fn = nil + goto RV + case reflect.Map: + if rvIsNil(rv) { + if e.h.NilCollectionToZeroLength { + e.e.WriteMapEmpty() + } else { + e.e.EncodeNil() + } + goto END + } + case reflect.Slice, reflect.Chan: + if rvIsNil(rv) { + if e.h.NilCollectionToZeroLength { + e.e.WriteArrayEmpty() + } else { + e.e.EncodeNil() + } + goto END + } + case reflect.Invalid, reflect.Func: + e.e.EncodeNil() + goto END + } + + if fn == nil { + fn = e.fn(rv.Type()) + } + + if !fn.i.addrE { + + } else if rvpValid { + rv = rvp + } else if rv.CanAddr() { + rv = rvAddr(rv, fn.i.ti.ptr) + } else { + rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr) + } + fn.fe(e, &fn.i, rv) + +END: + if ciPushes > 0 { + e.ci.pop(ciPushes) + } +} + +func (e *encoderMsgpackBytes) encodeValueNonNil(rv reflect.Value, fn *encFnMsgpackBytes) { + + if fn.i.addrE { + if rv.CanAddr() { + rv = rvAddr(rv, fn.i.ti.ptr) + } else { + rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr) + } + } + fn.fe(e, &fn.i, rv) +} + +func (e *encoderMsgpackBytes) encodeAs(v interface{}, t reflect.Type, ext bool) { + if ext { + e.encodeValue(baseRV(v), e.fn(t)) + } else { + e.encodeValue(baseRV(v), e.fnNoExt(t)) + } +} + +func (e *encoderMsgpackBytes) marshalUtf8(bs []byte, fnerr error) { + halt.onerror(fnerr) + if bs == nil { + e.e.EncodeNil() + } else { + e.e.EncodeString(stringView(bs)) + } +} + +func (e *encoderMsgpackBytes) marshalAsis(bs []byte, fnerr error) { + halt.onerror(fnerr) + if bs == nil { + e.e.EncodeNil() + } else { + e.e.writeBytesAsis(bs) + } +} + +func (e *encoderMsgpackBytes) marshalRaw(bs []byte, fnerr error) { + halt.onerror(fnerr) + e.e.EncodeBytes(bs) +} + +func (e *encoderMsgpackBytes) rawBytes(vv Raw) { + v := []byte(vv) + if !e.h.Raw { + halt.errorBytes("Raw values cannot be encoded: ", v) + } + e.e.writeBytesAsis(v) +} + +func (e *encoderMsgpackBytes) fn(t reflect.Type) *encFnMsgpackBytes { + return e.dh.encFnViaBH(t, e.rtidFn, e.h, e.fp, false) +} + +func (e *encoderMsgpackBytes) fnNoExt(t reflect.Type) *encFnMsgpackBytes { + return e.dh.encFnViaBH(t, e.rtidFnNoExt, e.h, e.fp, true) +} + +func (e *encoderMsgpackBytes) mapStart(length int) { + e.e.WriteMapStart(length) + e.c = containerMapStart +} + +func (e *encoderMsgpackBytes) mapElemValue() { + e.e.WriteMapElemValue() + e.c = containerMapValue +} + +func (e *encoderMsgpackBytes) arrayStart(length int) { + e.e.WriteArrayStart(length) + e.c = containerArrayStart +} + +func (e *encoderMsgpackBytes) writerEnd() { + e.e.writerEnd() +} + +func (e *encoderMsgpackBytes) atEndOfEncode() { + e.e.atEndOfEncode() +} + +func (e *encoderMsgpackBytes) Reset(w io.Writer) { + if e.bytes { + halt.onerror(errEncNoResetBytesWithWriter) + } + e.reset() + if w == nil { + w = io.Discard + } + e.e.resetOutIO(w) +} + +func (e *encoderMsgpackBytes) ResetBytes(out *[]byte) { + if !e.bytes { + halt.onerror(errEncNoResetWriterWithBytes) + } + e.resetBytes(out) +} + +func (e *encoderMsgpackBytes) resetBytes(out *[]byte) { + e.reset() + if out == nil { + out = &bytesEncAppenderDefOut + } + e.e.resetOutBytes(out) +} + +func (helperEncDriverMsgpackBytes) newEncoderBytes(out *[]byte, h Handle) *encoderMsgpackBytes { + var c1 encoderMsgpackBytes + c1.bytes = true + c1.init(h) + c1.ResetBytes(out) + return &c1 +} + +func (helperEncDriverMsgpackBytes) newEncoderIO(out io.Writer, h Handle) *encoderMsgpackBytes { + var c1 encoderMsgpackBytes + c1.bytes = false + c1.init(h) + c1.Reset(out) + return &c1 +} + +func (helperEncDriverMsgpackBytes) encFnloadFastpathUnderlying(ti *typeInfo, fp *fastpathEsMsgpackBytes) (f *fastpathEMsgpackBytes, u reflect.Type) { + rtid := rt2id(ti.fastpathUnderlying) + idx, ok := fastpathAvIndex(rtid) + if !ok { + return + } + f = &fp[idx] + if uint8(reflect.Array) == ti.kind { + u = reflect.ArrayOf(ti.rt.Len(), ti.elem) + } else { + u = f.rt + } + return +} + +func (helperEncDriverMsgpackBytes) encFindRtidFn(s []encRtidFnMsgpackBytes, rtid uintptr) (i uint, fn *encFnMsgpackBytes) { + + var h uint + var j = uint(len(s)) +LOOP: + if i < j { + h = (i + j) >> 1 + if s[h].rtid < rtid { + i = h + 1 + } else { + j = h + } + goto LOOP + } + if i < uint(len(s)) && s[i].rtid == rtid { + fn = s[i].fn + } + return +} + +func (helperEncDriverMsgpackBytes) encFromRtidFnSlice(fns *atomicRtidFnSlice) (s []encRtidFnMsgpackBytes) { + if v := fns.load(); v != nil { + s = *(lowLevelToPtr[[]encRtidFnMsgpackBytes](v)) + } + return +} + +func (dh helperEncDriverMsgpackBytes) encFnViaBH(rt reflect.Type, fns *atomicRtidFnSlice, + x *BasicHandle, fp *fastpathEsMsgpackBytes, checkExt bool) (fn *encFnMsgpackBytes) { + return dh.encFnVia(rt, fns, x.typeInfos(), &x.mu, x.extHandle, fp, + checkExt, x.CheckCircularRef, x.timeBuiltin, x.binaryHandle, x.jsonHandle) +} + +func (dh helperEncDriverMsgpackBytes) encFnVia(rt reflect.Type, fns *atomicRtidFnSlice, + tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathEsMsgpackBytes, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackBytes) { + rtid := rt2id(rt) + var sp []encRtidFnMsgpackBytes = dh.encFromRtidFnSlice(fns) + if sp != nil { + _, fn = dh.encFindRtidFn(sp, rtid) + } + if fn == nil { + fn = dh.encFnViaLoader(rt, rtid, fns, tinfos, mu, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json) + } + return +} + +func (dh helperEncDriverMsgpackBytes) encFnViaLoader(rt reflect.Type, rtid uintptr, fns *atomicRtidFnSlice, + tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathEsMsgpackBytes, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackBytes) { + + fn = dh.encFnLoad(rt, rtid, tinfos, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json) + var sp []encRtidFnMsgpackBytes + mu.Lock() + sp = dh.encFromRtidFnSlice(fns) + + if sp == nil { + sp = []encRtidFnMsgpackBytes{{rtid, fn}} + fns.store(ptrToLowLevel(&sp)) + } else { + idx, fn2 := dh.encFindRtidFn(sp, rtid) + if fn2 == nil { + sp2 := make([]encRtidFnMsgpackBytes, len(sp)+1) + copy(sp2[idx+1:], sp[idx:]) + copy(sp2, sp[:idx]) + sp2[idx] = encRtidFnMsgpackBytes{rtid, fn} + fns.store(ptrToLowLevel(&sp2)) + } + } + mu.Unlock() + return +} + +func (dh helperEncDriverMsgpackBytes) encFnLoad(rt reflect.Type, rtid uintptr, tinfos *TypeInfos, + exth extHandle, fp *fastpathEsMsgpackBytes, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackBytes) { + fn = new(encFnMsgpackBytes) + fi := &(fn.i) + ti := tinfos.get(rtid, rt) + fi.ti = ti + rk := reflect.Kind(ti.kind) + + if rtid == timeTypId && timeBuiltin { + fn.fe = (*encoderMsgpackBytes).kTime + } else if rtid == rawTypId { + fn.fe = (*encoderMsgpackBytes).raw + } else if rtid == rawExtTypId { + fn.fe = (*encoderMsgpackBytes).rawExt + fi.addrE = true + } else if xfFn := exth.getExt(rtid, checkExt); xfFn != nil { + fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext + fn.fe = (*encoderMsgpackBytes).ext + if rk == reflect.Struct || rk == reflect.Array { + fi.addrE = true + } + } else if ti.flagSelfer || ti.flagSelferPtr { + fn.fe = (*encoderMsgpackBytes).selferMarshal + fi.addrE = ti.flagSelferPtr + } else if supportMarshalInterfaces && binaryEncoding && + (ti.flagBinaryMarshaler || ti.flagBinaryMarshalerPtr) && + (ti.flagBinaryUnmarshaler || ti.flagBinaryUnmarshalerPtr) { + fn.fe = (*encoderMsgpackBytes).binaryMarshal + fi.addrE = ti.flagBinaryMarshalerPtr + } else if supportMarshalInterfaces && !binaryEncoding && json && + (ti.flagJsonMarshaler || ti.flagJsonMarshalerPtr) && + (ti.flagJsonUnmarshaler || ti.flagJsonUnmarshalerPtr) { + + fn.fe = (*encoderMsgpackBytes).jsonMarshal + fi.addrE = ti.flagJsonMarshalerPtr + } else if supportMarshalInterfaces && !binaryEncoding && + (ti.flagTextMarshaler || ti.flagTextMarshalerPtr) && + (ti.flagTextUnmarshaler || ti.flagTextUnmarshalerPtr) { + fn.fe = (*encoderMsgpackBytes).textMarshal + fi.addrE = ti.flagTextMarshalerPtr + } else { + if fastpathEnabled && (rk == reflect.Map || rk == reflect.Slice || rk == reflect.Array) { + + var rtid2 uintptr + if !ti.flagHasPkgPath { + rtid2 = rtid + if rk == reflect.Array { + rtid2 = rt2id(ti.key) + } + if idx, ok := fastpathAvIndex(rtid2); ok { + fn.fe = fp[idx].encfn + } + } else { + + xfe, xrt := dh.encFnloadFastpathUnderlying(ti, fp) + if xfe != nil { + xfnf := xfe.encfn + fn.fe = func(e *encoderMsgpackBytes, xf *encFnInfo, xrv reflect.Value) { + xfnf(e, xf, rvConvert(xrv, xrt)) + } + } + } + } + if fn.fe == nil { + switch rk { + case reflect.Bool: + fn.fe = (*encoderMsgpackBytes).kBool + case reflect.String: + + fn.fe = (*encoderMsgpackBytes).kString + case reflect.Int: + fn.fe = (*encoderMsgpackBytes).kInt + case reflect.Int8: + fn.fe = (*encoderMsgpackBytes).kInt8 + case reflect.Int16: + fn.fe = (*encoderMsgpackBytes).kInt16 + case reflect.Int32: + fn.fe = (*encoderMsgpackBytes).kInt32 + case reflect.Int64: + fn.fe = (*encoderMsgpackBytes).kInt64 + case reflect.Uint: + fn.fe = (*encoderMsgpackBytes).kUint + case reflect.Uint8: + fn.fe = (*encoderMsgpackBytes).kUint8 + case reflect.Uint16: + fn.fe = (*encoderMsgpackBytes).kUint16 + case reflect.Uint32: + fn.fe = (*encoderMsgpackBytes).kUint32 + case reflect.Uint64: + fn.fe = (*encoderMsgpackBytes).kUint64 + case reflect.Uintptr: + fn.fe = (*encoderMsgpackBytes).kUintptr + case reflect.Float32: + fn.fe = (*encoderMsgpackBytes).kFloat32 + case reflect.Float64: + fn.fe = (*encoderMsgpackBytes).kFloat64 + case reflect.Complex64: + fn.fe = (*encoderMsgpackBytes).kComplex64 + case reflect.Complex128: + fn.fe = (*encoderMsgpackBytes).kComplex128 + case reflect.Chan: + fn.fe = (*encoderMsgpackBytes).kChan + case reflect.Slice: + fn.fe = (*encoderMsgpackBytes).kSlice + case reflect.Array: + fn.fe = (*encoderMsgpackBytes).kArray + case reflect.Struct: + if ti.simple { + fn.fe = (*encoderMsgpackBytes).kStructSimple + } else { + fn.fe = (*encoderMsgpackBytes).kStruct + } + case reflect.Map: + fn.fe = (*encoderMsgpackBytes).kMap + case reflect.Interface: + + fn.fe = (*encoderMsgpackBytes).kErr + default: + + fn.fe = (*encoderMsgpackBytes).kErr + } + } + } + return +} +func (d *decoderMsgpackBytes) rawExt(f *decFnInfo, rv reflect.Value) { + d.d.DecodeRawExt(rv2i(rv).(*RawExt)) +} + +func (d *decoderMsgpackBytes) ext(f *decFnInfo, rv reflect.Value) { + d.d.DecodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn) +} + +func (d *decoderMsgpackBytes) selferUnmarshal(_ *decFnInfo, rv reflect.Value) { + rv2i(rv).(Selfer).CodecDecodeSelf(&Decoder{d}) +} + +func (d *decoderMsgpackBytes) binaryUnmarshal(_ *decFnInfo, rv reflect.Value) { + bm := rv2i(rv).(encoding.BinaryUnmarshaler) + xbs, _ := d.d.DecodeBytes() + fnerr := bm.UnmarshalBinary(xbs) + halt.onerror(fnerr) +} + +func (d *decoderMsgpackBytes) textUnmarshal(_ *decFnInfo, rv reflect.Value) { + tm := rv2i(rv).(encoding.TextUnmarshaler) + fnerr := tm.UnmarshalText(bytesOKs(d.d.DecodeStringAsBytes())) + halt.onerror(fnerr) +} + +func (d *decoderMsgpackBytes) jsonUnmarshal(_ *decFnInfo, rv reflect.Value) { + d.jsonUnmarshalV(rv2i(rv).(jsonUnmarshaler)) +} + +func (d *decoderMsgpackBytes) jsonUnmarshalV(tm jsonUnmarshaler) { + + halt.onerror(tm.UnmarshalJSON(d.d.nextValueBytes())) +} + +func (d *decoderMsgpackBytes) kErr(_ *decFnInfo, rv reflect.Value) { + halt.errorf("unsupported decoding kind: %s, for %#v", rv.Kind(), rv) + +} + +func (d *decoderMsgpackBytes) raw(_ *decFnInfo, rv reflect.Value) { + rvSetBytes(rv, d.rawBytes()) +} + +func (d *decoderMsgpackBytes) kString(_ *decFnInfo, rv reflect.Value) { + rvSetString(rv, d.detach2Str(d.d.DecodeStringAsBytes())) +} + +func (d *decoderMsgpackBytes) kBool(_ *decFnInfo, rv reflect.Value) { + rvSetBool(rv, d.d.DecodeBool()) +} + +func (d *decoderMsgpackBytes) kTime(_ *decFnInfo, rv reflect.Value) { + rvSetTime(rv, d.d.DecodeTime()) +} + +func (d *decoderMsgpackBytes) kFloat32(_ *decFnInfo, rv reflect.Value) { + rvSetFloat32(rv, d.d.DecodeFloat32()) +} + +func (d *decoderMsgpackBytes) kFloat64(_ *decFnInfo, rv reflect.Value) { + rvSetFloat64(rv, d.d.DecodeFloat64()) +} + +func (d *decoderMsgpackBytes) kComplex64(_ *decFnInfo, rv reflect.Value) { + rvSetComplex64(rv, complex(d.d.DecodeFloat32(), 0)) +} + +func (d *decoderMsgpackBytes) kComplex128(_ *decFnInfo, rv reflect.Value) { + rvSetComplex128(rv, complex(d.d.DecodeFloat64(), 0)) +} + +func (d *decoderMsgpackBytes) kInt(_ *decFnInfo, rv reflect.Value) { + rvSetInt(rv, int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))) +} + +func (d *decoderMsgpackBytes) kInt8(_ *decFnInfo, rv reflect.Value) { + rvSetInt8(rv, int8(chkOvf.IntV(d.d.DecodeInt64(), 8))) +} + +func (d *decoderMsgpackBytes) kInt16(_ *decFnInfo, rv reflect.Value) { + rvSetInt16(rv, int16(chkOvf.IntV(d.d.DecodeInt64(), 16))) +} + +func (d *decoderMsgpackBytes) kInt32(_ *decFnInfo, rv reflect.Value) { + rvSetInt32(rv, int32(chkOvf.IntV(d.d.DecodeInt64(), 32))) +} + +func (d *decoderMsgpackBytes) kInt64(_ *decFnInfo, rv reflect.Value) { + rvSetInt64(rv, d.d.DecodeInt64()) +} + +func (d *decoderMsgpackBytes) kUint(_ *decFnInfo, rv reflect.Value) { + rvSetUint(rv, uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))) +} + +func (d *decoderMsgpackBytes) kUintptr(_ *decFnInfo, rv reflect.Value) { + rvSetUintptr(rv, uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))) +} + +func (d *decoderMsgpackBytes) kUint8(_ *decFnInfo, rv reflect.Value) { + rvSetUint8(rv, uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))) +} + +func (d *decoderMsgpackBytes) kUint16(_ *decFnInfo, rv reflect.Value) { + rvSetUint16(rv, uint16(chkOvf.UintV(d.d.DecodeUint64(), 16))) +} + +func (d *decoderMsgpackBytes) kUint32(_ *decFnInfo, rv reflect.Value) { + rvSetUint32(rv, uint32(chkOvf.UintV(d.d.DecodeUint64(), 32))) +} + +func (d *decoderMsgpackBytes) kUint64(_ *decFnInfo, rv reflect.Value) { + rvSetUint64(rv, d.d.DecodeUint64()) +} + +func (d *decoderMsgpackBytes) kInterfaceNaked(f *decFnInfo) (rvn reflect.Value) { + + n := d.naked() + d.d.DecodeNaked() + + if decFailNonEmptyIntf && f.ti.numMeth > 0 { + halt.errorf("cannot decode non-nil codec value into nil %v (%v methods)", f.ti.rt, f.ti.numMeth) + } + + switch n.v { + case valueTypeMap: + mtid := d.mtid + if mtid == 0 { + if d.jsms { + mtid = mapStrIntfTypId + } else { + mtid = mapIntfIntfTypId + } + } + if mtid == mapStrIntfTypId { + var v2 map[string]interface{} + d.decode(&v2) + rvn = rv4iptr(&v2).Elem() + } else if mtid == mapIntfIntfTypId { + var v2 map[interface{}]interface{} + d.decode(&v2) + rvn = rv4iptr(&v2).Elem() + } else if d.mtr { + rvn = reflect.New(d.h.MapType) + d.decode(rv2i(rvn)) + rvn = rvn.Elem() + } else { + + rvn = rvZeroAddrK(d.h.MapType, reflect.Map) + d.decodeValue(rvn, nil) + } + case valueTypeArray: + if d.stid == 0 || d.stid == intfSliceTypId { + var v2 []interface{} + d.decode(&v2) + rvn = rv4iptr(&v2).Elem() + } else if d.str { + rvn = reflect.New(d.h.SliceType) + d.decode(rv2i(rvn)) + rvn = rvn.Elem() + } else { + rvn = rvZeroAddrK(d.h.SliceType, reflect.Slice) + d.decodeValue(rvn, nil) + } + if d.h.PreferArrayOverSlice { + rvn = rvGetArray4Slice(rvn) + } + case valueTypeExt: + tag, bytes := n.u, n.l + bfn := d.h.getExtForTag(tag) + var re = RawExt{Tag: tag} + if bytes == nil { + + if bfn == nil { + d.decode(&re.Value) + rvn = rv4iptr(&re).Elem() + } else if bfn.ext == SelfExt { + rvn = rvZeroAddrK(bfn.rt, bfn.rt.Kind()) + d.decodeValue(rvn, d.fnNoExt(bfn.rt)) + } else { + rvn = reflect.New(bfn.rt) + d.interfaceExtConvertAndDecode(rv2i(rvn), bfn.ext) + rvn = rvn.Elem() + } + } else { + + if bfn == nil { + re.setData(bytes, false) + rvn = rv4iptr(&re).Elem() + } else { + rvn = reflect.New(bfn.rt) + if bfn.ext == SelfExt { + sideDecode(d.hh, &d.h.sideDecPool, func(sd decoderI) { oneOffDecode(sd, rv2i(rvn), bytes, bfn.rt, true) }) + } else { + bfn.ext.ReadExt(rv2i(rvn), bytes) + } + rvn = rvn.Elem() + } + } + + if d.h.PreferPointerForStructOrArray && rvn.CanAddr() { + if rk := rvn.Kind(); rk == reflect.Array || rk == reflect.Struct { + rvn = rvn.Addr() + } + } + case valueTypeNil: + + case valueTypeInt: + rvn = n.ri() + case valueTypeUint: + rvn = n.ru() + case valueTypeFloat: + rvn = n.rf() + case valueTypeBool: + rvn = n.rb() + case valueTypeString, valueTypeSymbol: + rvn = n.rs() + case valueTypeBytes: + rvn = n.rl() + case valueTypeTime: + rvn = n.rt() + default: + halt.errorStr2("kInterfaceNaked: unexpected valueType: ", n.v.String()) + } + return +} + +func (d *decoderMsgpackBytes) kInterface(f *decFnInfo, rv reflect.Value) { + + isnilrv := rvIsNil(rv) + + var rvn reflect.Value + + if d.h.InterfaceReset { + + rvn = d.h.intf2impl(f.ti.rtid) + if !rvn.IsValid() { + rvn = d.kInterfaceNaked(f) + if rvn.IsValid() { + rvSetIntf(rv, rvn) + } else if !isnilrv { + decSetNonNilRV2Zero4Intf(rv) + } + return + } + } else if isnilrv { + + rvn = d.h.intf2impl(f.ti.rtid) + if !rvn.IsValid() { + rvn = d.kInterfaceNaked(f) + if rvn.IsValid() { + rvSetIntf(rv, rvn) + } + return + } + } else { + + rvn = rv.Elem() + } + + canDecode, _ := isDecodeable(rvn) + + if !canDecode { + rvn2 := d.oneShotAddrRV(rvn.Type(), rvn.Kind()) + rvSetDirect(rvn2, rvn) + rvn = rvn2 + } + + d.decodeValue(rvn, nil) + rvSetIntf(rv, rvn) +} + +func (d *decoderMsgpackBytes) kStructField(si *structFieldInfo, rv reflect.Value) { + if d.d.TryNil() { + rv = si.fieldNoAlloc(rv, true) + if rv.IsValid() { + decSetNonNilRV2Zero(rv) + } + } else if si.decBuiltin { + rv = rvAddr(si.fieldAlloc(rv), si.ptrTyp) + d.decode(rv2i(rv)) + } else { + fn := d.fn(si.baseTyp) + rv = si.fieldAlloc(rv) + if fn.i.addrD { + rv = rvAddr(rv, si.ptrTyp) + } + fn.fd(d, &fn.i, rv) + } +} + +func (d *decoderMsgpackBytes) kStructSimple(f *decFnInfo, rv reflect.Value) { + _ = d.d + ctyp := d.d.ContainerType() + ti := f.ti + if ctyp == valueTypeMap { + containerLen := d.mapStart(d.d.ReadMapStart()) + if containerLen == 0 { + d.mapEnd() + return + } + hasLen := containerLen >= 0 + var rvkencname []byte + for j := 0; d.containerNext(j, containerLen, hasLen); j++ { + d.mapElemKey(j == 0) + sab, att := d.d.DecodeStringAsBytes() + rvkencname = d.usableStructFieldNameBytes(rvkencname, sab, att) + d.mapElemValue() + if si := ti.siForEncName(rvkencname); si != nil { + d.kStructField(si, rv) + } else { + d.structFieldNotFound(-1, stringView(rvkencname)) + } + } + d.mapEnd() + } else if ctyp == valueTypeArray { + containerLen := d.arrayStart(d.d.ReadArrayStart()) + if containerLen == 0 { + d.arrayEnd() + return + } + + tisfi := ti.sfi.source() + hasLen := containerLen >= 0 + + for j := 0; d.containerNext(j, containerLen, hasLen); j++ { + d.arrayElem(j == 0) + if j < len(tisfi) { + d.kStructField(tisfi[j], rv) + } else { + d.structFieldNotFound(j, "") + } + } + d.arrayEnd() + } else { + halt.onerror(errNeedMapOrArrayDecodeToStruct) + } +} + +func (d *decoderMsgpackBytes) kStruct(f *decFnInfo, rv reflect.Value) { + _ = d.d + ctyp := d.d.ContainerType() + ti := f.ti + var mf MissingFielder + if ti.flagMissingFielder { + mf = rv2i(rv).(MissingFielder) + } else if ti.flagMissingFielderPtr { + mf = rv2i(rvAddr(rv, ti.ptr)).(MissingFielder) + } + if ctyp == valueTypeMap { + containerLen := d.mapStart(d.d.ReadMapStart()) + if containerLen == 0 { + d.mapEnd() + return + } + hasLen := containerLen >= 0 + var name2 []byte + var rvkencname []byte + tkt := ti.keyType + for j := 0; d.containerNext(j, containerLen, hasLen); j++ { + d.mapElemKey(j == 0) + + if tkt == valueTypeString { + sab, att := d.d.DecodeStringAsBytes() + rvkencname = d.usableStructFieldNameBytes(rvkencname, sab, att) + } else if tkt == valueTypeInt { + rvkencname = strconv.AppendInt(d.b[:0], d.d.DecodeInt64(), 10) + } else if tkt == valueTypeUint { + rvkencname = strconv.AppendUint(d.b[:0], d.d.DecodeUint64(), 10) + } else if tkt == valueTypeFloat { + rvkencname = strconv.AppendFloat(d.b[:0], d.d.DecodeFloat64(), 'f', -1, 64) + } else { + halt.errorStr2("invalid struct key type: ", ti.keyType.String()) + } + + d.mapElemValue() + if si := ti.siForEncName(rvkencname); si != nil { + d.kStructField(si, rv) + } else if mf != nil { + + name2 = append(name2[:0], rvkencname...) + var f interface{} + d.decode(&f) + if !mf.CodecMissingField(name2, f) && d.h.ErrorIfNoField { + halt.errorStr2("no matching struct field when decoding stream map with key: ", stringView(name2)) + } + } else { + d.structFieldNotFound(-1, stringView(rvkencname)) + } + } + d.mapEnd() + } else if ctyp == valueTypeArray { + containerLen := d.arrayStart(d.d.ReadArrayStart()) + if containerLen == 0 { + d.arrayEnd() + return + } + + tisfi := ti.sfi.source() + hasLen := containerLen >= 0 + + for j := 0; d.containerNext(j, containerLen, hasLen); j++ { + d.arrayElem(j == 0) + if j < len(tisfi) { + d.kStructField(tisfi[j], rv) + } else { + d.structFieldNotFound(j, "") + } + } + + d.arrayEnd() + } else { + halt.onerror(errNeedMapOrArrayDecodeToStruct) + } +} + +func (d *decoderMsgpackBytes) kSlice(f *decFnInfo, rv reflect.Value) { + _ = d.d + + ti := f.ti + rvCanset := rv.CanSet() + + ctyp := d.d.ContainerType() + if ctyp == valueTypeBytes || ctyp == valueTypeString { + + if !(ti.rtid == uint8SliceTypId || ti.elemkind == uint8(reflect.Uint8)) { + halt.errorf("bytes/string in stream must decode into slice/array of bytes, not %v", ti.rt) + } + rvbs := rvGetBytes(rv) + if rvCanset { + bs2, bst := d.decodeBytesInto(rvbs, false) + if bst != dBytesIntoParamOut { + rvSetBytes(rv, bs2) + } + } else { + + d.decodeBytesInto(rvbs[:len(rvbs):len(rvbs)], true) + } + return + } + + var containerLenS int + isArray := ctyp == valueTypeArray + if isArray { + containerLenS = d.arrayStart(d.d.ReadArrayStart()) + } else if ctyp == valueTypeMap { + containerLenS = d.mapStart(d.d.ReadMapStart()) * 2 + } else { + halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String()) + } + + if containerLenS == 0 { + if rvCanset { + if rvIsNil(rv) { + rvSetDirect(rv, rvSliceZeroCap(ti.rt)) + } else { + rvSetSliceLen(rv, 0) + } + } + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } + return + } + + rtelem0Mut := !scalarBitset.isset(ti.elemkind) + rtelem := ti.elem + + for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() { + rtelem = rtelem.Elem() + } + + var fn *decFnMsgpackBytes + + var rvChanged bool + + var rv0 = rv + var rv9 reflect.Value + + rvlen := rvLenSlice(rv) + rvcap := rvCapSlice(rv) + maxInitLen := d.maxInitLen() + hasLen := containerLenS >= 0 + if hasLen { + if containerLenS > rvcap { + oldRvlenGtZero := rvlen > 0 + rvlen1 := int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize))) + if rvlen1 == rvlen { + } else if rvlen1 <= rvcap { + if rvCanset { + rvlen = rvlen1 + rvSetSliceLen(rv, rvlen) + } + } else if rvCanset { + rvlen = rvlen1 + rv, rvCanset = rvMakeSlice(rv, f.ti, rvlen, rvlen) + rvcap = rvlen + rvChanged = !rvCanset + } else { + halt.errorStr("cannot decode into non-settable slice") + } + if rvChanged && oldRvlenGtZero && rtelem0Mut { + rvCopySlice(rv, rv0, rtelem) + } + } else if containerLenS != rvlen { + if rvCanset { + rvlen = containerLenS + rvSetSliceLen(rv, rvlen) + } + } + } + + var elemReset = d.h.SliceElementReset + + var rtelemIsPtr bool + var rtelemElem reflect.Type + builtin := ti.tielem.flagDecBuiltin + if builtin { + rtelemIsPtr = ti.elemkind == uint8(reflect.Ptr) + if rtelemIsPtr { + rtelemElem = ti.elem.Elem() + } + } + + var j int + for ; d.containerNext(j, containerLenS, hasLen); j++ { + if j == 0 { + if rvIsNil(rv) { + if rvCanset { + rvlen = int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize))) + rv, rvCanset = rvMakeSlice(rv, f.ti, rvlen, rvlen) + rvcap = rvlen + rvChanged = !rvCanset + } else { + halt.errorStr("cannot decode into non-settable slice") + } + } + if fn == nil { + fn = d.fn(rtelem) + } + } + + if ctyp == valueTypeArray { + d.arrayElem(j == 0) + } else if j&1 == 0 { + d.mapElemKey(j == 0) + } else { + d.mapElemValue() + } + + if j >= rvlen { + + if rvlen < rvcap { + rvlen = rvcap + if rvCanset { + rvSetSliceLen(rv, rvlen) + } else if rvChanged { + rv = rvSlice(rv, rvlen) + } else { + halt.onerror(errExpandSliceCannotChange) + } + } else { + if !(rvCanset || rvChanged) { + halt.onerror(errExpandSliceCannotChange) + } + rv, rvcap, rvCanset = rvGrowSlice(rv, f.ti, rvcap, 1) + + rvlen = rvcap + rvChanged = !rvCanset + } + } + + rv9 = rvArrayIndex(rv, j, f.ti, true) + if elemReset { + rvSetZero(rv9) + } + if d.d.TryNil() { + rvSetZero(rv9) + } else if builtin { + if rtelemIsPtr { + if rvIsNil(rv9) { + rvSetDirect(rv9, reflect.New(rtelemElem)) + } + d.decode(rv2i(rv9)) + } else { + d.decode(rv2i(rvAddr(rv9, ti.tielem.ptr))) + } + } else { + d.decodeValueNoCheckNil(rv9, fn) + } + } + if j < rvlen { + if rvCanset { + rvSetSliceLen(rv, j) + } else if rvChanged { + rv = rvSlice(rv, j) + } + + } else if j == 0 && rvIsNil(rv) { + if rvCanset { + rv = rvSliceZeroCap(ti.rt) + rvCanset = false + rvChanged = true + } + } + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } + + if rvChanged { + rvSetDirect(rv0, rv) + } +} + +func (d *decoderMsgpackBytes) kArray(f *decFnInfo, rv reflect.Value) { + _ = d.d + + ti := f.ti + ctyp := d.d.ContainerType() + if handleBytesWithinKArray && (ctyp == valueTypeBytes || ctyp == valueTypeString) { + + if ti.elemkind != uint8(reflect.Uint8) { + halt.errorf("bytes/string in stream can decode into array of bytes, but not %v", ti.rt) + } + rvbs := rvGetArrayBytes(rv, nil) + d.decodeBytesInto(rvbs, true) + return + } + + var containerLenS int + isArray := ctyp == valueTypeArray + if isArray { + containerLenS = d.arrayStart(d.d.ReadArrayStart()) + } else if ctyp == valueTypeMap { + containerLenS = d.mapStart(d.d.ReadMapStart()) * 2 + } else { + halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String()) + } + + if containerLenS == 0 { + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } + return + } + + rtelem := ti.elem + for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() { + rtelem = rtelem.Elem() + } + + var rv9 reflect.Value + + rvlen := rv.Len() + hasLen := containerLenS >= 0 + if hasLen && containerLenS > rvlen { + halt.errorf("cannot decode into array with length: %v, less than container length: %v", any(rvlen), any(containerLenS)) + } + + var elemReset = d.h.SliceElementReset + + var rtelemIsPtr bool + var rtelemElem reflect.Type + var fn *decFnMsgpackBytes + builtin := ti.tielem.flagDecBuiltin + if builtin { + rtelemIsPtr = ti.elemkind == uint8(reflect.Ptr) + if rtelemIsPtr { + rtelemElem = ti.elem.Elem() + } + } else { + fn = d.fn(rtelem) + } + + for j := 0; d.containerNext(j, containerLenS, hasLen); j++ { + if ctyp == valueTypeArray { + d.arrayElem(j == 0) + } else if j&1 == 0 { + d.mapElemKey(j == 0) + } else { + d.mapElemValue() + } + + if j >= rvlen { + d.arrayCannotExpand(rvlen, j+1) + d.swallow() + continue + } + + rv9 = rvArrayIndex(rv, j, f.ti, false) + if elemReset { + rvSetZero(rv9) + } + if d.d.TryNil() { + rvSetZero(rv9) + } else if builtin { + if rtelemIsPtr { + if rvIsNil(rv9) { + rvSetDirect(rv9, reflect.New(rtelemElem)) + } + d.decode(rv2i(rv9)) + } else { + d.decode(rv2i(rvAddr(rv9, ti.tielem.ptr))) + } + } else { + d.decodeValueNoCheckNil(rv9, fn) + } + } + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } +} + +func (d *decoderMsgpackBytes) kChan(f *decFnInfo, rv reflect.Value) { + _ = d.d + + ti := f.ti + if ti.chandir&uint8(reflect.SendDir) == 0 { + halt.errorStr("receive-only channel cannot be decoded") + } + ctyp := d.d.ContainerType() + if ctyp == valueTypeBytes || ctyp == valueTypeString { + + if !(ti.rtid == uint8SliceTypId || ti.elemkind == uint8(reflect.Uint8)) { + halt.errorf("bytes/string in stream must decode into slice/array of bytes, not %v", ti.rt) + } + bs2, _ := d.d.DecodeBytes() + irv := rv2i(rv) + ch, ok := irv.(chan<- byte) + if !ok { + ch = irv.(chan byte) + } + for _, b := range bs2 { + ch <- b + } + return + } + + var rvCanset = rv.CanSet() + + var containerLenS int + isArray := ctyp == valueTypeArray + if isArray { + containerLenS = d.arrayStart(d.d.ReadArrayStart()) + } else if ctyp == valueTypeMap { + containerLenS = d.mapStart(d.d.ReadMapStart()) * 2 + } else { + halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String()) + } + + if containerLenS == 0 { + if rvCanset && rvIsNil(rv) { + rvSetDirect(rv, reflect.MakeChan(ti.rt, 0)) + } + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } + return + } + + rtelem := ti.elem + useTransient := decUseTransient && ti.elemkind != byte(reflect.Ptr) && ti.tielem.flagCanTransient + + for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() { + rtelem = rtelem.Elem() + } + + var fn *decFnMsgpackBytes + + var rvChanged bool + var rv0 = rv + var rv9 reflect.Value + + var rvlen int + hasLen := containerLenS >= 0 + maxInitLen := d.maxInitLen() + + for j := 0; d.containerNext(j, containerLenS, hasLen); j++ { + if j == 0 { + if rvIsNil(rv) { + if hasLen { + rvlen = int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize))) + } else { + rvlen = decDefChanCap + } + if rvCanset { + rv = reflect.MakeChan(ti.rt, rvlen) + rvChanged = true + } else { + halt.errorStr("cannot decode into non-settable chan") + } + } + if fn == nil { + fn = d.fn(rtelem) + } + } + + if ctyp == valueTypeArray { + d.arrayElem(j == 0) + } else if j&1 == 0 { + d.mapElemKey(j == 0) + } else { + d.mapElemValue() + } + + if rv9.IsValid() { + rvSetZero(rv9) + } else if useTransient { + rv9 = d.perType.TransientAddrK(ti.elem, reflect.Kind(ti.elemkind)) + } else { + rv9 = rvZeroAddrK(ti.elem, reflect.Kind(ti.elemkind)) + } + if !d.d.TryNil() { + d.decodeValueNoCheckNil(rv9, fn) + } + rv.Send(rv9) + } + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } + + if rvChanged { + rvSetDirect(rv0, rv) + } + +} + +func (d *decoderMsgpackBytes) kMap(f *decFnInfo, rv reflect.Value) { + _ = d.d + containerLen := d.mapStart(d.d.ReadMapStart()) + ti := f.ti + if rvIsNil(rv) { + rvlen := int(decInferLen(containerLen, d.maxInitLen(), uint(ti.keysize+ti.elemsize))) + rvSetDirect(rv, makeMapReflect(ti.rt, rvlen)) + } + + if containerLen == 0 { + d.mapEnd() + return + } + + ktype, vtype := ti.key, ti.elem + ktypeId := rt2id(ktype) + vtypeKind := reflect.Kind(ti.elemkind) + ktypeKind := reflect.Kind(ti.keykind) + mparams := getMapReqParams(ti) + + vtypePtr := vtypeKind == reflect.Ptr + ktypePtr := ktypeKind == reflect.Ptr + + vTransient := decUseTransient && !vtypePtr && ti.tielem.flagCanTransient + + kTransient := vTransient && !ktypePtr && ti.tikey.flagCanTransient + + var vtypeElem reflect.Type + + var keyFn, valFn *decFnMsgpackBytes + var ktypeLo, vtypeLo = ktype, vtype + + if ktypeKind == reflect.Ptr { + for ktypeLo = ktype.Elem(); ktypeLo.Kind() == reflect.Ptr; ktypeLo = ktypeLo.Elem() { + } + } + + if vtypePtr { + vtypeElem = vtype.Elem() + for vtypeLo = vtypeElem; vtypeLo.Kind() == reflect.Ptr; vtypeLo = vtypeLo.Elem() { + } + } + + rvkMut := !scalarBitset.isset(ti.keykind) + rvvMut := !scalarBitset.isset(ti.elemkind) + rvvCanNil := isnilBitset.isset(ti.elemkind) + + var rvk, rvkn, rvv, rvvn, rvva, rvvz reflect.Value + + var doMapGet, doMapSet bool + + if !d.h.MapValueReset { + if rvvMut && (vtypeKind != reflect.Interface || !d.h.InterfaceReset) { + doMapGet = true + rvva = mapAddrLoopvarRV(vtype, vtypeKind) + } + } + + ktypeIsString := ktypeId == stringTypId + ktypeIsIntf := ktypeId == intfTypId + hasLen := containerLen >= 0 + + var kstr2bs []byte + var kstr string + + var mapKeyStringSharesBytesBuf bool + var att dBytesAttachState + + var vElem, kElem reflect.Type + kbuiltin := ti.tikey.flagDecBuiltin && ti.keykind != uint8(reflect.Slice) + vbuiltin := ti.tielem.flagDecBuiltin + if kbuiltin && ktypePtr { + kElem = ti.key.Elem() + } + if vbuiltin && vtypePtr { + vElem = ti.elem.Elem() + } + + for j := 0; d.containerNext(j, containerLen, hasLen); j++ { + mapKeyStringSharesBytesBuf = false + kstr = "" + if j == 0 { + + if kTransient { + rvk = d.perType.TransientAddr2K(ktype, ktypeKind) + } else { + rvk = rvZeroAddrK(ktype, ktypeKind) + } + if !rvkMut { + rvkn = rvk + } + if !rvvMut { + if vTransient { + rvvn = d.perType.TransientAddrK(vtype, vtypeKind) + } else { + rvvn = rvZeroAddrK(vtype, vtypeKind) + } + } + if !ktypeIsString && keyFn == nil { + keyFn = d.fn(ktypeLo) + } + if valFn == nil { + valFn = d.fn(vtypeLo) + } + } else if rvkMut { + rvSetZero(rvk) + } else { + rvk = rvkn + } + + d.mapElemKey(j == 0) + + if d.d.TryNil() { + rvSetZero(rvk) + } else if ktypeIsString { + kstr2bs, att = d.d.DecodeStringAsBytes() + kstr, mapKeyStringSharesBytesBuf = d.bytes2Str(kstr2bs, att) + rvSetString(rvk, kstr) + } else { + if kbuiltin { + if ktypePtr { + if rvIsNil(rvk) { + rvSetDirect(rvk, reflect.New(kElem)) + } + d.decode(rv2i(rvk)) + } else { + d.decode(rv2i(rvAddr(rvk, ti.tikey.ptr))) + } + } else { + d.decodeValueNoCheckNil(rvk, keyFn) + } + + if ktypeIsIntf { + if rvk2 := rvk.Elem(); rvk2.IsValid() && rvk2.Type() == uint8SliceTyp { + kstr2bs = rvGetBytes(rvk2) + kstr, mapKeyStringSharesBytesBuf = d.bytes2Str(kstr2bs, dBytesAttachView) + rvSetIntf(rvk, rv4istr(kstr)) + } + + } + } + + if mapKeyStringSharesBytesBuf && d.bufio { + if ktypeIsString { + rvSetString(rvk, d.detach2Str(kstr2bs, att)) + } else { + rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att))) + } + mapKeyStringSharesBytesBuf = false + } + + d.mapElemValue() + + if d.d.TryNil() { + if mapKeyStringSharesBytesBuf { + if ktypeIsString { + rvSetString(rvk, d.detach2Str(kstr2bs, att)) + } else { + rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att))) + } + } + + if !rvvz.IsValid() { + rvvz = rvZeroK(vtype, vtypeKind) + } + mapSet(rv, rvk, rvvz, mparams) + continue + } + + doMapSet = true + + if !rvvMut { + rvv = rvvn + } else if !doMapGet { + goto NEW_RVV + } else { + rvv = mapGet(rv, rvk, rvva, mparams) + if !rvv.IsValid() || (rvvCanNil && rvIsNil(rvv)) { + goto NEW_RVV + } + switch vtypeKind { + case reflect.Ptr, reflect.Map: + doMapSet = false + case reflect.Interface: + + rvvn = rvv.Elem() + if k := rvvn.Kind(); (k == reflect.Ptr || k == reflect.Map) && !rvIsNil(rvvn) { + d.decodeValueNoCheckNil(rvvn, nil) + continue + } + + rvvn = rvZeroAddrK(vtype, vtypeKind) + rvSetIntf(rvvn, rvv) + rvv = rvvn + default: + + if vTransient { + rvvn = d.perType.TransientAddrK(vtype, vtypeKind) + } else { + rvvn = rvZeroAddrK(vtype, vtypeKind) + } + rvSetDirect(rvvn, rvv) + rvv = rvvn + } + } + goto DECODE_VALUE_NO_CHECK_NIL + + NEW_RVV: + if vtypePtr { + rvv = reflect.New(vtypeElem) + } else if vTransient { + rvv = d.perType.TransientAddrK(vtype, vtypeKind) + } else { + rvv = rvZeroAddrK(vtype, vtypeKind) + } + + DECODE_VALUE_NO_CHECK_NIL: + if doMapSet && mapKeyStringSharesBytesBuf { + if ktypeIsString { + rvSetString(rvk, d.detach2Str(kstr2bs, att)) + } else { + rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att))) + } + } + if vbuiltin { + if vtypePtr { + if rvIsNil(rvv) { + rvSetDirect(rvv, reflect.New(vElem)) + } + d.decode(rv2i(rvv)) + } else { + d.decode(rv2i(rvAddr(rvv, ti.tielem.ptr))) + } + } else { + d.decodeValueNoCheckNil(rvv, valFn) + } + if doMapSet { + mapSet(rv, rvk, rvv, mparams) + } + } + + d.mapEnd() +} + +func (d *decoderMsgpackBytes) init(h Handle) { + initHandle(h) + callMake(&d.d) + d.hh = h + d.h = h.getBasicHandle() + + d.err = errDecoderNotInitialized + + if d.h.InternString && d.is == nil { + d.is.init() + } + + d.fp = d.d.init(h, &d.decoderBase, d).(*fastpathDsMsgpackBytes) + + if d.bytes { + d.rtidFn = &d.h.rtidFnsDecBytes + d.rtidFnNoExt = &d.h.rtidFnsDecNoExtBytes + } else { + d.bufio = d.h.ReaderBufferSize > 0 + d.rtidFn = &d.h.rtidFnsDecIO + d.rtidFnNoExt = &d.h.rtidFnsDecNoExtIO + } + + d.reset() + +} + +func (d *decoderMsgpackBytes) reset() { + d.d.reset() + d.err = nil + d.c = 0 + d.depth = 0 + d.calls = 0 + + d.maxdepth = decDefMaxDepth + if d.h.MaxDepth > 0 { + d.maxdepth = d.h.MaxDepth + } + d.mtid = 0 + d.stid = 0 + d.mtr = false + d.str = false + if d.h.MapType != nil { + d.mtid = rt2id(d.h.MapType) + _, d.mtr = fastpathAvIndex(d.mtid) + } + if d.h.SliceType != nil { + d.stid = rt2id(d.h.SliceType) + _, d.str = fastpathAvIndex(d.stid) + } +} + +func (d *decoderMsgpackBytes) Reset(r io.Reader) { + if d.bytes { + halt.onerror(errDecNoResetBytesWithReader) + } + d.reset() + if r == nil { + r = &eofReader + } + d.d.resetInIO(r) +} + +func (d *decoderMsgpackBytes) ResetBytes(in []byte) { + if !d.bytes { + halt.onerror(errDecNoResetReaderWithBytes) + } + d.resetBytes(in) +} + +func (d *decoderMsgpackBytes) resetBytes(in []byte) { + d.reset() + if in == nil { + in = zeroByteSlice + } + d.d.resetInBytes(in) +} + +func (d *decoderMsgpackBytes) ResetString(s string) { + d.ResetBytes(bytesView(s)) +} + +func (d *decoderMsgpackBytes) Decode(v interface{}) (err error) { + + defer panicValToErr(d, callRecoverSentinel, &d.err, &err, debugging) + d.mustDecode(v) + return +} + +func (d *decoderMsgpackBytes) MustDecode(v interface{}) { + defer panicValToErr(d, callRecoverSentinel, &d.err, nil, true) + d.mustDecode(v) + return +} + +func (d *decoderMsgpackBytes) mustDecode(v interface{}) { + halt.onerror(d.err) + if d.hh == nil { + halt.onerror(errNoFormatHandle) + } + + d.calls++ + d.decode(v) + d.calls-- +} + +func (d *decoderMsgpackBytes) Release() {} + +func (d *decoderMsgpackBytes) swallow() { + d.d.nextValueBytes() +} + +func (d *decoderMsgpackBytes) nextValueBytes() []byte { + return d.d.nextValueBytes() +} + +func (d *decoderMsgpackBytes) decode(iv interface{}) { + _ = d.d + + rv, ok := isNil(iv, true) + if ok { + halt.onerror(errCannotDecodeIntoNil) + } + + switch v := iv.(type) { + + case *string: + *v = d.detach2Str(d.d.DecodeStringAsBytes()) + case *bool: + *v = d.d.DecodeBool() + case *int: + *v = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize)) + case *int8: + *v = int8(chkOvf.IntV(d.d.DecodeInt64(), 8)) + case *int16: + *v = int16(chkOvf.IntV(d.d.DecodeInt64(), 16)) + case *int32: + *v = int32(chkOvf.IntV(d.d.DecodeInt64(), 32)) + case *int64: + *v = d.d.DecodeInt64() + case *uint: + *v = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize)) + case *uint8: + *v = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8)) + case *uint16: + *v = uint16(chkOvf.UintV(d.d.DecodeUint64(), 16)) + case *uint32: + *v = uint32(chkOvf.UintV(d.d.DecodeUint64(), 32)) + case *uint64: + *v = d.d.DecodeUint64() + case *uintptr: + *v = uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize)) + case *float32: + *v = d.d.DecodeFloat32() + case *float64: + *v = d.d.DecodeFloat64() + case *complex64: + *v = complex(d.d.DecodeFloat32(), 0) + case *complex128: + *v = complex(d.d.DecodeFloat64(), 0) + case *[]byte: + *v, _ = d.decodeBytesInto(*v, false) + case []byte: + + d.decodeBytesInto(v[:len(v):len(v)], true) + case *time.Time: + *v = d.d.DecodeTime() + case *Raw: + *v = d.rawBytes() + + case *interface{}: + d.decodeValue(rv4iptr(v), nil) + + case reflect.Value: + if ok, _ = isDecodeable(v); !ok { + d.haltAsNotDecodeable(v) + } + d.decodeValue(v, nil) + + default: + + if skipFastpathTypeSwitchInDirectCall || !d.dh.fastpathDecodeTypeSwitch(iv, d) { + if !rv.IsValid() { + rv = reflect.ValueOf(iv) + } + if ok, _ = isDecodeable(rv); !ok { + d.haltAsNotDecodeable(rv) + } + d.decodeValue(rv, nil) + } + } +} + +func (d *decoderMsgpackBytes) decodeValue(rv reflect.Value, fn *decFnMsgpackBytes) { + if d.d.TryNil() { + decSetNonNilRV2Zero(rv) + } else { + d.decodeValueNoCheckNil(rv, fn) + } +} + +func (d *decoderMsgpackBytes) decodeValueNoCheckNil(rv reflect.Value, fn *decFnMsgpackBytes) { + + var rvp reflect.Value + var rvpValid bool +PTR: + if rv.Kind() == reflect.Ptr { + rvpValid = true + if rvIsNil(rv) { + rvSetDirect(rv, reflect.New(rv.Type().Elem())) + } + rvp = rv + rv = rv.Elem() + goto PTR + } + + if fn == nil { + fn = d.fn(rv.Type()) + } + if fn.i.addrD { + if rvpValid { + rv = rvp + } else if rv.CanAddr() { + rv = rvAddr(rv, fn.i.ti.ptr) + } else if fn.i.addrDf { + halt.errorStr("cannot decode into a non-pointer value") + } + } + fn.fd(d, &fn.i, rv) +} + +func (d *decoderMsgpackBytes) decodeAs(v interface{}, t reflect.Type, ext bool) { + if ext { + d.decodeValue(baseRV(v), d.fn(t)) + } else { + d.decodeValue(baseRV(v), d.fnNoExt(t)) + } +} + +func (d *decoderMsgpackBytes) structFieldNotFound(index int, rvkencname string) { + + if d.h.ErrorIfNoField { + if index >= 0 { + halt.errorInt("no matching struct field found when decoding stream array at index ", int64(index)) + } else if rvkencname != "" { + halt.errorStr2("no matching struct field found when decoding stream map with key ", rvkencname) + } + } + d.swallow() +} + +func (d *decoderMsgpackBytes) decodeBytesInto(out []byte, mustFit bool) (v []byte, state dBytesIntoState) { + v, att := d.d.DecodeBytes() + if cap(v) == 0 || (att >= dBytesAttachViewZerocopy && !mustFit) { + + return + } + if len(v) == 0 { + v = zeroByteSlice + return + } + if len(out) == len(v) { + state = dBytesIntoParamOut + } else if cap(out) >= len(v) { + out = out[:len(v)] + state = dBytesIntoParamOutSlice + } else if mustFit { + halt.errorf("bytes capacity insufficient for decoded bytes: got/expected: %d/%d", len(v), len(out)) + } else { + out = make([]byte, len(v)) + state = dBytesIntoNew + } + copy(out, v) + v = out + return +} + +func (d *decoderMsgpackBytes) rawBytes() (v []byte) { + + v = d.d.nextValueBytes() + if d.bytes && !d.h.ZeroCopy { + vv := make([]byte, len(v)) + copy(vv, v) + v = vv + } + return +} + +func (d *decoderMsgpackBytes) wrapErr(v error, err *error) { + *err = wrapCodecErr(v, d.hh.Name(), d.d.NumBytesRead(), false) +} + +func (d *decoderMsgpackBytes) NumBytesRead() int { + return d.d.NumBytesRead() +} + +func (d *decoderMsgpackBytes) containerNext(j, containerLen int, hasLen bool) bool { + + if hasLen { + return j < containerLen + } + return !d.d.CheckBreak() +} + +func (d *decoderMsgpackBytes) mapElemKey(firstTime bool) { + d.d.ReadMapElemKey(firstTime) + d.c = containerMapKey +} + +func (d *decoderMsgpackBytes) mapElemValue() { + d.d.ReadMapElemValue() + d.c = containerMapValue +} + +func (d *decoderMsgpackBytes) mapEnd() { + d.d.ReadMapEnd() + d.depthDecr() + d.c = 0 +} + +func (d *decoderMsgpackBytes) arrayElem(firstTime bool) { + d.d.ReadArrayElem(firstTime) + d.c = containerArrayElem +} + +func (d *decoderMsgpackBytes) arrayEnd() { + d.d.ReadArrayEnd() + d.depthDecr() + d.c = 0 +} + +func (d *decoderMsgpackBytes) interfaceExtConvertAndDecode(v interface{}, ext InterfaceExt) { + + var vv interface{} + d.decode(&vv) + ext.UpdateExt(v, vv) + +} + +func (d *decoderMsgpackBytes) fn(t reflect.Type) *decFnMsgpackBytes { + return d.dh.decFnViaBH(t, d.rtidFn, d.h, d.fp, false) +} + +func (d *decoderMsgpackBytes) fnNoExt(t reflect.Type) *decFnMsgpackBytes { + return d.dh.decFnViaBH(t, d.rtidFnNoExt, d.h, d.fp, true) +} + +func (helperDecDriverMsgpackBytes) newDecoderBytes(in []byte, h Handle) *decoderMsgpackBytes { + var c1 decoderMsgpackBytes + c1.bytes = true + c1.init(h) + c1.ResetBytes(in) + return &c1 +} + +func (helperDecDriverMsgpackBytes) newDecoderIO(in io.Reader, h Handle) *decoderMsgpackBytes { + var c1 decoderMsgpackBytes + c1.init(h) + c1.Reset(in) + return &c1 +} + +func (helperDecDriverMsgpackBytes) decFnloadFastpathUnderlying(ti *typeInfo, fp *fastpathDsMsgpackBytes) (f *fastpathDMsgpackBytes, u reflect.Type) { + rtid := rt2id(ti.fastpathUnderlying) + idx, ok := fastpathAvIndex(rtid) + if !ok { + return + } + f = &fp[idx] + if uint8(reflect.Array) == ti.kind { + u = reflect.ArrayOf(ti.rt.Len(), ti.elem) + } else { + u = f.rt + } + return +} + +func (helperDecDriverMsgpackBytes) decFindRtidFn(s []decRtidFnMsgpackBytes, rtid uintptr) (i uint, fn *decFnMsgpackBytes) { + + var h uint + var j = uint(len(s)) +LOOP: + if i < j { + h = (i + j) >> 1 + if s[h].rtid < rtid { + i = h + 1 + } else { + j = h + } + goto LOOP + } + if i < uint(len(s)) && s[i].rtid == rtid { + fn = s[i].fn + } + return +} + +func (helperDecDriverMsgpackBytes) decFromRtidFnSlice(fns *atomicRtidFnSlice) (s []decRtidFnMsgpackBytes) { + if v := fns.load(); v != nil { + s = *(lowLevelToPtr[[]decRtidFnMsgpackBytes](v)) + } + return +} + +func (dh helperDecDriverMsgpackBytes) decFnViaBH(rt reflect.Type, fns *atomicRtidFnSlice, x *BasicHandle, fp *fastpathDsMsgpackBytes, + checkExt bool) (fn *decFnMsgpackBytes) { + return dh.decFnVia(rt, fns, x.typeInfos(), &x.mu, x.extHandle, fp, + checkExt, x.CheckCircularRef, x.timeBuiltin, x.binaryHandle, x.jsonHandle) +} + +func (dh helperDecDriverMsgpackBytes) decFnVia(rt reflect.Type, fns *atomicRtidFnSlice, + tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathDsMsgpackBytes, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackBytes) { + rtid := rt2id(rt) + var sp []decRtidFnMsgpackBytes = dh.decFromRtidFnSlice(fns) + if sp != nil { + _, fn = dh.decFindRtidFn(sp, rtid) + } + if fn == nil { + fn = dh.decFnViaLoader(rt, rtid, fns, tinfos, mu, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json) + } + return +} + +func (dh helperDecDriverMsgpackBytes) decFnViaLoader(rt reflect.Type, rtid uintptr, fns *atomicRtidFnSlice, + tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathDsMsgpackBytes, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackBytes) { + + fn = dh.decFnLoad(rt, rtid, tinfos, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json) + var sp []decRtidFnMsgpackBytes + mu.Lock() + sp = dh.decFromRtidFnSlice(fns) + + if sp == nil { + sp = []decRtidFnMsgpackBytes{{rtid, fn}} + fns.store(ptrToLowLevel(&sp)) + } else { + idx, fn2 := dh.decFindRtidFn(sp, rtid) + if fn2 == nil { + sp2 := make([]decRtidFnMsgpackBytes, len(sp)+1) + copy(sp2[idx+1:], sp[idx:]) + copy(sp2, sp[:idx]) + sp2[idx] = decRtidFnMsgpackBytes{rtid, fn} + fns.store(ptrToLowLevel(&sp2)) + } + } + mu.Unlock() + return +} + +func (dh helperDecDriverMsgpackBytes) decFnLoad(rt reflect.Type, rtid uintptr, tinfos *TypeInfos, + exth extHandle, fp *fastpathDsMsgpackBytes, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackBytes) { + fn = new(decFnMsgpackBytes) + fi := &(fn.i) + ti := tinfos.get(rtid, rt) + fi.ti = ti + rk := reflect.Kind(ti.kind) + + fi.addrDf = true + + if rtid == timeTypId && timeBuiltin { + fn.fd = (*decoderMsgpackBytes).kTime + } else if rtid == rawTypId { + fn.fd = (*decoderMsgpackBytes).raw + } else if rtid == rawExtTypId { + fn.fd = (*decoderMsgpackBytes).rawExt + fi.addrD = true + } else if xfFn := exth.getExt(rtid, checkExt); xfFn != nil { + fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext + fn.fd = (*decoderMsgpackBytes).ext + fi.addrD = true + } else if ti.flagSelfer || ti.flagSelferPtr { + fn.fd = (*decoderMsgpackBytes).selferUnmarshal + fi.addrD = ti.flagSelferPtr + } else if supportMarshalInterfaces && binaryEncoding && + (ti.flagBinaryMarshaler || ti.flagBinaryMarshalerPtr) && + (ti.flagBinaryUnmarshaler || ti.flagBinaryUnmarshalerPtr) { + fn.fd = (*decoderMsgpackBytes).binaryUnmarshal + fi.addrD = ti.flagBinaryUnmarshalerPtr + } else if supportMarshalInterfaces && !binaryEncoding && json && + (ti.flagJsonMarshaler || ti.flagJsonMarshalerPtr) && + (ti.flagJsonUnmarshaler || ti.flagJsonUnmarshalerPtr) { + + fn.fd = (*decoderMsgpackBytes).jsonUnmarshal + fi.addrD = ti.flagJsonUnmarshalerPtr + } else if supportMarshalInterfaces && !binaryEncoding && + (ti.flagTextMarshaler || ti.flagTextMarshalerPtr) && + (ti.flagTextUnmarshaler || ti.flagTextUnmarshalerPtr) { + fn.fd = (*decoderMsgpackBytes).textUnmarshal + fi.addrD = ti.flagTextUnmarshalerPtr + } else { + if fastpathEnabled && (rk == reflect.Map || rk == reflect.Slice || rk == reflect.Array) { + var rtid2 uintptr + if !ti.flagHasPkgPath { + rtid2 = rtid + if rk == reflect.Array { + rtid2 = rt2id(ti.key) + } + if idx, ok := fastpathAvIndex(rtid2); ok { + fn.fd = fp[idx].decfn + fi.addrD = true + fi.addrDf = false + if rk == reflect.Array { + fi.addrD = false + } + } + } else { + + xfe, xrt := dh.decFnloadFastpathUnderlying(ti, fp) + if xfe != nil { + xfnf2 := xfe.decfn + if rk == reflect.Array { + fi.addrD = false + fn.fd = func(d *decoderMsgpackBytes, xf *decFnInfo, xrv reflect.Value) { + xfnf2(d, xf, rvConvert(xrv, xrt)) + } + } else { + fi.addrD = true + fi.addrDf = false + xptr2rt := reflect.PointerTo(xrt) + fn.fd = func(d *decoderMsgpackBytes, xf *decFnInfo, xrv reflect.Value) { + if xrv.Kind() == reflect.Ptr { + xfnf2(d, xf, rvConvert(xrv, xptr2rt)) + } else { + xfnf2(d, xf, rvConvert(xrv, xrt)) + } + } + } + } + } + } + if fn.fd == nil { + switch rk { + case reflect.Bool: + fn.fd = (*decoderMsgpackBytes).kBool + case reflect.String: + fn.fd = (*decoderMsgpackBytes).kString + case reflect.Int: + fn.fd = (*decoderMsgpackBytes).kInt + case reflect.Int8: + fn.fd = (*decoderMsgpackBytes).kInt8 + case reflect.Int16: + fn.fd = (*decoderMsgpackBytes).kInt16 + case reflect.Int32: + fn.fd = (*decoderMsgpackBytes).kInt32 + case reflect.Int64: + fn.fd = (*decoderMsgpackBytes).kInt64 + case reflect.Uint: + fn.fd = (*decoderMsgpackBytes).kUint + case reflect.Uint8: + fn.fd = (*decoderMsgpackBytes).kUint8 + case reflect.Uint16: + fn.fd = (*decoderMsgpackBytes).kUint16 + case reflect.Uint32: + fn.fd = (*decoderMsgpackBytes).kUint32 + case reflect.Uint64: + fn.fd = (*decoderMsgpackBytes).kUint64 + case reflect.Uintptr: + fn.fd = (*decoderMsgpackBytes).kUintptr + case reflect.Float32: + fn.fd = (*decoderMsgpackBytes).kFloat32 + case reflect.Float64: + fn.fd = (*decoderMsgpackBytes).kFloat64 + case reflect.Complex64: + fn.fd = (*decoderMsgpackBytes).kComplex64 + case reflect.Complex128: + fn.fd = (*decoderMsgpackBytes).kComplex128 + case reflect.Chan: + fn.fd = (*decoderMsgpackBytes).kChan + case reflect.Slice: + fn.fd = (*decoderMsgpackBytes).kSlice + case reflect.Array: + fi.addrD = false + fn.fd = (*decoderMsgpackBytes).kArray + case reflect.Struct: + if ti.simple { + fn.fd = (*decoderMsgpackBytes).kStructSimple + } else { + fn.fd = (*decoderMsgpackBytes).kStruct + } + case reflect.Map: + fn.fd = (*decoderMsgpackBytes).kMap + case reflect.Interface: + + fn.fd = (*decoderMsgpackBytes).kInterface + default: + + fn.fd = (*decoderMsgpackBytes).kErr + } + } + } + return +} +func (e *msgpackEncDriverBytes) EncodeNil() { + e.w.writen1(mpNil) +} + +func (e *msgpackEncDriverBytes) EncodeInt(i int64) { + if e.h.PositiveIntUnsigned && i >= 0 { + e.EncodeUint(uint64(i)) + } else if i > math.MaxInt8 { + if i <= math.MaxInt16 { + e.w.writen1(mpInt16) + e.w.writen2(bigen.PutUint16(uint16(i))) + } else if i <= math.MaxInt32 { + e.w.writen1(mpInt32) + e.w.writen4(bigen.PutUint32(uint32(i))) + } else { + e.w.writen1(mpInt64) + e.w.writen8(bigen.PutUint64(uint64(i))) + } + } else if i >= -32 { + if e.h.NoFixedNum { + e.w.writen2(mpInt8, byte(i)) + } else { + e.w.writen1(byte(i)) + } + } else if i >= math.MinInt8 { + e.w.writen2(mpInt8, byte(i)) + } else if i >= math.MinInt16 { + e.w.writen1(mpInt16) + e.w.writen2(bigen.PutUint16(uint16(i))) + } else if i >= math.MinInt32 { + e.w.writen1(mpInt32) + e.w.writen4(bigen.PutUint32(uint32(i))) + } else { + e.w.writen1(mpInt64) + e.w.writen8(bigen.PutUint64(uint64(i))) + } +} + +func (e *msgpackEncDriverBytes) EncodeUint(i uint64) { + if i <= math.MaxInt8 { + if e.h.NoFixedNum { + e.w.writen2(mpUint8, byte(i)) + } else { + e.w.writen1(byte(i)) + } + } else if i <= math.MaxUint8 { + e.w.writen2(mpUint8, byte(i)) + } else if i <= math.MaxUint16 { + e.w.writen1(mpUint16) + e.w.writen2(bigen.PutUint16(uint16(i))) + } else if i <= math.MaxUint32 { + e.w.writen1(mpUint32) + e.w.writen4(bigen.PutUint32(uint32(i))) + } else { + e.w.writen1(mpUint64) + e.w.writen8(bigen.PutUint64(uint64(i))) + } +} + +func (e *msgpackEncDriverBytes) EncodeBool(b bool) { + if b { + e.w.writen1(mpTrue) + } else { + e.w.writen1(mpFalse) + } +} + +func (e *msgpackEncDriverBytes) EncodeFloat32(f float32) { + e.w.writen1(mpFloat) + e.w.writen4(bigen.PutUint32(math.Float32bits(f))) +} + +func (e *msgpackEncDriverBytes) EncodeFloat64(f float64) { + e.w.writen1(mpDouble) + e.w.writen8(bigen.PutUint64(math.Float64bits(f))) +} + +func (e *msgpackEncDriverBytes) EncodeTime(t time.Time) { + if t.IsZero() { + e.EncodeNil() + return + } + t = t.UTC() + sec, nsec := t.Unix(), uint64(t.Nanosecond()) + var data64 uint64 + var l = 4 + if sec >= 0 && sec>>34 == 0 { + data64 = (nsec << 34) | uint64(sec) + if data64&0xffffffff00000000 != 0 { + l = 8 + } + } else { + l = 12 + } + if e.h.WriteExt { + e.encodeExtPreamble(mpTimeExtTagU, l) + } else { + e.writeContainerLen(msgpackContainerRawLegacy, l) + } + switch l { + case 4: + e.w.writen4(bigen.PutUint32(uint32(data64))) + case 8: + e.w.writen8(bigen.PutUint64(data64)) + case 12: + e.w.writen4(bigen.PutUint32(uint32(nsec))) + e.w.writen8(bigen.PutUint64(uint64(sec))) + } +} + +func (e *msgpackEncDriverBytes) EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext) { + var bs0, bs []byte + if ext == SelfExt { + bs0 = e.e.blist.get(1024) + bs = bs0 + sideEncode(e.h, &e.h.sideEncPool, func(se encoderI) { oneOffEncode(se, v, &bs, basetype, true) }) + } else { + bs = ext.WriteExt(v) + } + if bs == nil { + e.writeNilBytes() + goto END + } + if e.h.WriteExt { + e.encodeExtPreamble(uint8(xtag), len(bs)) + e.w.writeb(bs) + } else { + e.EncodeBytes(bs) + } +END: + if ext == SelfExt { + e.e.blist.put(bs) + if !byteSliceSameData(bs0, bs) { + e.e.blist.put(bs0) + } + } +} + +func (e *msgpackEncDriverBytes) EncodeRawExt(re *RawExt) { + e.encodeExtPreamble(uint8(re.Tag), len(re.Data)) + e.w.writeb(re.Data) +} + +func (e *msgpackEncDriverBytes) encodeExtPreamble(xtag byte, l int) { + if l == 1 { + e.w.writen2(mpFixExt1, xtag) + } else if l == 2 { + e.w.writen2(mpFixExt2, xtag) + } else if l == 4 { + e.w.writen2(mpFixExt4, xtag) + } else if l == 8 { + e.w.writen2(mpFixExt8, xtag) + } else if l == 16 { + e.w.writen2(mpFixExt16, xtag) + } else if l < 256 { + e.w.writen2(mpExt8, byte(l)) + e.w.writen1(xtag) + } else if l < 65536 { + e.w.writen1(mpExt16) + e.w.writen2(bigen.PutUint16(uint16(l))) + e.w.writen1(xtag) + } else { + e.w.writen1(mpExt32) + e.w.writen4(bigen.PutUint32(uint32(l))) + e.w.writen1(xtag) + } +} + +func (e *msgpackEncDriverBytes) WriteArrayStart(length int) { + e.writeContainerLen(msgpackContainerList, length) +} + +func (e *msgpackEncDriverBytes) WriteMapStart(length int) { + e.writeContainerLen(msgpackContainerMap, length) +} + +func (e *msgpackEncDriverBytes) WriteArrayEmpty() { + + e.w.writen1(mpFixArrayMin) +} + +func (e *msgpackEncDriverBytes) WriteMapEmpty() { + + e.w.writen1(mpFixMapMin) +} + +func (e *msgpackEncDriverBytes) EncodeString(s string) { + var ct msgpackContainerType + if e.h.WriteExt { + if e.h.StringToRaw { + ct = msgpackContainerBin + } else { + ct = msgpackContainerStr + } + } else { + ct = msgpackContainerRawLegacy + } + e.writeContainerLen(ct, len(s)) + if len(s) > 0 { + e.w.writestr(s) + } +} + +func (e *msgpackEncDriverBytes) EncodeStringNoEscape4Json(v string) { e.EncodeString(v) } + +func (e *msgpackEncDriverBytes) EncodeStringBytesRaw(bs []byte) { + if e.h.WriteExt { + e.writeContainerLen(msgpackContainerBin, len(bs)) + } else { + e.writeContainerLen(msgpackContainerRawLegacy, len(bs)) + } + if len(bs) > 0 { + e.w.writeb(bs) + } +} + +func (e *msgpackEncDriverBytes) EncodeBytes(v []byte) { + if v == nil { + e.writeNilBytes() + return + } + e.EncodeStringBytesRaw(v) +} + +func (e *msgpackEncDriverBytes) writeNilOr(v byte) { + if !e.h.NilCollectionToZeroLength { + v = mpNil + } + e.w.writen1(v) +} + +func (e *msgpackEncDriverBytes) writeNilArray() { + e.writeNilOr(mpFixArrayMin) +} + +func (e *msgpackEncDriverBytes) writeNilMap() { + e.writeNilOr(mpFixMapMin) +} + +func (e *msgpackEncDriverBytes) writeNilBytes() { + e.writeNilOr(mpFixStrMin) +} + +func (e *msgpackEncDriverBytes) writeContainerLen(ct msgpackContainerType, l int) { + if ct.fixCutoff > 0 && l < int(ct.fixCutoff) { + e.w.writen1(ct.bFixMin | byte(l)) + } else if ct.b8 > 0 && l < 256 { + e.w.writen2(ct.b8, uint8(l)) + } else if l < 65536 { + e.w.writen1(ct.b16) + e.w.writen2(bigen.PutUint16(uint16(l))) + } else { + e.w.writen1(ct.b32) + e.w.writen4(bigen.PutUint32(uint32(l))) + } +} + +func (d *msgpackDecDriverBytes) DecodeNaked() { + if !d.bdRead { + d.readNextBd() + } + bd := d.bd + n := d.d.naked() + var decodeFurther bool + + switch bd { + case mpNil: + n.v = valueTypeNil + d.bdRead = false + case mpFalse: + n.v = valueTypeBool + n.b = false + case mpTrue: + n.v = valueTypeBool + n.b = true + + case mpFloat: + n.v = valueTypeFloat + n.f = float64(math.Float32frombits(bigen.Uint32(d.r.readn4()))) + case mpDouble: + n.v = valueTypeFloat + n.f = math.Float64frombits(bigen.Uint64(d.r.readn8())) + + case mpUint8: + n.v = valueTypeUint + n.u = uint64(d.r.readn1()) + case mpUint16: + n.v = valueTypeUint + n.u = uint64(bigen.Uint16(d.r.readn2())) + case mpUint32: + n.v = valueTypeUint + n.u = uint64(bigen.Uint32(d.r.readn4())) + case mpUint64: + n.v = valueTypeUint + n.u = uint64(bigen.Uint64(d.r.readn8())) + + case mpInt8: + n.v = valueTypeInt + n.i = int64(int8(d.r.readn1())) + case mpInt16: + n.v = valueTypeInt + n.i = int64(int16(bigen.Uint16(d.r.readn2()))) + case mpInt32: + n.v = valueTypeInt + n.i = int64(int32(bigen.Uint32(d.r.readn4()))) + case mpInt64: + n.v = valueTypeInt + n.i = int64(int64(bigen.Uint64(d.r.readn8()))) + + default: + switch { + case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax: + + n.v = valueTypeInt + n.i = int64(int8(bd)) + case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax: + + n.v = valueTypeInt + n.i = int64(int8(bd)) + case bd == mpStr8, bd == mpStr16, bd == mpStr32, bd >= mpFixStrMin && bd <= mpFixStrMax: + d.d.fauxUnionReadRawBytes(d, d.h.WriteExt, d.h.RawToString) + + case bd == mpBin8, bd == mpBin16, bd == mpBin32: + d.d.fauxUnionReadRawBytes(d, false, d.h.RawToString) + case bd == mpArray16, bd == mpArray32, bd >= mpFixArrayMin && bd <= mpFixArrayMax: + n.v = valueTypeArray + decodeFurther = true + case bd == mpMap16, bd == mpMap32, bd >= mpFixMapMin && bd <= mpFixMapMax: + n.v = valueTypeMap + decodeFurther = true + case bd >= mpFixExt1 && bd <= mpFixExt16, bd >= mpExt8 && bd <= mpExt32: + n.v = valueTypeExt + clen := d.readExtLen() + n.u = uint64(d.r.readn1()) + if n.u == uint64(mpTimeExtTagU) { + n.v = valueTypeTime + n.t = d.decodeTime(clen) + } else { + n.l = d.r.readx(uint(clen)) + } + default: + halt.errorf("cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd)) + } + } + if !decodeFurther { + d.bdRead = false + } + if n.v == valueTypeUint && d.h.SignedInteger { + n.v = valueTypeInt + n.i = int64(n.u) + } +} + +func (d *msgpackDecDriverBytes) nextValueBytes() (v []byte) { + if !d.bdRead { + d.readNextBd() + } + d.r.startRecording() + d.nextValueBytesBdReadR() + v = d.r.stopRecording() + d.bdRead = false + return +} + +func (d *msgpackDecDriverBytes) nextValueBytesBdReadR() { + bd := d.bd + + var clen uint + + switch bd { + case mpNil, mpFalse, mpTrue: + case mpUint8, mpInt8: + d.r.readn1() + case mpUint16, mpInt16: + d.r.skip(2) + case mpFloat, mpUint32, mpInt32: + d.r.skip(4) + case mpDouble, mpUint64, mpInt64: + d.r.skip(8) + case mpStr8, mpBin8: + clen = uint(d.r.readn1()) + d.r.skip(clen) + case mpStr16, mpBin16: + x := d.r.readn2() + clen = uint(bigen.Uint16(x)) + d.r.skip(clen) + case mpStr32, mpBin32: + x := d.r.readn4() + clen = uint(bigen.Uint32(x)) + d.r.skip(clen) + case mpFixExt1: + d.r.readn1() + d.r.readn1() + case mpFixExt2: + d.r.readn1() + d.r.skip(2) + case mpFixExt4: + d.r.readn1() + d.r.skip(4) + case mpFixExt8: + d.r.readn1() + d.r.skip(8) + case mpFixExt16: + d.r.readn1() + d.r.skip(16) + case mpExt8: + clen = uint(d.r.readn1()) + d.r.readn1() + d.r.skip(clen) + case mpExt16: + x := d.r.readn2() + clen = uint(bigen.Uint16(x)) + d.r.readn1() + d.r.skip(clen) + case mpExt32: + x := d.r.readn4() + clen = uint(bigen.Uint32(x)) + d.r.readn1() + d.r.skip(clen) + case mpArray16: + x := d.r.readn2() + clen = uint(bigen.Uint16(x)) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + } + case mpArray32: + x := d.r.readn4() + clen = uint(bigen.Uint32(x)) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + } + case mpMap16: + x := d.r.readn2() + clen = uint(bigen.Uint16(x)) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + d.readNextBd() + d.nextValueBytesBdReadR() + } + case mpMap32: + x := d.r.readn4() + clen = uint(bigen.Uint32(x)) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + d.readNextBd() + d.nextValueBytesBdReadR() + } + default: + switch { + case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax: + case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax: + case bd >= mpFixStrMin && bd <= mpFixStrMax: + clen = uint(mpFixStrMin ^ bd) + d.r.skip(clen) + case bd >= mpFixArrayMin && bd <= mpFixArrayMax: + clen = uint(mpFixArrayMin ^ bd) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + } + case bd >= mpFixMapMin && bd <= mpFixMapMax: + clen = uint(mpFixMapMin ^ bd) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + d.readNextBd() + d.nextValueBytesBdReadR() + } + default: + halt.errorf("nextValueBytes: cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd)) + } + } + return +} + +func (d *msgpackDecDriverBytes) decFloat4Int32() (f float32) { + fbits := bigen.Uint32(d.r.readn4()) + f = math.Float32frombits(fbits) + if !noFrac32(fbits) { + halt.errorf("assigning integer value from float32 with a fraction: %v", f) + } + return +} + +func (d *msgpackDecDriverBytes) decFloat4Int64() (f float64) { + fbits := bigen.Uint64(d.r.readn8()) + f = math.Float64frombits(fbits) + if !noFrac64(fbits) { + halt.errorf("assigning integer value from float64 with a fraction: %v", f) + } + return +} + +func (d *msgpackDecDriverBytes) DecodeInt64() (i int64) { + if d.advanceNil() { + return + } + switch d.bd { + case mpUint8: + i = int64(uint64(d.r.readn1())) + case mpUint16: + i = int64(uint64(bigen.Uint16(d.r.readn2()))) + case mpUint32: + i = int64(uint64(bigen.Uint32(d.r.readn4()))) + case mpUint64: + i = int64(bigen.Uint64(d.r.readn8())) + case mpInt8: + i = int64(int8(d.r.readn1())) + case mpInt16: + i = int64(int16(bigen.Uint16(d.r.readn2()))) + case mpInt32: + i = int64(int32(bigen.Uint32(d.r.readn4()))) + case mpInt64: + i = int64(bigen.Uint64(d.r.readn8())) + case mpFloat: + i = int64(d.decFloat4Int32()) + case mpDouble: + i = int64(d.decFloat4Int64()) + default: + switch { + case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax: + i = int64(int8(d.bd)) + case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax: + i = int64(int8(d.bd)) + default: + halt.errorf("cannot decode signed integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd)) + } + } + d.bdRead = false + return +} + +func (d *msgpackDecDriverBytes) DecodeUint64() (ui uint64) { + if d.advanceNil() { + return + } + switch d.bd { + case mpUint8: + ui = uint64(d.r.readn1()) + case mpUint16: + ui = uint64(bigen.Uint16(d.r.readn2())) + case mpUint32: + ui = uint64(bigen.Uint32(d.r.readn4())) + case mpUint64: + ui = bigen.Uint64(d.r.readn8()) + case mpInt8: + if i := int64(int8(d.r.readn1())); i >= 0 { + ui = uint64(i) + } else { + halt.errorf("assigning negative signed value: %v, to unsigned type", i) + } + case mpInt16: + if i := int64(int16(bigen.Uint16(d.r.readn2()))); i >= 0 { + ui = uint64(i) + } else { + halt.errorf("assigning negative signed value: %v, to unsigned type", i) + } + case mpInt32: + if i := int64(int32(bigen.Uint32(d.r.readn4()))); i >= 0 { + ui = uint64(i) + } else { + halt.errorf("assigning negative signed value: %v, to unsigned type", i) + } + case mpInt64: + if i := int64(bigen.Uint64(d.r.readn8())); i >= 0 { + ui = uint64(i) + } else { + halt.errorf("assigning negative signed value: %v, to unsigned type", i) + } + case mpFloat: + if f := d.decFloat4Int32(); f >= 0 { + ui = uint64(f) + } else { + halt.errorf("assigning negative float value: %v, to unsigned type", f) + } + case mpDouble: + if f := d.decFloat4Int64(); f >= 0 { + ui = uint64(f) + } else { + halt.errorf("assigning negative float value: %v, to unsigned type", f) + } + default: + switch { + case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax: + ui = uint64(d.bd) + case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax: + halt.errorf("assigning negative signed value: %v, to unsigned type", int(d.bd)) + default: + halt.errorf("cannot decode unsigned integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd)) + } + } + d.bdRead = false + return +} + +func (d *msgpackDecDriverBytes) DecodeFloat64() (f float64) { + if d.advanceNil() { + return + } + if d.bd == mpFloat { + f = float64(math.Float32frombits(bigen.Uint32(d.r.readn4()))) + } else if d.bd == mpDouble { + f = math.Float64frombits(bigen.Uint64(d.r.readn8())) + } else { + f = float64(d.DecodeInt64()) + } + d.bdRead = false + return +} + +func (d *msgpackDecDriverBytes) DecodeBool() (b bool) { + if d.advanceNil() { + return + } + if d.bd == mpFalse || d.bd == 0 { + + } else if d.bd == mpTrue || d.bd == 1 { + b = true + } else { + halt.errorf("cannot decode bool: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd)) + } + d.bdRead = false + return +} + +func (d *msgpackDecDriverBytes) DecodeBytes() (bs []byte, state dBytesAttachState) { + if d.advanceNil() { + return + } + + var cond bool + bd := d.bd + var clen int + if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 { + clen = d.readContainerLen(msgpackContainerBin) + } else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || + (bd >= mpFixStrMin && bd <= mpFixStrMax) { + clen = d.readContainerLen(msgpackContainerStr) + } else if bd == mpArray16 || bd == mpArray32 || + (bd >= mpFixArrayMin && bd <= mpFixArrayMax) { + slen := d.ReadArrayStart() + bs, cond = usableByteSlice(d.d.buf, slen) + for i := 0; i < len(bs); i++ { + bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8)) + } + for i := len(bs); i < slen; i++ { + bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8))) + } + if cond { + d.d.buf = bs + } + state = dBytesAttachBuffer + return + } else { + halt.errorf("invalid byte descriptor for decoding bytes, got: 0x%x", d.bd) + } + + d.bdRead = false + bs, cond = d.r.readxb(uint(clen)) + state = d.d.attachState(cond) + return +} + +func (d *msgpackDecDriverBytes) DecodeStringAsBytes() (out []byte, state dBytesAttachState) { + out, state = d.DecodeBytes() + if d.h.ValidateUnicode && !utf8.Valid(out) { + halt.errorf("DecodeStringAsBytes: invalid UTF-8: %s", out) + } + return +} + +func (d *msgpackDecDriverBytes) readNextBd() { + d.bd = d.r.readn1() + d.bdRead = true +} + +func (d *msgpackDecDriverBytes) advanceNil() (null bool) { + if !d.bdRead { + d.readNextBd() + } + if d.bd == mpNil { + d.bdRead = false + return true + } + return +} + +func (d *msgpackDecDriverBytes) TryNil() (v bool) { + return d.advanceNil() +} + +func (d *msgpackDecDriverBytes) ContainerType() (vt valueType) { + if !d.bdRead { + d.readNextBd() + } + bd := d.bd + if bd == mpNil { + d.bdRead = false + return valueTypeNil + } else if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 { + return valueTypeBytes + } else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || + (bd >= mpFixStrMin && bd <= mpFixStrMax) { + if d.h.WriteExt || d.h.RawToString { + return valueTypeString + } + return valueTypeBytes + } else if bd == mpArray16 || bd == mpArray32 || (bd >= mpFixArrayMin && bd <= mpFixArrayMax) { + return valueTypeArray + } else if bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) { + return valueTypeMap + } + return valueTypeUnset +} + +func (d *msgpackDecDriverBytes) readContainerLen(ct msgpackContainerType) (clen int) { + bd := d.bd + if bd == ct.b8 { + clen = int(d.r.readn1()) + } else if bd == ct.b16 { + clen = int(bigen.Uint16(d.r.readn2())) + } else if bd == ct.b32 { + clen = int(bigen.Uint32(d.r.readn4())) + } else if (ct.bFixMin & bd) == ct.bFixMin { + clen = int(ct.bFixMin ^ bd) + } else { + halt.errorf("cannot read container length: %s: hex: %x, decimal: %d", msgBadDesc, bd, bd) + } + d.bdRead = false + return +} + +func (d *msgpackDecDriverBytes) ReadMapStart() int { + if d.advanceNil() { + return containerLenNil + } + return d.readContainerLen(msgpackContainerMap) +} + +func (d *msgpackDecDriverBytes) ReadArrayStart() int { + if d.advanceNil() { + return containerLenNil + } + return d.readContainerLen(msgpackContainerList) +} + +func (d *msgpackDecDriverBytes) readExtLen() (clen int) { + switch d.bd { + case mpFixExt1: + clen = 1 + case mpFixExt2: + clen = 2 + case mpFixExt4: + clen = 4 + case mpFixExt8: + clen = 8 + case mpFixExt16: + clen = 16 + case mpExt8: + clen = int(d.r.readn1()) + case mpExt16: + clen = int(bigen.Uint16(d.r.readn2())) + case mpExt32: + clen = int(bigen.Uint32(d.r.readn4())) + default: + halt.errorf("decoding ext bytes: found unexpected byte: %x", d.bd) + } + return +} + +func (d *msgpackDecDriverBytes) DecodeTime() (t time.Time) { + + if d.advanceNil() { + return + } + bd := d.bd + var clen int + if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 { + clen = d.readContainerLen(msgpackContainerBin) + } else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || + (bd >= mpFixStrMin && bd <= mpFixStrMax) { + clen = d.readContainerLen(msgpackContainerStr) + } else { + + d.bdRead = false + b2 := d.r.readn1() + if d.bd == mpFixExt4 && b2 == mpTimeExtTagU { + clen = 4 + } else if d.bd == mpFixExt8 && b2 == mpTimeExtTagU { + clen = 8 + } else if d.bd == mpExt8 && b2 == 12 && d.r.readn1() == mpTimeExtTagU { + clen = 12 + } else { + halt.errorf("invalid stream for decoding time as extension: got 0x%x, 0x%x", d.bd, b2) + } + } + return d.decodeTime(clen) +} + +func (d *msgpackDecDriverBytes) decodeTime(clen int) (t time.Time) { + d.bdRead = false + switch clen { + case 4: + t = time.Unix(int64(bigen.Uint32(d.r.readn4())), 0).UTC() + case 8: + tv := bigen.Uint64(d.r.readn8()) + t = time.Unix(int64(tv&0x00000003ffffffff), int64(tv>>34)).UTC() + case 12: + nsec := bigen.Uint32(d.r.readn4()) + sec := bigen.Uint64(d.r.readn8()) + t = time.Unix(int64(sec), int64(nsec)).UTC() + default: + halt.errorf("invalid length of bytes for decoding time - expecting 4 or 8 or 12, got %d", clen) + } + return +} + +func (d *msgpackDecDriverBytes) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) { + xbs, _, _, ok := d.decodeExtV(ext != nil, xtag) + if !ok { + return + } + if ext == SelfExt { + sideDecode(d.h, &d.h.sideDecPool, func(sd decoderI) { oneOffDecode(sd, rv, xbs, basetype, true) }) + } else { + ext.ReadExt(rv, xbs) + } +} + +func (d *msgpackDecDriverBytes) DecodeRawExt(re *RawExt) { + xbs, realxtag, state, ok := d.decodeExtV(false, 0) + if !ok { + return + } + re.Tag = uint64(realxtag) + re.setData(xbs, state >= dBytesAttachViewZerocopy) +} + +func (d *msgpackDecDriverBytes) decodeExtV(verifyTag bool, xtagIn uint64) (xbs []byte, xtag byte, bstate dBytesAttachState, ok bool) { + if xtagIn > 0xff { + halt.errorf("ext: tag must be <= 0xff; got: %v", xtagIn) + } + if d.advanceNil() { + return + } + tag := uint8(xtagIn) + xbd := d.bd + if xbd == mpBin8 || xbd == mpBin16 || xbd == mpBin32 { + xbs, bstate = d.DecodeBytes() + } else if xbd == mpStr8 || xbd == mpStr16 || xbd == mpStr32 || + (xbd >= mpFixStrMin && xbd <= mpFixStrMax) { + xbs, bstate = d.DecodeStringAsBytes() + } else { + clen := d.readExtLen() + xtag = d.r.readn1() + if verifyTag && xtag != tag { + halt.errorf("wrong extension tag - got %b, expecting %v", xtag, tag) + } + xbs, ok = d.r.readxb(uint(clen)) + bstate = d.d.attachState(ok) + + } + d.bdRead = false + ok = true + return +} + +func (d *msgpackEncDriverBytes) init(hh Handle, shared *encoderBase, enc encoderI) (fp interface{}) { + callMake(&d.w) + d.h = hh.(*MsgpackHandle) + d.e = shared + if shared.bytes { + fp = msgpackFpEncBytes + } else { + fp = msgpackFpEncIO + } + + d.init2(enc) + return +} + +func (e *msgpackEncDriverBytes) writeBytesAsis(b []byte) { e.w.writeb(b) } + +func (e *msgpackEncDriverBytes) writerEnd() { e.w.end() } + +func (e *msgpackEncDriverBytes) resetOutBytes(out *[]byte) { + e.w.resetBytes(*out, out) +} + +func (e *msgpackEncDriverBytes) resetOutIO(out io.Writer) { + e.w.resetIO(out, e.h.WriterBufferSize, &e.e.blist) +} + +func (d *msgpackDecDriverBytes) init(hh Handle, shared *decoderBase, dec decoderI) (fp interface{}) { + callMake(&d.r) + d.h = hh.(*MsgpackHandle) + d.d = shared + if shared.bytes { + fp = msgpackFpDecBytes + } else { + fp = msgpackFpDecIO + } + + d.init2(dec) + return +} + +func (d *msgpackDecDriverBytes) NumBytesRead() int { + return int(d.r.numread()) +} + +func (d *msgpackDecDriverBytes) resetInBytes(in []byte) { + d.r.resetBytes(in) +} + +func (d *msgpackDecDriverBytes) resetInIO(r io.Reader) { + d.r.resetIO(r, d.h.ReaderBufferSize, d.h.MaxInitLen, &d.d.blist) +} + +func (d *msgpackDecDriverBytes) descBd() string { + return sprintf("%v (%s)", d.bd, mpdesc(d.bd)) +} + +func (d *msgpackDecDriverBytes) DecodeFloat32() (f float32) { + return float32(chkOvf.Float32V(d.DecodeFloat64())) +} + +type helperEncDriverMsgpackIO struct{} +type encFnMsgpackIO struct { + i encFnInfo + fe func(*encoderMsgpackIO, *encFnInfo, reflect.Value) +} +type encRtidFnMsgpackIO struct { + rtid uintptr + fn *encFnMsgpackIO +} +type encoderMsgpackIO struct { + dh helperEncDriverMsgpackIO + fp *fastpathEsMsgpackIO + e msgpackEncDriverIO + encoderBase +} +type helperDecDriverMsgpackIO struct{} +type decFnMsgpackIO struct { + i decFnInfo + fd func(*decoderMsgpackIO, *decFnInfo, reflect.Value) +} +type decRtidFnMsgpackIO struct { + rtid uintptr + fn *decFnMsgpackIO +} +type decoderMsgpackIO struct { + dh helperDecDriverMsgpackIO + fp *fastpathDsMsgpackIO + d msgpackDecDriverIO + decoderBase +} +type msgpackEncDriverIO struct { + noBuiltInTypes + encDriverNoopContainerWriter + encDriverNoState + encDriverContainerNoTrackerT + encInit2er + + h *MsgpackHandle + e *encoderBase + w bufioEncWriter +} +type msgpackDecDriverIO struct { + decDriverNoopContainerReader + decDriverNoopNumberHelper + decInit2er + + h *MsgpackHandle + d *decoderBase + r ioDecReader + + bdAndBdread + + noBuiltInTypes +} + +func (e *encoderMsgpackIO) rawExt(_ *encFnInfo, rv reflect.Value) { + if re := rv2i(rv).(*RawExt); re == nil { + e.e.EncodeNil() + } else { + e.e.EncodeRawExt(re) + } +} + +func (e *encoderMsgpackIO) ext(f *encFnInfo, rv reflect.Value) { + e.e.EncodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn) +} + +func (e *encoderMsgpackIO) selferMarshal(_ *encFnInfo, rv reflect.Value) { + rv2i(rv).(Selfer).CodecEncodeSelf(&Encoder{e}) +} + +func (e *encoderMsgpackIO) binaryMarshal(_ *encFnInfo, rv reflect.Value) { + bs, fnerr := rv2i(rv).(encoding.BinaryMarshaler).MarshalBinary() + e.marshalRaw(bs, fnerr) +} + +func (e *encoderMsgpackIO) textMarshal(_ *encFnInfo, rv reflect.Value) { + bs, fnerr := rv2i(rv).(encoding.TextMarshaler).MarshalText() + e.marshalUtf8(bs, fnerr) +} + +func (e *encoderMsgpackIO) jsonMarshal(_ *encFnInfo, rv reflect.Value) { + bs, fnerr := rv2i(rv).(jsonMarshaler).MarshalJSON() + e.marshalAsis(bs, fnerr) +} + +func (e *encoderMsgpackIO) raw(_ *encFnInfo, rv reflect.Value) { + e.rawBytes(rv2i(rv).(Raw)) +} + +func (e *encoderMsgpackIO) encodeComplex64(v complex64) { + if imag(v) != 0 { + halt.errorf("cannot encode complex number: %v, with imaginary values: %v", any(v), any(imag(v))) + } + e.e.EncodeFloat32(real(v)) +} + +func (e *encoderMsgpackIO) encodeComplex128(v complex128) { + if imag(v) != 0 { + halt.errorf("cannot encode complex number: %v, with imaginary values: %v", any(v), any(imag(v))) + } + e.e.EncodeFloat64(real(v)) +} + +func (e *encoderMsgpackIO) kBool(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeBool(rvGetBool(rv)) +} + +func (e *encoderMsgpackIO) kTime(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeTime(rvGetTime(rv)) +} + +func (e *encoderMsgpackIO) kString(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeString(rvGetString(rv)) +} + +func (e *encoderMsgpackIO) kFloat32(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeFloat32(rvGetFloat32(rv)) +} + +func (e *encoderMsgpackIO) kFloat64(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeFloat64(rvGetFloat64(rv)) +} + +func (e *encoderMsgpackIO) kComplex64(_ *encFnInfo, rv reflect.Value) { + e.encodeComplex64(rvGetComplex64(rv)) +} + +func (e *encoderMsgpackIO) kComplex128(_ *encFnInfo, rv reflect.Value) { + e.encodeComplex128(rvGetComplex128(rv)) +} + +func (e *encoderMsgpackIO) kInt(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeInt(int64(rvGetInt(rv))) +} + +func (e *encoderMsgpackIO) kInt8(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeInt(int64(rvGetInt8(rv))) +} + +func (e *encoderMsgpackIO) kInt16(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeInt(int64(rvGetInt16(rv))) +} + +func (e *encoderMsgpackIO) kInt32(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeInt(int64(rvGetInt32(rv))) +} + +func (e *encoderMsgpackIO) kInt64(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeInt(int64(rvGetInt64(rv))) +} + +func (e *encoderMsgpackIO) kUint(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUint(rv))) +} + +func (e *encoderMsgpackIO) kUint8(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUint8(rv))) +} + +func (e *encoderMsgpackIO) kUint16(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUint16(rv))) +} + +func (e *encoderMsgpackIO) kUint32(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUint32(rv))) +} + +func (e *encoderMsgpackIO) kUint64(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUint64(rv))) +} + +func (e *encoderMsgpackIO) kUintptr(_ *encFnInfo, rv reflect.Value) { + e.e.EncodeUint(uint64(rvGetUintptr(rv))) +} + +func (e *encoderMsgpackIO) kSeqFn(rt reflect.Type) (fn *encFnMsgpackIO) { + + if rt = baseRT(rt); rt.Kind() != reflect.Interface { + fn = e.fn(rt) + } + return +} + +func (e *encoderMsgpackIO) kArrayWMbs(rv reflect.Value, ti *typeInfo, isSlice bool) { + var l int + if isSlice { + l = rvLenSlice(rv) + } else { + l = rv.Len() + } + if l == 0 { + e.e.WriteMapEmpty() + return + } + e.haltOnMbsOddLen(l) + e.mapStart(l >> 1) + + var fn *encFnMsgpackIO + builtin := ti.tielem.flagEncBuiltin + if !builtin { + fn = e.kSeqFn(ti.elem) + } + + j := 0 + e.c = containerMapKey + e.e.WriteMapElemKey(true) + for { + rvv := rvArrayIndex(rv, j, ti, isSlice) + if builtin { + e.encodeIB(rv2i(baseRVRV(rvv))) + } else { + e.encodeValue(rvv, fn) + } + j++ + if j == l { + break + } + if j&1 == 0 { + e.c = containerMapKey + e.e.WriteMapElemKey(false) + } else { + e.mapElemValue() + } + } + e.c = 0 + e.e.WriteMapEnd() + +} + +func (e *encoderMsgpackIO) kArrayW(rv reflect.Value, ti *typeInfo, isSlice bool) { + var l int + if isSlice { + l = rvLenSlice(rv) + } else { + l = rv.Len() + } + if l <= 0 { + e.e.WriteArrayEmpty() + return + } + e.arrayStart(l) + + var fn *encFnMsgpackIO + if !ti.tielem.flagEncBuiltin { + fn = e.kSeqFn(ti.elem) + } + + j := 0 + e.c = containerArrayElem + e.e.WriteArrayElem(true) + builtin := ti.tielem.flagEncBuiltin + for { + rvv := rvArrayIndex(rv, j, ti, isSlice) + if builtin { + e.encodeIB(rv2i(baseRVRV(rvv))) + } else { + e.encodeValue(rvv, fn) + } + j++ + if j == l { + break + } + e.c = containerArrayElem + e.e.WriteArrayElem(false) + } + + e.c = 0 + e.e.WriteArrayEnd() +} + +func (e *encoderMsgpackIO) kChan(f *encFnInfo, rv reflect.Value) { + if f.ti.chandir&uint8(reflect.RecvDir) == 0 { + halt.errorStr("send-only channel cannot be encoded") + } + if !f.ti.mbs && uint8TypId == rt2id(f.ti.elem) { + e.kSliceBytesChan(rv) + return + } + rtslice := reflect.SliceOf(f.ti.elem) + rv = chanToSlice(rv, rtslice, e.h.ChanRecvTimeout) + ti := e.h.getTypeInfo(rt2id(rtslice), rtslice) + if f.ti.mbs { + e.kArrayWMbs(rv, ti, true) + } else { + e.kArrayW(rv, ti, true) + } +} + +func (e *encoderMsgpackIO) kSlice(f *encFnInfo, rv reflect.Value) { + if f.ti.mbs { + e.kArrayWMbs(rv, f.ti, true) + } else if f.ti.rtid == uint8SliceTypId || uint8TypId == rt2id(f.ti.elem) { + + e.e.EncodeBytes(rvGetBytes(rv)) + } else { + e.kArrayW(rv, f.ti, true) + } +} + +func (e *encoderMsgpackIO) kArray(f *encFnInfo, rv reflect.Value) { + if f.ti.mbs { + e.kArrayWMbs(rv, f.ti, false) + } else if handleBytesWithinKArray && uint8TypId == rt2id(f.ti.elem) { + e.e.EncodeStringBytesRaw(rvGetArrayBytes(rv, nil)) + } else { + e.kArrayW(rv, f.ti, false) + } +} + +func (e *encoderMsgpackIO) kSliceBytesChan(rv reflect.Value) { + + bs0 := e.blist.peek(32, true) + bs := bs0 + + irv := rv2i(rv) + ch, ok := irv.(<-chan byte) + if !ok { + ch = irv.(chan byte) + } + +L1: + switch timeout := e.h.ChanRecvTimeout; { + case timeout == 0: + for { + select { + case b := <-ch: + bs = append(bs, b) + default: + break L1 + } + } + case timeout > 0: + tt := time.NewTimer(timeout) + for { + select { + case b := <-ch: + bs = append(bs, b) + case <-tt.C: + + break L1 + } + } + default: + for b := range ch { + bs = append(bs, b) + } + } + + e.e.EncodeBytes(bs) + e.blist.put(bs) + if !byteSliceSameData(bs0, bs) { + e.blist.put(bs0) + } +} + +func (e *encoderMsgpackIO) kStructFieldKey(keyType valueType, encName string) { + + if keyType == valueTypeString { + e.e.EncodeString(encName) + } else if keyType == valueTypeInt { + e.e.EncodeInt(must.Int(strconv.ParseInt(encName, 10, 64))) + } else if keyType == valueTypeUint { + e.e.EncodeUint(must.Uint(strconv.ParseUint(encName, 10, 64))) + } else if keyType == valueTypeFloat { + e.e.EncodeFloat64(must.Float(strconv.ParseFloat(encName, 64))) + } else { + halt.errorStr2("invalid struct key type: ", keyType.String()) + } + +} + +func (e *encoderMsgpackIO) kStructSimple(f *encFnInfo, rv reflect.Value) { + _ = e.e + tisfi := f.ti.sfi.source() + + chkCirRef := e.h.CheckCircularRef + var si *structFieldInfo + var j int + + if f.ti.toArray || e.h.StructToArray { + if len(tisfi) == 0 { + e.e.WriteArrayEmpty() + return + } + e.arrayStart(len(tisfi)) + for j, si = range tisfi { + e.c = containerArrayElem + e.e.WriteArrayElem(j == 0) + if si.encBuiltin { + e.encodeIB(rv2i(si.fieldNoAlloc(rv, true))) + } else { + e.encodeValue(si.fieldNoAlloc(rv, !chkCirRef), nil) + } + } + e.c = 0 + e.e.WriteArrayEnd() + } else { + if len(tisfi) == 0 { + e.e.WriteMapEmpty() + return + } + if e.h.Canonical { + tisfi = f.ti.sfi.sorted() + } + e.mapStart(len(tisfi)) + for j, si = range tisfi { + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + e.e.EncodeStringNoEscape4Json(si.encName) + e.mapElemValue() + if si.encBuiltin { + e.encodeIB(rv2i(si.fieldNoAlloc(rv, true))) + } else { + e.encodeValue(si.fieldNoAlloc(rv, !chkCirRef), nil) + } + } + e.c = 0 + e.e.WriteMapEnd() + } +} + +func (e *encoderMsgpackIO) kStruct(f *encFnInfo, rv reflect.Value) { + _ = e.e + ti := f.ti + toMap := !(ti.toArray || e.h.StructToArray) + var mf map[string]interface{} + if ti.flagMissingFielder { + toMap = true + mf = rv2i(rv).(MissingFielder).CodecMissingFields() + } else if ti.flagMissingFielderPtr { + toMap = true + if rv.CanAddr() { + mf = rv2i(rvAddr(rv, ti.ptr)).(MissingFielder).CodecMissingFields() + } else { + mf = rv2i(e.addrRV(rv, ti.rt, ti.ptr)).(MissingFielder).CodecMissingFields() + } + } + newlen := len(mf) + tisfi := ti.sfi.source() + newlen += len(tisfi) + + var fkvs = e.slist.get(newlen)[:newlen] + + recur := e.h.RecursiveEmptyCheck + chkCirRef := e.h.CheckCircularRef + + var xlen int + + var kv sfiRv + var j int + var sf encStructFieldObj + if toMap { + newlen = 0 + if e.h.Canonical { + tisfi = f.ti.sfi.sorted() + } + for _, si := range tisfi { + + if si.omitEmpty { + kv.r = si.fieldNoAlloc(rv, false) + if isEmptyValue(kv.r, e.h.TypeInfos, recur) { + continue + } + } else { + kv.r = si.fieldNoAlloc(rv, si.encBuiltin || !chkCirRef) + } + kv.v = si + fkvs[newlen] = kv + newlen++ + } + + var mf2s []stringIntf + if len(mf) != 0 { + mf2s = make([]stringIntf, 0, len(mf)) + for k, v := range mf { + if k == "" { + continue + } + if ti.infoFieldOmitempty && isEmptyValue(reflect.ValueOf(v), e.h.TypeInfos, recur) { + continue + } + mf2s = append(mf2s, stringIntf{k, v}) + } + } + + xlen = newlen + len(mf2s) + if xlen == 0 { + e.e.WriteMapEmpty() + goto END + } + + e.mapStart(xlen) + + if len(mf2s) != 0 && e.h.Canonical { + mf2w := make([]encStructFieldObj, newlen+len(mf2s)) + for j = 0; j < newlen; j++ { + kv = fkvs[j] + mf2w[j] = encStructFieldObj{kv.v.encName, kv.r, nil, true, + !kv.v.encNameEscape4Json, kv.v.encBuiltin} + } + for _, v := range mf2s { + mf2w[j] = encStructFieldObj{v.v, reflect.Value{}, v.i, false, false, false} + j++ + } + sort.Sort((encStructFieldObjSlice)(mf2w)) + for j, sf = range mf2w { + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + if ti.keyType == valueTypeString && sf.noEsc4json { + e.e.EncodeStringNoEscape4Json(sf.key) + } else { + e.kStructFieldKey(ti.keyType, sf.key) + } + e.mapElemValue() + if sf.isRv { + if sf.builtin { + e.encodeIB(rv2i(baseRVRV(sf.rv))) + } else { + e.encodeValue(sf.rv, nil) + } + } else { + if !e.encodeBuiltin(sf.intf) { + e.encodeR(reflect.ValueOf(sf.intf)) + } + + } + } + } else { + keytyp := ti.keyType + for j = 0; j < newlen; j++ { + kv = fkvs[j] + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + if ti.keyType == valueTypeString && !kv.v.encNameEscape4Json { + e.e.EncodeStringNoEscape4Json(kv.v.encName) + } else { + e.kStructFieldKey(keytyp, kv.v.encName) + } + e.mapElemValue() + if kv.v.encBuiltin { + e.encodeIB(rv2i(baseRVRV(kv.r))) + } else { + e.encodeValue(kv.r, nil) + } + } + for _, v := range mf2s { + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + e.kStructFieldKey(keytyp, v.v) + e.mapElemValue() + if !e.encodeBuiltin(v.i) { + e.encodeR(reflect.ValueOf(v.i)) + } + + j++ + } + } + + e.c = 0 + e.e.WriteMapEnd() + } else { + newlen = len(tisfi) + for i, si := range tisfi { + + if si.omitEmpty { + + kv.r = si.fieldNoAlloc(rv, false) + if isEmptyContainerValue(kv.r, e.h.TypeInfos, recur) { + kv.r = reflect.Value{} + } + } else { + kv.r = si.fieldNoAlloc(rv, si.encBuiltin || !chkCirRef) + } + kv.v = si + fkvs[i] = kv + } + + if newlen == 0 { + e.e.WriteArrayEmpty() + goto END + } + + e.arrayStart(newlen) + for j = 0; j < newlen; j++ { + e.c = containerArrayElem + e.e.WriteArrayElem(j == 0) + kv = fkvs[j] + if !kv.r.IsValid() { + e.e.EncodeNil() + } else if kv.v.encBuiltin { + e.encodeIB(rv2i(baseRVRV(kv.r))) + } else { + e.encodeValue(kv.r, nil) + } + } + e.c = 0 + e.e.WriteArrayEnd() + } + +END: + + e.slist.put(fkvs) +} + +func (e *encoderMsgpackIO) kMap(f *encFnInfo, rv reflect.Value) { + _ = e.e + l := rvLenMap(rv) + if l == 0 { + e.e.WriteMapEmpty() + return + } + e.mapStart(l) + + var keyFn, valFn *encFnMsgpackIO + + ktypeKind := reflect.Kind(f.ti.keykind) + vtypeKind := reflect.Kind(f.ti.elemkind) + + rtval := f.ti.elem + rtvalkind := vtypeKind + for rtvalkind == reflect.Ptr { + rtval = rtval.Elem() + rtvalkind = rtval.Kind() + } + if rtvalkind != reflect.Interface { + valFn = e.fn(rtval) + } + + var rvv = mapAddrLoopvarRV(f.ti.elem, vtypeKind) + + rtkey := f.ti.key + var keyTypeIsString = stringTypId == rt2id(rtkey) + if keyTypeIsString { + keyFn = e.fn(rtkey) + } else { + for rtkey.Kind() == reflect.Ptr { + rtkey = rtkey.Elem() + } + if rtkey.Kind() != reflect.Interface { + keyFn = e.fn(rtkey) + } + } + + if e.h.Canonical { + e.kMapCanonical(f.ti, rv, rvv, keyFn, valFn) + e.c = 0 + e.e.WriteMapEnd() + return + } + + var rvk = mapAddrLoopvarRV(f.ti.key, ktypeKind) + + var it mapIter + mapRange(&it, rv, rvk, rvv, true) + + kbuiltin := f.ti.tikey.flagEncBuiltin + vbuiltin := f.ti.tielem.flagEncBuiltin + for j := 0; it.Next(); j++ { + rv = it.Key() + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + if keyTypeIsString { + e.e.EncodeString(rvGetString(rv)) + } else if kbuiltin { + e.encodeIB(rv2i(baseRVRV(rv))) + } else { + e.encodeValue(rv, keyFn) + } + e.mapElemValue() + rv = it.Value() + if vbuiltin { + e.encodeIB(rv2i(baseRVRV(rv))) + } else { + e.encodeValue(it.Value(), valFn) + } + } + it.Done() + + e.c = 0 + e.e.WriteMapEnd() +} + +func (e *encoderMsgpackIO) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, keyFn, valFn *encFnMsgpackIO) { + _ = e.e + + rtkey := ti.key + rtkeydecl := rtkey.PkgPath() == "" && rtkey.Name() != "" + + mks := rv.MapKeys() + rtkeyKind := rtkey.Kind() + mparams := getMapReqParams(ti) + + switch rtkeyKind { + case reflect.Bool: + + if len(mks) == 2 && mks[0].Bool() { + mks[0], mks[1] = mks[1], mks[0] + } + for i := range mks { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeBool(mks[i].Bool()) + } else { + e.encodeValueNonNil(mks[i], keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mks[i], rvv, mparams), valFn) + } + case reflect.String: + mksv := make([]orderedRv[string], len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = rvGetString(k) + } + slices.SortFunc(mksv, cmpOrderedRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeString(mksv[i].v) + } else { + e.encodeValueNonNil(mksv[i].r, keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr: + mksv := make([]orderedRv[uint64], len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Uint() + } + slices.SortFunc(mksv, cmpOrderedRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeUint(mksv[i].v) + } else { + e.encodeValueNonNil(mksv[i].r, keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + mksv := make([]orderedRv[int64], len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Int() + } + slices.SortFunc(mksv, cmpOrderedRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeInt(mksv[i].v) + } else { + e.encodeValueNonNil(mksv[i].r, keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + case reflect.Float32: + mksv := make([]orderedRv[float64], len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Float() + } + slices.SortFunc(mksv, cmpOrderedRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeFloat32(float32(mksv[i].v)) + } else { + e.encodeValueNonNil(mksv[i].r, keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + case reflect.Float64: + mksv := make([]orderedRv[float64], len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = k.Float() + } + slices.SortFunc(mksv, cmpOrderedRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + if rtkeydecl { + e.e.EncodeFloat64(mksv[i].v) + } else { + e.encodeValueNonNil(mksv[i].r, keyFn) + } + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + default: + if rtkey == timeTyp { + mksv := make([]timeRv, len(mks)) + for i, k := range mks { + v := &mksv[i] + v.r = k + v.v = rv2i(k).(time.Time) + } + slices.SortFunc(mksv, cmpTimeRv) + for i := range mksv { + e.c = containerMapKey + e.e.WriteMapElemKey(i == 0) + e.e.EncodeTime(mksv[i].v) + e.mapElemValue() + e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn) + } + break + } + + bs0 := e.blist.get(len(mks) * 16) + mksv := bs0 + mksbv := make([]bytesRv, len(mks)) + + sideEncode(e.hh, &e.h.sideEncPool, func(se encoderI) { + se.ResetBytes(&mksv) + for i, k := range mks { + v := &mksbv[i] + l := len(mksv) + se.setContainerState(containerMapKey) + se.encodeR(baseRVRV(k)) + se.atEndOfEncode() + se.writerEnd() + v.r = k + v.v = mksv[l:] + } + }) + + slices.SortFunc(mksbv, cmpBytesRv) + for j := range mksbv { + e.c = containerMapKey + e.e.WriteMapElemKey(j == 0) + e.e.writeBytesAsis(mksbv[j].v) + e.mapElemValue() + e.encodeValue(mapGet(rv, mksbv[j].r, rvv, mparams), valFn) + } + e.blist.put(mksv) + if !byteSliceSameData(bs0, mksv) { + e.blist.put(bs0) + } + } +} + +func (e *encoderMsgpackIO) init(h Handle) { + initHandle(h) + callMake(&e.e) + e.hh = h + e.h = h.getBasicHandle() + + e.err = errEncoderNotInitialized + + e.fp = e.e.init(h, &e.encoderBase, e).(*fastpathEsMsgpackIO) + + if e.bytes { + e.rtidFn = &e.h.rtidFnsEncBytes + e.rtidFnNoExt = &e.h.rtidFnsEncNoExtBytes + } else { + e.rtidFn = &e.h.rtidFnsEncIO + e.rtidFnNoExt = &e.h.rtidFnsEncNoExtIO + } + + e.reset() +} + +func (e *encoderMsgpackIO) reset() { + e.e.reset() + if e.ci != nil { + e.ci = e.ci[:0] + } + e.c = 0 + e.calls = 0 + e.seq = 0 + e.err = nil +} + +func (e *encoderMsgpackIO) Encode(v interface{}) (err error) { + + defer panicValToErr(e, callRecoverSentinel, &e.err, &err, debugging) + e.mustEncode(v) + return +} + +func (e *encoderMsgpackIO) MustEncode(v interface{}) { + defer panicValToErr(e, callRecoverSentinel, &e.err, nil, true) + e.mustEncode(v) + return +} + +func (e *encoderMsgpackIO) mustEncode(v interface{}) { + halt.onerror(e.err) + if e.hh == nil { + halt.onerror(errNoFormatHandle) + } + + e.calls++ + if !e.encodeBuiltin(v) { + e.encodeR(reflect.ValueOf(v)) + } + + e.calls-- + if e.calls == 0 { + e.e.atEndOfEncode() + e.e.writerEnd() + } +} + +func (e *encoderMsgpackIO) encodeI(iv interface{}) { + if !e.encodeBuiltin(iv) { + e.encodeR(reflect.ValueOf(iv)) + } +} + +func (e *encoderMsgpackIO) encodeIB(iv interface{}) { + if !e.encodeBuiltin(iv) { + + halt.errorStr("[should not happen] invalid type passed to encodeBuiltin") + } +} + +func (e *encoderMsgpackIO) encodeR(base reflect.Value) { + e.encodeValue(base, nil) +} + +func (e *encoderMsgpackIO) encodeBuiltin(iv interface{}) (ok bool) { + ok = true + switch v := iv.(type) { + case nil: + e.e.EncodeNil() + + case Raw: + e.rawBytes(v) + case string: + e.e.EncodeString(v) + case bool: + e.e.EncodeBool(v) + case int: + e.e.EncodeInt(int64(v)) + case int8: + e.e.EncodeInt(int64(v)) + case int16: + e.e.EncodeInt(int64(v)) + case int32: + e.e.EncodeInt(int64(v)) + case int64: + e.e.EncodeInt(v) + case uint: + e.e.EncodeUint(uint64(v)) + case uint8: + e.e.EncodeUint(uint64(v)) + case uint16: + e.e.EncodeUint(uint64(v)) + case uint32: + e.e.EncodeUint(uint64(v)) + case uint64: + e.e.EncodeUint(v) + case uintptr: + e.e.EncodeUint(uint64(v)) + case float32: + e.e.EncodeFloat32(v) + case float64: + e.e.EncodeFloat64(v) + case complex64: + e.encodeComplex64(v) + case complex128: + e.encodeComplex128(v) + case time.Time: + e.e.EncodeTime(v) + case []byte: + e.e.EncodeBytes(v) + default: + + ok = !skipFastpathTypeSwitchInDirectCall && e.dh.fastpathEncodeTypeSwitch(iv, e) + } + return +} + +func (e *encoderMsgpackIO) encodeValue(rv reflect.Value, fn *encFnMsgpackIO) { + + var ciPushes int + + var rvp reflect.Value + var rvpValid bool + +RV: + switch rv.Kind() { + case reflect.Ptr: + if rvIsNil(rv) { + e.e.EncodeNil() + goto END + } + rvpValid = true + rvp = rv + rv = rv.Elem() + + if e.h.CheckCircularRef && e.ci.canPushElemKind(rv.Kind()) { + e.ci.push(rv2i(rvp)) + ciPushes++ + } + goto RV + case reflect.Interface: + if rvIsNil(rv) { + e.e.EncodeNil() + goto END + } + rvpValid = false + rvp = reflect.Value{} + rv = rv.Elem() + fn = nil + goto RV + case reflect.Map: + if rvIsNil(rv) { + if e.h.NilCollectionToZeroLength { + e.e.WriteMapEmpty() + } else { + e.e.EncodeNil() + } + goto END + } + case reflect.Slice, reflect.Chan: + if rvIsNil(rv) { + if e.h.NilCollectionToZeroLength { + e.e.WriteArrayEmpty() + } else { + e.e.EncodeNil() + } + goto END + } + case reflect.Invalid, reflect.Func: + e.e.EncodeNil() + goto END + } + + if fn == nil { + fn = e.fn(rv.Type()) + } + + if !fn.i.addrE { + + } else if rvpValid { + rv = rvp + } else if rv.CanAddr() { + rv = rvAddr(rv, fn.i.ti.ptr) + } else { + rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr) + } + fn.fe(e, &fn.i, rv) + +END: + if ciPushes > 0 { + e.ci.pop(ciPushes) + } +} + +func (e *encoderMsgpackIO) encodeValueNonNil(rv reflect.Value, fn *encFnMsgpackIO) { + + if fn.i.addrE { + if rv.CanAddr() { + rv = rvAddr(rv, fn.i.ti.ptr) + } else { + rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr) + } + } + fn.fe(e, &fn.i, rv) +} + +func (e *encoderMsgpackIO) encodeAs(v interface{}, t reflect.Type, ext bool) { + if ext { + e.encodeValue(baseRV(v), e.fn(t)) + } else { + e.encodeValue(baseRV(v), e.fnNoExt(t)) + } +} + +func (e *encoderMsgpackIO) marshalUtf8(bs []byte, fnerr error) { + halt.onerror(fnerr) + if bs == nil { + e.e.EncodeNil() + } else { + e.e.EncodeString(stringView(bs)) + } +} + +func (e *encoderMsgpackIO) marshalAsis(bs []byte, fnerr error) { + halt.onerror(fnerr) + if bs == nil { + e.e.EncodeNil() + } else { + e.e.writeBytesAsis(bs) + } +} + +func (e *encoderMsgpackIO) marshalRaw(bs []byte, fnerr error) { + halt.onerror(fnerr) + e.e.EncodeBytes(bs) +} + +func (e *encoderMsgpackIO) rawBytes(vv Raw) { + v := []byte(vv) + if !e.h.Raw { + halt.errorBytes("Raw values cannot be encoded: ", v) + } + e.e.writeBytesAsis(v) +} + +func (e *encoderMsgpackIO) fn(t reflect.Type) *encFnMsgpackIO { + return e.dh.encFnViaBH(t, e.rtidFn, e.h, e.fp, false) +} + +func (e *encoderMsgpackIO) fnNoExt(t reflect.Type) *encFnMsgpackIO { + return e.dh.encFnViaBH(t, e.rtidFnNoExt, e.h, e.fp, true) +} + +func (e *encoderMsgpackIO) mapStart(length int) { + e.e.WriteMapStart(length) + e.c = containerMapStart +} + +func (e *encoderMsgpackIO) mapElemValue() { + e.e.WriteMapElemValue() + e.c = containerMapValue +} + +func (e *encoderMsgpackIO) arrayStart(length int) { + e.e.WriteArrayStart(length) + e.c = containerArrayStart +} + +func (e *encoderMsgpackIO) writerEnd() { + e.e.writerEnd() +} + +func (e *encoderMsgpackIO) atEndOfEncode() { + e.e.atEndOfEncode() +} + +func (e *encoderMsgpackIO) Reset(w io.Writer) { + if e.bytes { + halt.onerror(errEncNoResetBytesWithWriter) + } + e.reset() + if w == nil { + w = io.Discard + } + e.e.resetOutIO(w) +} + +func (e *encoderMsgpackIO) ResetBytes(out *[]byte) { + if !e.bytes { + halt.onerror(errEncNoResetWriterWithBytes) + } + e.resetBytes(out) +} + +func (e *encoderMsgpackIO) resetBytes(out *[]byte) { + e.reset() + if out == nil { + out = &bytesEncAppenderDefOut + } + e.e.resetOutBytes(out) +} + +func (helperEncDriverMsgpackIO) newEncoderBytes(out *[]byte, h Handle) *encoderMsgpackIO { + var c1 encoderMsgpackIO + c1.bytes = true + c1.init(h) + c1.ResetBytes(out) + return &c1 +} + +func (helperEncDriverMsgpackIO) newEncoderIO(out io.Writer, h Handle) *encoderMsgpackIO { + var c1 encoderMsgpackIO + c1.bytes = false + c1.init(h) + c1.Reset(out) + return &c1 +} + +func (helperEncDriverMsgpackIO) encFnloadFastpathUnderlying(ti *typeInfo, fp *fastpathEsMsgpackIO) (f *fastpathEMsgpackIO, u reflect.Type) { + rtid := rt2id(ti.fastpathUnderlying) + idx, ok := fastpathAvIndex(rtid) + if !ok { + return + } + f = &fp[idx] + if uint8(reflect.Array) == ti.kind { + u = reflect.ArrayOf(ti.rt.Len(), ti.elem) + } else { + u = f.rt + } + return +} + +func (helperEncDriverMsgpackIO) encFindRtidFn(s []encRtidFnMsgpackIO, rtid uintptr) (i uint, fn *encFnMsgpackIO) { + + var h uint + var j = uint(len(s)) +LOOP: + if i < j { + h = (i + j) >> 1 + if s[h].rtid < rtid { + i = h + 1 + } else { + j = h + } + goto LOOP + } + if i < uint(len(s)) && s[i].rtid == rtid { + fn = s[i].fn + } + return +} + +func (helperEncDriverMsgpackIO) encFromRtidFnSlice(fns *atomicRtidFnSlice) (s []encRtidFnMsgpackIO) { + if v := fns.load(); v != nil { + s = *(lowLevelToPtr[[]encRtidFnMsgpackIO](v)) + } + return +} + +func (dh helperEncDriverMsgpackIO) encFnViaBH(rt reflect.Type, fns *atomicRtidFnSlice, + x *BasicHandle, fp *fastpathEsMsgpackIO, checkExt bool) (fn *encFnMsgpackIO) { + return dh.encFnVia(rt, fns, x.typeInfos(), &x.mu, x.extHandle, fp, + checkExt, x.CheckCircularRef, x.timeBuiltin, x.binaryHandle, x.jsonHandle) +} + +func (dh helperEncDriverMsgpackIO) encFnVia(rt reflect.Type, fns *atomicRtidFnSlice, + tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathEsMsgpackIO, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackIO) { + rtid := rt2id(rt) + var sp []encRtidFnMsgpackIO = dh.encFromRtidFnSlice(fns) + if sp != nil { + _, fn = dh.encFindRtidFn(sp, rtid) + } + if fn == nil { + fn = dh.encFnViaLoader(rt, rtid, fns, tinfos, mu, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json) + } + return +} + +func (dh helperEncDriverMsgpackIO) encFnViaLoader(rt reflect.Type, rtid uintptr, fns *atomicRtidFnSlice, + tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathEsMsgpackIO, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackIO) { + + fn = dh.encFnLoad(rt, rtid, tinfos, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json) + var sp []encRtidFnMsgpackIO + mu.Lock() + sp = dh.encFromRtidFnSlice(fns) + + if sp == nil { + sp = []encRtidFnMsgpackIO{{rtid, fn}} + fns.store(ptrToLowLevel(&sp)) + } else { + idx, fn2 := dh.encFindRtidFn(sp, rtid) + if fn2 == nil { + sp2 := make([]encRtidFnMsgpackIO, len(sp)+1) + copy(sp2[idx+1:], sp[idx:]) + copy(sp2, sp[:idx]) + sp2[idx] = encRtidFnMsgpackIO{rtid, fn} + fns.store(ptrToLowLevel(&sp2)) + } + } + mu.Unlock() + return +} + +func (dh helperEncDriverMsgpackIO) encFnLoad(rt reflect.Type, rtid uintptr, tinfos *TypeInfos, + exth extHandle, fp *fastpathEsMsgpackIO, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackIO) { + fn = new(encFnMsgpackIO) + fi := &(fn.i) + ti := tinfos.get(rtid, rt) + fi.ti = ti + rk := reflect.Kind(ti.kind) + + if rtid == timeTypId && timeBuiltin { + fn.fe = (*encoderMsgpackIO).kTime + } else if rtid == rawTypId { + fn.fe = (*encoderMsgpackIO).raw + } else if rtid == rawExtTypId { + fn.fe = (*encoderMsgpackIO).rawExt + fi.addrE = true + } else if xfFn := exth.getExt(rtid, checkExt); xfFn != nil { + fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext + fn.fe = (*encoderMsgpackIO).ext + if rk == reflect.Struct || rk == reflect.Array { + fi.addrE = true + } + } else if ti.flagSelfer || ti.flagSelferPtr { + fn.fe = (*encoderMsgpackIO).selferMarshal + fi.addrE = ti.flagSelferPtr + } else if supportMarshalInterfaces && binaryEncoding && + (ti.flagBinaryMarshaler || ti.flagBinaryMarshalerPtr) && + (ti.flagBinaryUnmarshaler || ti.flagBinaryUnmarshalerPtr) { + fn.fe = (*encoderMsgpackIO).binaryMarshal + fi.addrE = ti.flagBinaryMarshalerPtr + } else if supportMarshalInterfaces && !binaryEncoding && json && + (ti.flagJsonMarshaler || ti.flagJsonMarshalerPtr) && + (ti.flagJsonUnmarshaler || ti.flagJsonUnmarshalerPtr) { + + fn.fe = (*encoderMsgpackIO).jsonMarshal + fi.addrE = ti.flagJsonMarshalerPtr + } else if supportMarshalInterfaces && !binaryEncoding && + (ti.flagTextMarshaler || ti.flagTextMarshalerPtr) && + (ti.flagTextUnmarshaler || ti.flagTextUnmarshalerPtr) { + fn.fe = (*encoderMsgpackIO).textMarshal + fi.addrE = ti.flagTextMarshalerPtr + } else { + if fastpathEnabled && (rk == reflect.Map || rk == reflect.Slice || rk == reflect.Array) { + + var rtid2 uintptr + if !ti.flagHasPkgPath { + rtid2 = rtid + if rk == reflect.Array { + rtid2 = rt2id(ti.key) + } + if idx, ok := fastpathAvIndex(rtid2); ok { + fn.fe = fp[idx].encfn + } + } else { + + xfe, xrt := dh.encFnloadFastpathUnderlying(ti, fp) + if xfe != nil { + xfnf := xfe.encfn + fn.fe = func(e *encoderMsgpackIO, xf *encFnInfo, xrv reflect.Value) { + xfnf(e, xf, rvConvert(xrv, xrt)) + } + } + } + } + if fn.fe == nil { + switch rk { + case reflect.Bool: + fn.fe = (*encoderMsgpackIO).kBool + case reflect.String: + + fn.fe = (*encoderMsgpackIO).kString + case reflect.Int: + fn.fe = (*encoderMsgpackIO).kInt + case reflect.Int8: + fn.fe = (*encoderMsgpackIO).kInt8 + case reflect.Int16: + fn.fe = (*encoderMsgpackIO).kInt16 + case reflect.Int32: + fn.fe = (*encoderMsgpackIO).kInt32 + case reflect.Int64: + fn.fe = (*encoderMsgpackIO).kInt64 + case reflect.Uint: + fn.fe = (*encoderMsgpackIO).kUint + case reflect.Uint8: + fn.fe = (*encoderMsgpackIO).kUint8 + case reflect.Uint16: + fn.fe = (*encoderMsgpackIO).kUint16 + case reflect.Uint32: + fn.fe = (*encoderMsgpackIO).kUint32 + case reflect.Uint64: + fn.fe = (*encoderMsgpackIO).kUint64 + case reflect.Uintptr: + fn.fe = (*encoderMsgpackIO).kUintptr + case reflect.Float32: + fn.fe = (*encoderMsgpackIO).kFloat32 + case reflect.Float64: + fn.fe = (*encoderMsgpackIO).kFloat64 + case reflect.Complex64: + fn.fe = (*encoderMsgpackIO).kComplex64 + case reflect.Complex128: + fn.fe = (*encoderMsgpackIO).kComplex128 + case reflect.Chan: + fn.fe = (*encoderMsgpackIO).kChan + case reflect.Slice: + fn.fe = (*encoderMsgpackIO).kSlice + case reflect.Array: + fn.fe = (*encoderMsgpackIO).kArray + case reflect.Struct: + if ti.simple { + fn.fe = (*encoderMsgpackIO).kStructSimple + } else { + fn.fe = (*encoderMsgpackIO).kStruct + } + case reflect.Map: + fn.fe = (*encoderMsgpackIO).kMap + case reflect.Interface: + + fn.fe = (*encoderMsgpackIO).kErr + default: + + fn.fe = (*encoderMsgpackIO).kErr + } + } + } + return +} +func (d *decoderMsgpackIO) rawExt(f *decFnInfo, rv reflect.Value) { + d.d.DecodeRawExt(rv2i(rv).(*RawExt)) +} + +func (d *decoderMsgpackIO) ext(f *decFnInfo, rv reflect.Value) { + d.d.DecodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn) +} + +func (d *decoderMsgpackIO) selferUnmarshal(_ *decFnInfo, rv reflect.Value) { + rv2i(rv).(Selfer).CodecDecodeSelf(&Decoder{d}) +} + +func (d *decoderMsgpackIO) binaryUnmarshal(_ *decFnInfo, rv reflect.Value) { + bm := rv2i(rv).(encoding.BinaryUnmarshaler) + xbs, _ := d.d.DecodeBytes() + fnerr := bm.UnmarshalBinary(xbs) + halt.onerror(fnerr) +} + +func (d *decoderMsgpackIO) textUnmarshal(_ *decFnInfo, rv reflect.Value) { + tm := rv2i(rv).(encoding.TextUnmarshaler) + fnerr := tm.UnmarshalText(bytesOKs(d.d.DecodeStringAsBytes())) + halt.onerror(fnerr) +} + +func (d *decoderMsgpackIO) jsonUnmarshal(_ *decFnInfo, rv reflect.Value) { + d.jsonUnmarshalV(rv2i(rv).(jsonUnmarshaler)) +} + +func (d *decoderMsgpackIO) jsonUnmarshalV(tm jsonUnmarshaler) { + + halt.onerror(tm.UnmarshalJSON(d.d.nextValueBytes())) +} + +func (d *decoderMsgpackIO) kErr(_ *decFnInfo, rv reflect.Value) { + halt.errorf("unsupported decoding kind: %s, for %#v", rv.Kind(), rv) + +} + +func (d *decoderMsgpackIO) raw(_ *decFnInfo, rv reflect.Value) { + rvSetBytes(rv, d.rawBytes()) +} + +func (d *decoderMsgpackIO) kString(_ *decFnInfo, rv reflect.Value) { + rvSetString(rv, d.detach2Str(d.d.DecodeStringAsBytes())) +} + +func (d *decoderMsgpackIO) kBool(_ *decFnInfo, rv reflect.Value) { + rvSetBool(rv, d.d.DecodeBool()) +} + +func (d *decoderMsgpackIO) kTime(_ *decFnInfo, rv reflect.Value) { + rvSetTime(rv, d.d.DecodeTime()) +} + +func (d *decoderMsgpackIO) kFloat32(_ *decFnInfo, rv reflect.Value) { + rvSetFloat32(rv, d.d.DecodeFloat32()) +} + +func (d *decoderMsgpackIO) kFloat64(_ *decFnInfo, rv reflect.Value) { + rvSetFloat64(rv, d.d.DecodeFloat64()) +} + +func (d *decoderMsgpackIO) kComplex64(_ *decFnInfo, rv reflect.Value) { + rvSetComplex64(rv, complex(d.d.DecodeFloat32(), 0)) +} + +func (d *decoderMsgpackIO) kComplex128(_ *decFnInfo, rv reflect.Value) { + rvSetComplex128(rv, complex(d.d.DecodeFloat64(), 0)) +} + +func (d *decoderMsgpackIO) kInt(_ *decFnInfo, rv reflect.Value) { + rvSetInt(rv, int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))) +} + +func (d *decoderMsgpackIO) kInt8(_ *decFnInfo, rv reflect.Value) { + rvSetInt8(rv, int8(chkOvf.IntV(d.d.DecodeInt64(), 8))) +} + +func (d *decoderMsgpackIO) kInt16(_ *decFnInfo, rv reflect.Value) { + rvSetInt16(rv, int16(chkOvf.IntV(d.d.DecodeInt64(), 16))) +} + +func (d *decoderMsgpackIO) kInt32(_ *decFnInfo, rv reflect.Value) { + rvSetInt32(rv, int32(chkOvf.IntV(d.d.DecodeInt64(), 32))) +} + +func (d *decoderMsgpackIO) kInt64(_ *decFnInfo, rv reflect.Value) { + rvSetInt64(rv, d.d.DecodeInt64()) +} + +func (d *decoderMsgpackIO) kUint(_ *decFnInfo, rv reflect.Value) { + rvSetUint(rv, uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))) +} + +func (d *decoderMsgpackIO) kUintptr(_ *decFnInfo, rv reflect.Value) { + rvSetUintptr(rv, uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))) +} + +func (d *decoderMsgpackIO) kUint8(_ *decFnInfo, rv reflect.Value) { + rvSetUint8(rv, uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))) +} + +func (d *decoderMsgpackIO) kUint16(_ *decFnInfo, rv reflect.Value) { + rvSetUint16(rv, uint16(chkOvf.UintV(d.d.DecodeUint64(), 16))) +} + +func (d *decoderMsgpackIO) kUint32(_ *decFnInfo, rv reflect.Value) { + rvSetUint32(rv, uint32(chkOvf.UintV(d.d.DecodeUint64(), 32))) +} + +func (d *decoderMsgpackIO) kUint64(_ *decFnInfo, rv reflect.Value) { + rvSetUint64(rv, d.d.DecodeUint64()) +} + +func (d *decoderMsgpackIO) kInterfaceNaked(f *decFnInfo) (rvn reflect.Value) { + + n := d.naked() + d.d.DecodeNaked() + + if decFailNonEmptyIntf && f.ti.numMeth > 0 { + halt.errorf("cannot decode non-nil codec value into nil %v (%v methods)", f.ti.rt, f.ti.numMeth) + } + + switch n.v { + case valueTypeMap: + mtid := d.mtid + if mtid == 0 { + if d.jsms { + mtid = mapStrIntfTypId + } else { + mtid = mapIntfIntfTypId + } + } + if mtid == mapStrIntfTypId { + var v2 map[string]interface{} + d.decode(&v2) + rvn = rv4iptr(&v2).Elem() + } else if mtid == mapIntfIntfTypId { + var v2 map[interface{}]interface{} + d.decode(&v2) + rvn = rv4iptr(&v2).Elem() + } else if d.mtr { + rvn = reflect.New(d.h.MapType) + d.decode(rv2i(rvn)) + rvn = rvn.Elem() + } else { + + rvn = rvZeroAddrK(d.h.MapType, reflect.Map) + d.decodeValue(rvn, nil) + } + case valueTypeArray: + if d.stid == 0 || d.stid == intfSliceTypId { + var v2 []interface{} + d.decode(&v2) + rvn = rv4iptr(&v2).Elem() + } else if d.str { + rvn = reflect.New(d.h.SliceType) + d.decode(rv2i(rvn)) + rvn = rvn.Elem() + } else { + rvn = rvZeroAddrK(d.h.SliceType, reflect.Slice) + d.decodeValue(rvn, nil) + } + if d.h.PreferArrayOverSlice { + rvn = rvGetArray4Slice(rvn) + } + case valueTypeExt: + tag, bytes := n.u, n.l + bfn := d.h.getExtForTag(tag) + var re = RawExt{Tag: tag} + if bytes == nil { + + if bfn == nil { + d.decode(&re.Value) + rvn = rv4iptr(&re).Elem() + } else if bfn.ext == SelfExt { + rvn = rvZeroAddrK(bfn.rt, bfn.rt.Kind()) + d.decodeValue(rvn, d.fnNoExt(bfn.rt)) + } else { + rvn = reflect.New(bfn.rt) + d.interfaceExtConvertAndDecode(rv2i(rvn), bfn.ext) + rvn = rvn.Elem() + } + } else { + + if bfn == nil { + re.setData(bytes, false) + rvn = rv4iptr(&re).Elem() + } else { + rvn = reflect.New(bfn.rt) + if bfn.ext == SelfExt { + sideDecode(d.hh, &d.h.sideDecPool, func(sd decoderI) { oneOffDecode(sd, rv2i(rvn), bytes, bfn.rt, true) }) + } else { + bfn.ext.ReadExt(rv2i(rvn), bytes) + } + rvn = rvn.Elem() + } + } + + if d.h.PreferPointerForStructOrArray && rvn.CanAddr() { + if rk := rvn.Kind(); rk == reflect.Array || rk == reflect.Struct { + rvn = rvn.Addr() + } + } + case valueTypeNil: + + case valueTypeInt: + rvn = n.ri() + case valueTypeUint: + rvn = n.ru() + case valueTypeFloat: + rvn = n.rf() + case valueTypeBool: + rvn = n.rb() + case valueTypeString, valueTypeSymbol: + rvn = n.rs() + case valueTypeBytes: + rvn = n.rl() + case valueTypeTime: + rvn = n.rt() + default: + halt.errorStr2("kInterfaceNaked: unexpected valueType: ", n.v.String()) + } + return +} + +func (d *decoderMsgpackIO) kInterface(f *decFnInfo, rv reflect.Value) { + + isnilrv := rvIsNil(rv) + + var rvn reflect.Value + + if d.h.InterfaceReset { + + rvn = d.h.intf2impl(f.ti.rtid) + if !rvn.IsValid() { + rvn = d.kInterfaceNaked(f) + if rvn.IsValid() { + rvSetIntf(rv, rvn) + } else if !isnilrv { + decSetNonNilRV2Zero4Intf(rv) + } + return + } + } else if isnilrv { + + rvn = d.h.intf2impl(f.ti.rtid) + if !rvn.IsValid() { + rvn = d.kInterfaceNaked(f) + if rvn.IsValid() { + rvSetIntf(rv, rvn) + } + return + } + } else { + + rvn = rv.Elem() + } + + canDecode, _ := isDecodeable(rvn) + + if !canDecode { + rvn2 := d.oneShotAddrRV(rvn.Type(), rvn.Kind()) + rvSetDirect(rvn2, rvn) + rvn = rvn2 + } + + d.decodeValue(rvn, nil) + rvSetIntf(rv, rvn) +} + +func (d *decoderMsgpackIO) kStructField(si *structFieldInfo, rv reflect.Value) { + if d.d.TryNil() { + rv = si.fieldNoAlloc(rv, true) + if rv.IsValid() { + decSetNonNilRV2Zero(rv) + } + } else if si.decBuiltin { + rv = rvAddr(si.fieldAlloc(rv), si.ptrTyp) + d.decode(rv2i(rv)) + } else { + fn := d.fn(si.baseTyp) + rv = si.fieldAlloc(rv) + if fn.i.addrD { + rv = rvAddr(rv, si.ptrTyp) + } + fn.fd(d, &fn.i, rv) + } +} + +func (d *decoderMsgpackIO) kStructSimple(f *decFnInfo, rv reflect.Value) { + _ = d.d + ctyp := d.d.ContainerType() + ti := f.ti + if ctyp == valueTypeMap { + containerLen := d.mapStart(d.d.ReadMapStart()) + if containerLen == 0 { + d.mapEnd() + return + } + hasLen := containerLen >= 0 + var rvkencname []byte + for j := 0; d.containerNext(j, containerLen, hasLen); j++ { + d.mapElemKey(j == 0) + sab, att := d.d.DecodeStringAsBytes() + rvkencname = d.usableStructFieldNameBytes(rvkencname, sab, att) + d.mapElemValue() + if si := ti.siForEncName(rvkencname); si != nil { + d.kStructField(si, rv) + } else { + d.structFieldNotFound(-1, stringView(rvkencname)) + } + } + d.mapEnd() + } else if ctyp == valueTypeArray { + containerLen := d.arrayStart(d.d.ReadArrayStart()) + if containerLen == 0 { + d.arrayEnd() + return + } + + tisfi := ti.sfi.source() + hasLen := containerLen >= 0 + + for j := 0; d.containerNext(j, containerLen, hasLen); j++ { + d.arrayElem(j == 0) + if j < len(tisfi) { + d.kStructField(tisfi[j], rv) + } else { + d.structFieldNotFound(j, "") + } + } + d.arrayEnd() + } else { + halt.onerror(errNeedMapOrArrayDecodeToStruct) + } +} + +func (d *decoderMsgpackIO) kStruct(f *decFnInfo, rv reflect.Value) { + _ = d.d + ctyp := d.d.ContainerType() + ti := f.ti + var mf MissingFielder + if ti.flagMissingFielder { + mf = rv2i(rv).(MissingFielder) + } else if ti.flagMissingFielderPtr { + mf = rv2i(rvAddr(rv, ti.ptr)).(MissingFielder) + } + if ctyp == valueTypeMap { + containerLen := d.mapStart(d.d.ReadMapStart()) + if containerLen == 0 { + d.mapEnd() + return + } + hasLen := containerLen >= 0 + var name2 []byte + var rvkencname []byte + tkt := ti.keyType + for j := 0; d.containerNext(j, containerLen, hasLen); j++ { + d.mapElemKey(j == 0) + + if tkt == valueTypeString { + sab, att := d.d.DecodeStringAsBytes() + rvkencname = d.usableStructFieldNameBytes(rvkencname, sab, att) + } else if tkt == valueTypeInt { + rvkencname = strconv.AppendInt(d.b[:0], d.d.DecodeInt64(), 10) + } else if tkt == valueTypeUint { + rvkencname = strconv.AppendUint(d.b[:0], d.d.DecodeUint64(), 10) + } else if tkt == valueTypeFloat { + rvkencname = strconv.AppendFloat(d.b[:0], d.d.DecodeFloat64(), 'f', -1, 64) + } else { + halt.errorStr2("invalid struct key type: ", ti.keyType.String()) + } + + d.mapElemValue() + if si := ti.siForEncName(rvkencname); si != nil { + d.kStructField(si, rv) + } else if mf != nil { + + name2 = append(name2[:0], rvkencname...) + var f interface{} + d.decode(&f) + if !mf.CodecMissingField(name2, f) && d.h.ErrorIfNoField { + halt.errorStr2("no matching struct field when decoding stream map with key: ", stringView(name2)) + } + } else { + d.structFieldNotFound(-1, stringView(rvkencname)) + } + } + d.mapEnd() + } else if ctyp == valueTypeArray { + containerLen := d.arrayStart(d.d.ReadArrayStart()) + if containerLen == 0 { + d.arrayEnd() + return + } + + tisfi := ti.sfi.source() + hasLen := containerLen >= 0 + + for j := 0; d.containerNext(j, containerLen, hasLen); j++ { + d.arrayElem(j == 0) + if j < len(tisfi) { + d.kStructField(tisfi[j], rv) + } else { + d.structFieldNotFound(j, "") + } + } + + d.arrayEnd() + } else { + halt.onerror(errNeedMapOrArrayDecodeToStruct) + } +} + +func (d *decoderMsgpackIO) kSlice(f *decFnInfo, rv reflect.Value) { + _ = d.d + + ti := f.ti + rvCanset := rv.CanSet() + + ctyp := d.d.ContainerType() + if ctyp == valueTypeBytes || ctyp == valueTypeString { + + if !(ti.rtid == uint8SliceTypId || ti.elemkind == uint8(reflect.Uint8)) { + halt.errorf("bytes/string in stream must decode into slice/array of bytes, not %v", ti.rt) + } + rvbs := rvGetBytes(rv) + if rvCanset { + bs2, bst := d.decodeBytesInto(rvbs, false) + if bst != dBytesIntoParamOut { + rvSetBytes(rv, bs2) + } + } else { + + d.decodeBytesInto(rvbs[:len(rvbs):len(rvbs)], true) + } + return + } + + var containerLenS int + isArray := ctyp == valueTypeArray + if isArray { + containerLenS = d.arrayStart(d.d.ReadArrayStart()) + } else if ctyp == valueTypeMap { + containerLenS = d.mapStart(d.d.ReadMapStart()) * 2 + } else { + halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String()) + } + + if containerLenS == 0 { + if rvCanset { + if rvIsNil(rv) { + rvSetDirect(rv, rvSliceZeroCap(ti.rt)) + } else { + rvSetSliceLen(rv, 0) + } + } + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } + return + } + + rtelem0Mut := !scalarBitset.isset(ti.elemkind) + rtelem := ti.elem + + for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() { + rtelem = rtelem.Elem() + } + + var fn *decFnMsgpackIO + + var rvChanged bool + + var rv0 = rv + var rv9 reflect.Value + + rvlen := rvLenSlice(rv) + rvcap := rvCapSlice(rv) + maxInitLen := d.maxInitLen() + hasLen := containerLenS >= 0 + if hasLen { + if containerLenS > rvcap { + oldRvlenGtZero := rvlen > 0 + rvlen1 := int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize))) + if rvlen1 == rvlen { + } else if rvlen1 <= rvcap { + if rvCanset { + rvlen = rvlen1 + rvSetSliceLen(rv, rvlen) + } + } else if rvCanset { + rvlen = rvlen1 + rv, rvCanset = rvMakeSlice(rv, f.ti, rvlen, rvlen) + rvcap = rvlen + rvChanged = !rvCanset + } else { + halt.errorStr("cannot decode into non-settable slice") + } + if rvChanged && oldRvlenGtZero && rtelem0Mut { + rvCopySlice(rv, rv0, rtelem) + } + } else if containerLenS != rvlen { + if rvCanset { + rvlen = containerLenS + rvSetSliceLen(rv, rvlen) + } + } + } + + var elemReset = d.h.SliceElementReset + + var rtelemIsPtr bool + var rtelemElem reflect.Type + builtin := ti.tielem.flagDecBuiltin + if builtin { + rtelemIsPtr = ti.elemkind == uint8(reflect.Ptr) + if rtelemIsPtr { + rtelemElem = ti.elem.Elem() + } + } + + var j int + for ; d.containerNext(j, containerLenS, hasLen); j++ { + if j == 0 { + if rvIsNil(rv) { + if rvCanset { + rvlen = int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize))) + rv, rvCanset = rvMakeSlice(rv, f.ti, rvlen, rvlen) + rvcap = rvlen + rvChanged = !rvCanset + } else { + halt.errorStr("cannot decode into non-settable slice") + } + } + if fn == nil { + fn = d.fn(rtelem) + } + } + + if ctyp == valueTypeArray { + d.arrayElem(j == 0) + } else if j&1 == 0 { + d.mapElemKey(j == 0) + } else { + d.mapElemValue() + } + + if j >= rvlen { + + if rvlen < rvcap { + rvlen = rvcap + if rvCanset { + rvSetSliceLen(rv, rvlen) + } else if rvChanged { + rv = rvSlice(rv, rvlen) + } else { + halt.onerror(errExpandSliceCannotChange) + } + } else { + if !(rvCanset || rvChanged) { + halt.onerror(errExpandSliceCannotChange) + } + rv, rvcap, rvCanset = rvGrowSlice(rv, f.ti, rvcap, 1) + + rvlen = rvcap + rvChanged = !rvCanset + } + } + + rv9 = rvArrayIndex(rv, j, f.ti, true) + if elemReset { + rvSetZero(rv9) + } + if d.d.TryNil() { + rvSetZero(rv9) + } else if builtin { + if rtelemIsPtr { + if rvIsNil(rv9) { + rvSetDirect(rv9, reflect.New(rtelemElem)) + } + d.decode(rv2i(rv9)) + } else { + d.decode(rv2i(rvAddr(rv9, ti.tielem.ptr))) + } + } else { + d.decodeValueNoCheckNil(rv9, fn) + } + } + if j < rvlen { + if rvCanset { + rvSetSliceLen(rv, j) + } else if rvChanged { + rv = rvSlice(rv, j) + } + + } else if j == 0 && rvIsNil(rv) { + if rvCanset { + rv = rvSliceZeroCap(ti.rt) + rvCanset = false + rvChanged = true + } + } + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } + + if rvChanged { + rvSetDirect(rv0, rv) + } +} + +func (d *decoderMsgpackIO) kArray(f *decFnInfo, rv reflect.Value) { + _ = d.d + + ti := f.ti + ctyp := d.d.ContainerType() + if handleBytesWithinKArray && (ctyp == valueTypeBytes || ctyp == valueTypeString) { + + if ti.elemkind != uint8(reflect.Uint8) { + halt.errorf("bytes/string in stream can decode into array of bytes, but not %v", ti.rt) + } + rvbs := rvGetArrayBytes(rv, nil) + d.decodeBytesInto(rvbs, true) + return + } + + var containerLenS int + isArray := ctyp == valueTypeArray + if isArray { + containerLenS = d.arrayStart(d.d.ReadArrayStart()) + } else if ctyp == valueTypeMap { + containerLenS = d.mapStart(d.d.ReadMapStart()) * 2 + } else { + halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String()) + } + + if containerLenS == 0 { + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } + return + } + + rtelem := ti.elem + for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() { + rtelem = rtelem.Elem() + } + + var rv9 reflect.Value + + rvlen := rv.Len() + hasLen := containerLenS >= 0 + if hasLen && containerLenS > rvlen { + halt.errorf("cannot decode into array with length: %v, less than container length: %v", any(rvlen), any(containerLenS)) + } + + var elemReset = d.h.SliceElementReset + + var rtelemIsPtr bool + var rtelemElem reflect.Type + var fn *decFnMsgpackIO + builtin := ti.tielem.flagDecBuiltin + if builtin { + rtelemIsPtr = ti.elemkind == uint8(reflect.Ptr) + if rtelemIsPtr { + rtelemElem = ti.elem.Elem() + } + } else { + fn = d.fn(rtelem) + } + + for j := 0; d.containerNext(j, containerLenS, hasLen); j++ { + if ctyp == valueTypeArray { + d.arrayElem(j == 0) + } else if j&1 == 0 { + d.mapElemKey(j == 0) + } else { + d.mapElemValue() + } + + if j >= rvlen { + d.arrayCannotExpand(rvlen, j+1) + d.swallow() + continue + } + + rv9 = rvArrayIndex(rv, j, f.ti, false) + if elemReset { + rvSetZero(rv9) + } + if d.d.TryNil() { + rvSetZero(rv9) + } else if builtin { + if rtelemIsPtr { + if rvIsNil(rv9) { + rvSetDirect(rv9, reflect.New(rtelemElem)) + } + d.decode(rv2i(rv9)) + } else { + d.decode(rv2i(rvAddr(rv9, ti.tielem.ptr))) + } + } else { + d.decodeValueNoCheckNil(rv9, fn) + } + } + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } +} + +func (d *decoderMsgpackIO) kChan(f *decFnInfo, rv reflect.Value) { + _ = d.d + + ti := f.ti + if ti.chandir&uint8(reflect.SendDir) == 0 { + halt.errorStr("receive-only channel cannot be decoded") + } + ctyp := d.d.ContainerType() + if ctyp == valueTypeBytes || ctyp == valueTypeString { + + if !(ti.rtid == uint8SliceTypId || ti.elemkind == uint8(reflect.Uint8)) { + halt.errorf("bytes/string in stream must decode into slice/array of bytes, not %v", ti.rt) + } + bs2, _ := d.d.DecodeBytes() + irv := rv2i(rv) + ch, ok := irv.(chan<- byte) + if !ok { + ch = irv.(chan byte) + } + for _, b := range bs2 { + ch <- b + } + return + } + + var rvCanset = rv.CanSet() + + var containerLenS int + isArray := ctyp == valueTypeArray + if isArray { + containerLenS = d.arrayStart(d.d.ReadArrayStart()) + } else if ctyp == valueTypeMap { + containerLenS = d.mapStart(d.d.ReadMapStart()) * 2 + } else { + halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String()) + } + + if containerLenS == 0 { + if rvCanset && rvIsNil(rv) { + rvSetDirect(rv, reflect.MakeChan(ti.rt, 0)) + } + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } + return + } + + rtelem := ti.elem + useTransient := decUseTransient && ti.elemkind != byte(reflect.Ptr) && ti.tielem.flagCanTransient + + for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() { + rtelem = rtelem.Elem() + } + + var fn *decFnMsgpackIO + + var rvChanged bool + var rv0 = rv + var rv9 reflect.Value + + var rvlen int + hasLen := containerLenS >= 0 + maxInitLen := d.maxInitLen() + + for j := 0; d.containerNext(j, containerLenS, hasLen); j++ { + if j == 0 { + if rvIsNil(rv) { + if hasLen { + rvlen = int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize))) + } else { + rvlen = decDefChanCap + } + if rvCanset { + rv = reflect.MakeChan(ti.rt, rvlen) + rvChanged = true + } else { + halt.errorStr("cannot decode into non-settable chan") + } + } + if fn == nil { + fn = d.fn(rtelem) + } + } + + if ctyp == valueTypeArray { + d.arrayElem(j == 0) + } else if j&1 == 0 { + d.mapElemKey(j == 0) + } else { + d.mapElemValue() + } + + if rv9.IsValid() { + rvSetZero(rv9) + } else if useTransient { + rv9 = d.perType.TransientAddrK(ti.elem, reflect.Kind(ti.elemkind)) + } else { + rv9 = rvZeroAddrK(ti.elem, reflect.Kind(ti.elemkind)) + } + if !d.d.TryNil() { + d.decodeValueNoCheckNil(rv9, fn) + } + rv.Send(rv9) + } + if isArray { + d.arrayEnd() + } else { + d.mapEnd() + } + + if rvChanged { + rvSetDirect(rv0, rv) + } + +} + +func (d *decoderMsgpackIO) kMap(f *decFnInfo, rv reflect.Value) { + _ = d.d + containerLen := d.mapStart(d.d.ReadMapStart()) + ti := f.ti + if rvIsNil(rv) { + rvlen := int(decInferLen(containerLen, d.maxInitLen(), uint(ti.keysize+ti.elemsize))) + rvSetDirect(rv, makeMapReflect(ti.rt, rvlen)) + } + + if containerLen == 0 { + d.mapEnd() + return + } + + ktype, vtype := ti.key, ti.elem + ktypeId := rt2id(ktype) + vtypeKind := reflect.Kind(ti.elemkind) + ktypeKind := reflect.Kind(ti.keykind) + mparams := getMapReqParams(ti) + + vtypePtr := vtypeKind == reflect.Ptr + ktypePtr := ktypeKind == reflect.Ptr + + vTransient := decUseTransient && !vtypePtr && ti.tielem.flagCanTransient + + kTransient := vTransient && !ktypePtr && ti.tikey.flagCanTransient + + var vtypeElem reflect.Type + + var keyFn, valFn *decFnMsgpackIO + var ktypeLo, vtypeLo = ktype, vtype + + if ktypeKind == reflect.Ptr { + for ktypeLo = ktype.Elem(); ktypeLo.Kind() == reflect.Ptr; ktypeLo = ktypeLo.Elem() { + } + } + + if vtypePtr { + vtypeElem = vtype.Elem() + for vtypeLo = vtypeElem; vtypeLo.Kind() == reflect.Ptr; vtypeLo = vtypeLo.Elem() { + } + } + + rvkMut := !scalarBitset.isset(ti.keykind) + rvvMut := !scalarBitset.isset(ti.elemkind) + rvvCanNil := isnilBitset.isset(ti.elemkind) + + var rvk, rvkn, rvv, rvvn, rvva, rvvz reflect.Value + + var doMapGet, doMapSet bool + + if !d.h.MapValueReset { + if rvvMut && (vtypeKind != reflect.Interface || !d.h.InterfaceReset) { + doMapGet = true + rvva = mapAddrLoopvarRV(vtype, vtypeKind) + } + } + + ktypeIsString := ktypeId == stringTypId + ktypeIsIntf := ktypeId == intfTypId + hasLen := containerLen >= 0 + + var kstr2bs []byte + var kstr string + + var mapKeyStringSharesBytesBuf bool + var att dBytesAttachState + + var vElem, kElem reflect.Type + kbuiltin := ti.tikey.flagDecBuiltin && ti.keykind != uint8(reflect.Slice) + vbuiltin := ti.tielem.flagDecBuiltin + if kbuiltin && ktypePtr { + kElem = ti.key.Elem() + } + if vbuiltin && vtypePtr { + vElem = ti.elem.Elem() + } + + for j := 0; d.containerNext(j, containerLen, hasLen); j++ { + mapKeyStringSharesBytesBuf = false + kstr = "" + if j == 0 { + + if kTransient { + rvk = d.perType.TransientAddr2K(ktype, ktypeKind) + } else { + rvk = rvZeroAddrK(ktype, ktypeKind) + } + if !rvkMut { + rvkn = rvk + } + if !rvvMut { + if vTransient { + rvvn = d.perType.TransientAddrK(vtype, vtypeKind) + } else { + rvvn = rvZeroAddrK(vtype, vtypeKind) + } + } + if !ktypeIsString && keyFn == nil { + keyFn = d.fn(ktypeLo) + } + if valFn == nil { + valFn = d.fn(vtypeLo) + } + } else if rvkMut { + rvSetZero(rvk) + } else { + rvk = rvkn + } + + d.mapElemKey(j == 0) + + if d.d.TryNil() { + rvSetZero(rvk) + } else if ktypeIsString { + kstr2bs, att = d.d.DecodeStringAsBytes() + kstr, mapKeyStringSharesBytesBuf = d.bytes2Str(kstr2bs, att) + rvSetString(rvk, kstr) + } else { + if kbuiltin { + if ktypePtr { + if rvIsNil(rvk) { + rvSetDirect(rvk, reflect.New(kElem)) + } + d.decode(rv2i(rvk)) + } else { + d.decode(rv2i(rvAddr(rvk, ti.tikey.ptr))) + } + } else { + d.decodeValueNoCheckNil(rvk, keyFn) + } + + if ktypeIsIntf { + if rvk2 := rvk.Elem(); rvk2.IsValid() && rvk2.Type() == uint8SliceTyp { + kstr2bs = rvGetBytes(rvk2) + kstr, mapKeyStringSharesBytesBuf = d.bytes2Str(kstr2bs, dBytesAttachView) + rvSetIntf(rvk, rv4istr(kstr)) + } + + } + } + + if mapKeyStringSharesBytesBuf && d.bufio { + if ktypeIsString { + rvSetString(rvk, d.detach2Str(kstr2bs, att)) + } else { + rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att))) + } + mapKeyStringSharesBytesBuf = false + } + + d.mapElemValue() + + if d.d.TryNil() { + if mapKeyStringSharesBytesBuf { + if ktypeIsString { + rvSetString(rvk, d.detach2Str(kstr2bs, att)) + } else { + rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att))) + } + } + + if !rvvz.IsValid() { + rvvz = rvZeroK(vtype, vtypeKind) + } + mapSet(rv, rvk, rvvz, mparams) + continue + } + + doMapSet = true + + if !rvvMut { + rvv = rvvn + } else if !doMapGet { + goto NEW_RVV + } else { + rvv = mapGet(rv, rvk, rvva, mparams) + if !rvv.IsValid() || (rvvCanNil && rvIsNil(rvv)) { + goto NEW_RVV + } + switch vtypeKind { + case reflect.Ptr, reflect.Map: + doMapSet = false + case reflect.Interface: + + rvvn = rvv.Elem() + if k := rvvn.Kind(); (k == reflect.Ptr || k == reflect.Map) && !rvIsNil(rvvn) { + d.decodeValueNoCheckNil(rvvn, nil) + continue + } + + rvvn = rvZeroAddrK(vtype, vtypeKind) + rvSetIntf(rvvn, rvv) + rvv = rvvn + default: + + if vTransient { + rvvn = d.perType.TransientAddrK(vtype, vtypeKind) + } else { + rvvn = rvZeroAddrK(vtype, vtypeKind) + } + rvSetDirect(rvvn, rvv) + rvv = rvvn + } + } + goto DECODE_VALUE_NO_CHECK_NIL + + NEW_RVV: + if vtypePtr { + rvv = reflect.New(vtypeElem) + } else if vTransient { + rvv = d.perType.TransientAddrK(vtype, vtypeKind) + } else { + rvv = rvZeroAddrK(vtype, vtypeKind) + } + + DECODE_VALUE_NO_CHECK_NIL: + if doMapSet && mapKeyStringSharesBytesBuf { + if ktypeIsString { + rvSetString(rvk, d.detach2Str(kstr2bs, att)) + } else { + rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att))) + } + } + if vbuiltin { + if vtypePtr { + if rvIsNil(rvv) { + rvSetDirect(rvv, reflect.New(vElem)) + } + d.decode(rv2i(rvv)) + } else { + d.decode(rv2i(rvAddr(rvv, ti.tielem.ptr))) + } + } else { + d.decodeValueNoCheckNil(rvv, valFn) + } + if doMapSet { + mapSet(rv, rvk, rvv, mparams) + } + } + + d.mapEnd() +} + +func (d *decoderMsgpackIO) init(h Handle) { + initHandle(h) + callMake(&d.d) + d.hh = h + d.h = h.getBasicHandle() + + d.err = errDecoderNotInitialized + + if d.h.InternString && d.is == nil { + d.is.init() + } + + d.fp = d.d.init(h, &d.decoderBase, d).(*fastpathDsMsgpackIO) + + if d.bytes { + d.rtidFn = &d.h.rtidFnsDecBytes + d.rtidFnNoExt = &d.h.rtidFnsDecNoExtBytes + } else { + d.bufio = d.h.ReaderBufferSize > 0 + d.rtidFn = &d.h.rtidFnsDecIO + d.rtidFnNoExt = &d.h.rtidFnsDecNoExtIO + } + + d.reset() + +} + +func (d *decoderMsgpackIO) reset() { + d.d.reset() + d.err = nil + d.c = 0 + d.depth = 0 + d.calls = 0 + + d.maxdepth = decDefMaxDepth + if d.h.MaxDepth > 0 { + d.maxdepth = d.h.MaxDepth + } + d.mtid = 0 + d.stid = 0 + d.mtr = false + d.str = false + if d.h.MapType != nil { + d.mtid = rt2id(d.h.MapType) + _, d.mtr = fastpathAvIndex(d.mtid) + } + if d.h.SliceType != nil { + d.stid = rt2id(d.h.SliceType) + _, d.str = fastpathAvIndex(d.stid) + } +} + +func (d *decoderMsgpackIO) Reset(r io.Reader) { + if d.bytes { + halt.onerror(errDecNoResetBytesWithReader) + } + d.reset() + if r == nil { + r = &eofReader + } + d.d.resetInIO(r) +} + +func (d *decoderMsgpackIO) ResetBytes(in []byte) { + if !d.bytes { + halt.onerror(errDecNoResetReaderWithBytes) + } + d.resetBytes(in) +} + +func (d *decoderMsgpackIO) resetBytes(in []byte) { + d.reset() + if in == nil { + in = zeroByteSlice + } + d.d.resetInBytes(in) +} + +func (d *decoderMsgpackIO) ResetString(s string) { + d.ResetBytes(bytesView(s)) +} + +func (d *decoderMsgpackIO) Decode(v interface{}) (err error) { + + defer panicValToErr(d, callRecoverSentinel, &d.err, &err, debugging) + d.mustDecode(v) + return +} + +func (d *decoderMsgpackIO) MustDecode(v interface{}) { + defer panicValToErr(d, callRecoverSentinel, &d.err, nil, true) + d.mustDecode(v) + return +} + +func (d *decoderMsgpackIO) mustDecode(v interface{}) { + halt.onerror(d.err) + if d.hh == nil { + halt.onerror(errNoFormatHandle) + } + + d.calls++ + d.decode(v) + d.calls-- +} + +func (d *decoderMsgpackIO) Release() {} + +func (d *decoderMsgpackIO) swallow() { + d.d.nextValueBytes() +} + +func (d *decoderMsgpackIO) nextValueBytes() []byte { + return d.d.nextValueBytes() +} + +func (d *decoderMsgpackIO) decode(iv interface{}) { + _ = d.d + + rv, ok := isNil(iv, true) + if ok { + halt.onerror(errCannotDecodeIntoNil) + } + + switch v := iv.(type) { + + case *string: + *v = d.detach2Str(d.d.DecodeStringAsBytes()) + case *bool: + *v = d.d.DecodeBool() + case *int: + *v = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize)) + case *int8: + *v = int8(chkOvf.IntV(d.d.DecodeInt64(), 8)) + case *int16: + *v = int16(chkOvf.IntV(d.d.DecodeInt64(), 16)) + case *int32: + *v = int32(chkOvf.IntV(d.d.DecodeInt64(), 32)) + case *int64: + *v = d.d.DecodeInt64() + case *uint: + *v = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize)) + case *uint8: + *v = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8)) + case *uint16: + *v = uint16(chkOvf.UintV(d.d.DecodeUint64(), 16)) + case *uint32: + *v = uint32(chkOvf.UintV(d.d.DecodeUint64(), 32)) + case *uint64: + *v = d.d.DecodeUint64() + case *uintptr: + *v = uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize)) + case *float32: + *v = d.d.DecodeFloat32() + case *float64: + *v = d.d.DecodeFloat64() + case *complex64: + *v = complex(d.d.DecodeFloat32(), 0) + case *complex128: + *v = complex(d.d.DecodeFloat64(), 0) + case *[]byte: + *v, _ = d.decodeBytesInto(*v, false) + case []byte: + + d.decodeBytesInto(v[:len(v):len(v)], true) + case *time.Time: + *v = d.d.DecodeTime() + case *Raw: + *v = d.rawBytes() + + case *interface{}: + d.decodeValue(rv4iptr(v), nil) + + case reflect.Value: + if ok, _ = isDecodeable(v); !ok { + d.haltAsNotDecodeable(v) + } + d.decodeValue(v, nil) + + default: + + if skipFastpathTypeSwitchInDirectCall || !d.dh.fastpathDecodeTypeSwitch(iv, d) { + if !rv.IsValid() { + rv = reflect.ValueOf(iv) + } + if ok, _ = isDecodeable(rv); !ok { + d.haltAsNotDecodeable(rv) + } + d.decodeValue(rv, nil) + } + } +} + +func (d *decoderMsgpackIO) decodeValue(rv reflect.Value, fn *decFnMsgpackIO) { + if d.d.TryNil() { + decSetNonNilRV2Zero(rv) + } else { + d.decodeValueNoCheckNil(rv, fn) + } +} + +func (d *decoderMsgpackIO) decodeValueNoCheckNil(rv reflect.Value, fn *decFnMsgpackIO) { + + var rvp reflect.Value + var rvpValid bool +PTR: + if rv.Kind() == reflect.Ptr { + rvpValid = true + if rvIsNil(rv) { + rvSetDirect(rv, reflect.New(rv.Type().Elem())) + } + rvp = rv + rv = rv.Elem() + goto PTR + } + + if fn == nil { + fn = d.fn(rv.Type()) + } + if fn.i.addrD { + if rvpValid { + rv = rvp + } else if rv.CanAddr() { + rv = rvAddr(rv, fn.i.ti.ptr) + } else if fn.i.addrDf { + halt.errorStr("cannot decode into a non-pointer value") + } + } + fn.fd(d, &fn.i, rv) +} + +func (d *decoderMsgpackIO) decodeAs(v interface{}, t reflect.Type, ext bool) { + if ext { + d.decodeValue(baseRV(v), d.fn(t)) + } else { + d.decodeValue(baseRV(v), d.fnNoExt(t)) + } +} + +func (d *decoderMsgpackIO) structFieldNotFound(index int, rvkencname string) { + + if d.h.ErrorIfNoField { + if index >= 0 { + halt.errorInt("no matching struct field found when decoding stream array at index ", int64(index)) + } else if rvkencname != "" { + halt.errorStr2("no matching struct field found when decoding stream map with key ", rvkencname) + } + } + d.swallow() +} + +func (d *decoderMsgpackIO) decodeBytesInto(out []byte, mustFit bool) (v []byte, state dBytesIntoState) { + v, att := d.d.DecodeBytes() + if cap(v) == 0 || (att >= dBytesAttachViewZerocopy && !mustFit) { + + return + } + if len(v) == 0 { + v = zeroByteSlice + return + } + if len(out) == len(v) { + state = dBytesIntoParamOut + } else if cap(out) >= len(v) { + out = out[:len(v)] + state = dBytesIntoParamOutSlice + } else if mustFit { + halt.errorf("bytes capacity insufficient for decoded bytes: got/expected: %d/%d", len(v), len(out)) + } else { + out = make([]byte, len(v)) + state = dBytesIntoNew + } + copy(out, v) + v = out + return +} + +func (d *decoderMsgpackIO) rawBytes() (v []byte) { + + v = d.d.nextValueBytes() + if d.bytes && !d.h.ZeroCopy { + vv := make([]byte, len(v)) + copy(vv, v) + v = vv + } + return +} + +func (d *decoderMsgpackIO) wrapErr(v error, err *error) { + *err = wrapCodecErr(v, d.hh.Name(), d.d.NumBytesRead(), false) +} + +func (d *decoderMsgpackIO) NumBytesRead() int { + return d.d.NumBytesRead() +} + +func (d *decoderMsgpackIO) containerNext(j, containerLen int, hasLen bool) bool { + + if hasLen { + return j < containerLen + } + return !d.d.CheckBreak() +} + +func (d *decoderMsgpackIO) mapElemKey(firstTime bool) { + d.d.ReadMapElemKey(firstTime) + d.c = containerMapKey +} + +func (d *decoderMsgpackIO) mapElemValue() { + d.d.ReadMapElemValue() + d.c = containerMapValue +} + +func (d *decoderMsgpackIO) mapEnd() { + d.d.ReadMapEnd() + d.depthDecr() + d.c = 0 +} + +func (d *decoderMsgpackIO) arrayElem(firstTime bool) { + d.d.ReadArrayElem(firstTime) + d.c = containerArrayElem +} + +func (d *decoderMsgpackIO) arrayEnd() { + d.d.ReadArrayEnd() + d.depthDecr() + d.c = 0 +} + +func (d *decoderMsgpackIO) interfaceExtConvertAndDecode(v interface{}, ext InterfaceExt) { + + var vv interface{} + d.decode(&vv) + ext.UpdateExt(v, vv) + +} + +func (d *decoderMsgpackIO) fn(t reflect.Type) *decFnMsgpackIO { + return d.dh.decFnViaBH(t, d.rtidFn, d.h, d.fp, false) +} + +func (d *decoderMsgpackIO) fnNoExt(t reflect.Type) *decFnMsgpackIO { + return d.dh.decFnViaBH(t, d.rtidFnNoExt, d.h, d.fp, true) +} + +func (helperDecDriverMsgpackIO) newDecoderBytes(in []byte, h Handle) *decoderMsgpackIO { + var c1 decoderMsgpackIO + c1.bytes = true + c1.init(h) + c1.ResetBytes(in) + return &c1 +} + +func (helperDecDriverMsgpackIO) newDecoderIO(in io.Reader, h Handle) *decoderMsgpackIO { + var c1 decoderMsgpackIO + c1.init(h) + c1.Reset(in) + return &c1 +} + +func (helperDecDriverMsgpackIO) decFnloadFastpathUnderlying(ti *typeInfo, fp *fastpathDsMsgpackIO) (f *fastpathDMsgpackIO, u reflect.Type) { + rtid := rt2id(ti.fastpathUnderlying) + idx, ok := fastpathAvIndex(rtid) + if !ok { + return + } + f = &fp[idx] + if uint8(reflect.Array) == ti.kind { + u = reflect.ArrayOf(ti.rt.Len(), ti.elem) + } else { + u = f.rt + } + return +} + +func (helperDecDriverMsgpackIO) decFindRtidFn(s []decRtidFnMsgpackIO, rtid uintptr) (i uint, fn *decFnMsgpackIO) { + + var h uint + var j = uint(len(s)) +LOOP: + if i < j { + h = (i + j) >> 1 + if s[h].rtid < rtid { + i = h + 1 + } else { + j = h + } + goto LOOP + } + if i < uint(len(s)) && s[i].rtid == rtid { + fn = s[i].fn + } + return +} + +func (helperDecDriverMsgpackIO) decFromRtidFnSlice(fns *atomicRtidFnSlice) (s []decRtidFnMsgpackIO) { + if v := fns.load(); v != nil { + s = *(lowLevelToPtr[[]decRtidFnMsgpackIO](v)) + } + return +} + +func (dh helperDecDriverMsgpackIO) decFnViaBH(rt reflect.Type, fns *atomicRtidFnSlice, x *BasicHandle, fp *fastpathDsMsgpackIO, + checkExt bool) (fn *decFnMsgpackIO) { + return dh.decFnVia(rt, fns, x.typeInfos(), &x.mu, x.extHandle, fp, + checkExt, x.CheckCircularRef, x.timeBuiltin, x.binaryHandle, x.jsonHandle) +} + +func (dh helperDecDriverMsgpackIO) decFnVia(rt reflect.Type, fns *atomicRtidFnSlice, + tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathDsMsgpackIO, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackIO) { + rtid := rt2id(rt) + var sp []decRtidFnMsgpackIO = dh.decFromRtidFnSlice(fns) + if sp != nil { + _, fn = dh.decFindRtidFn(sp, rtid) + } + if fn == nil { + fn = dh.decFnViaLoader(rt, rtid, fns, tinfos, mu, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json) + } + return +} + +func (dh helperDecDriverMsgpackIO) decFnViaLoader(rt reflect.Type, rtid uintptr, fns *atomicRtidFnSlice, + tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathDsMsgpackIO, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackIO) { + + fn = dh.decFnLoad(rt, rtid, tinfos, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json) + var sp []decRtidFnMsgpackIO + mu.Lock() + sp = dh.decFromRtidFnSlice(fns) + + if sp == nil { + sp = []decRtidFnMsgpackIO{{rtid, fn}} + fns.store(ptrToLowLevel(&sp)) + } else { + idx, fn2 := dh.decFindRtidFn(sp, rtid) + if fn2 == nil { + sp2 := make([]decRtidFnMsgpackIO, len(sp)+1) + copy(sp2[idx+1:], sp[idx:]) + copy(sp2, sp[:idx]) + sp2[idx] = decRtidFnMsgpackIO{rtid, fn} + fns.store(ptrToLowLevel(&sp2)) + } + } + mu.Unlock() + return +} + +func (dh helperDecDriverMsgpackIO) decFnLoad(rt reflect.Type, rtid uintptr, tinfos *TypeInfos, + exth extHandle, fp *fastpathDsMsgpackIO, + checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackIO) { + fn = new(decFnMsgpackIO) + fi := &(fn.i) + ti := tinfos.get(rtid, rt) + fi.ti = ti + rk := reflect.Kind(ti.kind) + + fi.addrDf = true + + if rtid == timeTypId && timeBuiltin { + fn.fd = (*decoderMsgpackIO).kTime + } else if rtid == rawTypId { + fn.fd = (*decoderMsgpackIO).raw + } else if rtid == rawExtTypId { + fn.fd = (*decoderMsgpackIO).rawExt + fi.addrD = true + } else if xfFn := exth.getExt(rtid, checkExt); xfFn != nil { + fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext + fn.fd = (*decoderMsgpackIO).ext + fi.addrD = true + } else if ti.flagSelfer || ti.flagSelferPtr { + fn.fd = (*decoderMsgpackIO).selferUnmarshal + fi.addrD = ti.flagSelferPtr + } else if supportMarshalInterfaces && binaryEncoding && + (ti.flagBinaryMarshaler || ti.flagBinaryMarshalerPtr) && + (ti.flagBinaryUnmarshaler || ti.flagBinaryUnmarshalerPtr) { + fn.fd = (*decoderMsgpackIO).binaryUnmarshal + fi.addrD = ti.flagBinaryUnmarshalerPtr + } else if supportMarshalInterfaces && !binaryEncoding && json && + (ti.flagJsonMarshaler || ti.flagJsonMarshalerPtr) && + (ti.flagJsonUnmarshaler || ti.flagJsonUnmarshalerPtr) { + + fn.fd = (*decoderMsgpackIO).jsonUnmarshal + fi.addrD = ti.flagJsonUnmarshalerPtr + } else if supportMarshalInterfaces && !binaryEncoding && + (ti.flagTextMarshaler || ti.flagTextMarshalerPtr) && + (ti.flagTextUnmarshaler || ti.flagTextUnmarshalerPtr) { + fn.fd = (*decoderMsgpackIO).textUnmarshal + fi.addrD = ti.flagTextUnmarshalerPtr + } else { + if fastpathEnabled && (rk == reflect.Map || rk == reflect.Slice || rk == reflect.Array) { + var rtid2 uintptr + if !ti.flagHasPkgPath { + rtid2 = rtid + if rk == reflect.Array { + rtid2 = rt2id(ti.key) + } + if idx, ok := fastpathAvIndex(rtid2); ok { + fn.fd = fp[idx].decfn + fi.addrD = true + fi.addrDf = false + if rk == reflect.Array { + fi.addrD = false + } + } + } else { + + xfe, xrt := dh.decFnloadFastpathUnderlying(ti, fp) + if xfe != nil { + xfnf2 := xfe.decfn + if rk == reflect.Array { + fi.addrD = false + fn.fd = func(d *decoderMsgpackIO, xf *decFnInfo, xrv reflect.Value) { + xfnf2(d, xf, rvConvert(xrv, xrt)) + } + } else { + fi.addrD = true + fi.addrDf = false + xptr2rt := reflect.PointerTo(xrt) + fn.fd = func(d *decoderMsgpackIO, xf *decFnInfo, xrv reflect.Value) { + if xrv.Kind() == reflect.Ptr { + xfnf2(d, xf, rvConvert(xrv, xptr2rt)) + } else { + xfnf2(d, xf, rvConvert(xrv, xrt)) + } + } + } + } + } + } + if fn.fd == nil { + switch rk { + case reflect.Bool: + fn.fd = (*decoderMsgpackIO).kBool + case reflect.String: + fn.fd = (*decoderMsgpackIO).kString + case reflect.Int: + fn.fd = (*decoderMsgpackIO).kInt + case reflect.Int8: + fn.fd = (*decoderMsgpackIO).kInt8 + case reflect.Int16: + fn.fd = (*decoderMsgpackIO).kInt16 + case reflect.Int32: + fn.fd = (*decoderMsgpackIO).kInt32 + case reflect.Int64: + fn.fd = (*decoderMsgpackIO).kInt64 + case reflect.Uint: + fn.fd = (*decoderMsgpackIO).kUint + case reflect.Uint8: + fn.fd = (*decoderMsgpackIO).kUint8 + case reflect.Uint16: + fn.fd = (*decoderMsgpackIO).kUint16 + case reflect.Uint32: + fn.fd = (*decoderMsgpackIO).kUint32 + case reflect.Uint64: + fn.fd = (*decoderMsgpackIO).kUint64 + case reflect.Uintptr: + fn.fd = (*decoderMsgpackIO).kUintptr + case reflect.Float32: + fn.fd = (*decoderMsgpackIO).kFloat32 + case reflect.Float64: + fn.fd = (*decoderMsgpackIO).kFloat64 + case reflect.Complex64: + fn.fd = (*decoderMsgpackIO).kComplex64 + case reflect.Complex128: + fn.fd = (*decoderMsgpackIO).kComplex128 + case reflect.Chan: + fn.fd = (*decoderMsgpackIO).kChan + case reflect.Slice: + fn.fd = (*decoderMsgpackIO).kSlice + case reflect.Array: + fi.addrD = false + fn.fd = (*decoderMsgpackIO).kArray + case reflect.Struct: + if ti.simple { + fn.fd = (*decoderMsgpackIO).kStructSimple + } else { + fn.fd = (*decoderMsgpackIO).kStruct + } + case reflect.Map: + fn.fd = (*decoderMsgpackIO).kMap + case reflect.Interface: + + fn.fd = (*decoderMsgpackIO).kInterface + default: + + fn.fd = (*decoderMsgpackIO).kErr + } + } + } + return +} +func (e *msgpackEncDriverIO) EncodeNil() { + e.w.writen1(mpNil) +} + +func (e *msgpackEncDriverIO) EncodeInt(i int64) { + if e.h.PositiveIntUnsigned && i >= 0 { + e.EncodeUint(uint64(i)) + } else if i > math.MaxInt8 { + if i <= math.MaxInt16 { + e.w.writen1(mpInt16) + e.w.writen2(bigen.PutUint16(uint16(i))) + } else if i <= math.MaxInt32 { + e.w.writen1(mpInt32) + e.w.writen4(bigen.PutUint32(uint32(i))) + } else { + e.w.writen1(mpInt64) + e.w.writen8(bigen.PutUint64(uint64(i))) + } + } else if i >= -32 { + if e.h.NoFixedNum { + e.w.writen2(mpInt8, byte(i)) + } else { + e.w.writen1(byte(i)) + } + } else if i >= math.MinInt8 { + e.w.writen2(mpInt8, byte(i)) + } else if i >= math.MinInt16 { + e.w.writen1(mpInt16) + e.w.writen2(bigen.PutUint16(uint16(i))) + } else if i >= math.MinInt32 { + e.w.writen1(mpInt32) + e.w.writen4(bigen.PutUint32(uint32(i))) + } else { + e.w.writen1(mpInt64) + e.w.writen8(bigen.PutUint64(uint64(i))) + } +} + +func (e *msgpackEncDriverIO) EncodeUint(i uint64) { + if i <= math.MaxInt8 { + if e.h.NoFixedNum { + e.w.writen2(mpUint8, byte(i)) + } else { + e.w.writen1(byte(i)) + } + } else if i <= math.MaxUint8 { + e.w.writen2(mpUint8, byte(i)) + } else if i <= math.MaxUint16 { + e.w.writen1(mpUint16) + e.w.writen2(bigen.PutUint16(uint16(i))) + } else if i <= math.MaxUint32 { + e.w.writen1(mpUint32) + e.w.writen4(bigen.PutUint32(uint32(i))) + } else { + e.w.writen1(mpUint64) + e.w.writen8(bigen.PutUint64(uint64(i))) + } +} + +func (e *msgpackEncDriverIO) EncodeBool(b bool) { + if b { + e.w.writen1(mpTrue) + } else { + e.w.writen1(mpFalse) + } +} + +func (e *msgpackEncDriverIO) EncodeFloat32(f float32) { + e.w.writen1(mpFloat) + e.w.writen4(bigen.PutUint32(math.Float32bits(f))) +} + +func (e *msgpackEncDriverIO) EncodeFloat64(f float64) { + e.w.writen1(mpDouble) + e.w.writen8(bigen.PutUint64(math.Float64bits(f))) +} + +func (e *msgpackEncDriverIO) EncodeTime(t time.Time) { + if t.IsZero() { + e.EncodeNil() + return + } + t = t.UTC() + sec, nsec := t.Unix(), uint64(t.Nanosecond()) + var data64 uint64 + var l = 4 + if sec >= 0 && sec>>34 == 0 { + data64 = (nsec << 34) | uint64(sec) + if data64&0xffffffff00000000 != 0 { + l = 8 + } + } else { + l = 12 + } + if e.h.WriteExt { + e.encodeExtPreamble(mpTimeExtTagU, l) + } else { + e.writeContainerLen(msgpackContainerRawLegacy, l) + } + switch l { + case 4: + e.w.writen4(bigen.PutUint32(uint32(data64))) + case 8: + e.w.writen8(bigen.PutUint64(data64)) + case 12: + e.w.writen4(bigen.PutUint32(uint32(nsec))) + e.w.writen8(bigen.PutUint64(uint64(sec))) + } +} + +func (e *msgpackEncDriverIO) EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext) { + var bs0, bs []byte + if ext == SelfExt { + bs0 = e.e.blist.get(1024) + bs = bs0 + sideEncode(e.h, &e.h.sideEncPool, func(se encoderI) { oneOffEncode(se, v, &bs, basetype, true) }) + } else { + bs = ext.WriteExt(v) + } + if bs == nil { + e.writeNilBytes() + goto END + } + if e.h.WriteExt { + e.encodeExtPreamble(uint8(xtag), len(bs)) + e.w.writeb(bs) + } else { + e.EncodeBytes(bs) + } +END: + if ext == SelfExt { + e.e.blist.put(bs) + if !byteSliceSameData(bs0, bs) { + e.e.blist.put(bs0) + } + } +} + +func (e *msgpackEncDriverIO) EncodeRawExt(re *RawExt) { + e.encodeExtPreamble(uint8(re.Tag), len(re.Data)) + e.w.writeb(re.Data) +} + +func (e *msgpackEncDriverIO) encodeExtPreamble(xtag byte, l int) { + if l == 1 { + e.w.writen2(mpFixExt1, xtag) + } else if l == 2 { + e.w.writen2(mpFixExt2, xtag) + } else if l == 4 { + e.w.writen2(mpFixExt4, xtag) + } else if l == 8 { + e.w.writen2(mpFixExt8, xtag) + } else if l == 16 { + e.w.writen2(mpFixExt16, xtag) + } else if l < 256 { + e.w.writen2(mpExt8, byte(l)) + e.w.writen1(xtag) + } else if l < 65536 { + e.w.writen1(mpExt16) + e.w.writen2(bigen.PutUint16(uint16(l))) + e.w.writen1(xtag) + } else { + e.w.writen1(mpExt32) + e.w.writen4(bigen.PutUint32(uint32(l))) + e.w.writen1(xtag) + } +} + +func (e *msgpackEncDriverIO) WriteArrayStart(length int) { + e.writeContainerLen(msgpackContainerList, length) +} + +func (e *msgpackEncDriverIO) WriteMapStart(length int) { + e.writeContainerLen(msgpackContainerMap, length) +} + +func (e *msgpackEncDriverIO) WriteArrayEmpty() { + + e.w.writen1(mpFixArrayMin) +} + +func (e *msgpackEncDriverIO) WriteMapEmpty() { + + e.w.writen1(mpFixMapMin) +} + +func (e *msgpackEncDriverIO) EncodeString(s string) { + var ct msgpackContainerType + if e.h.WriteExt { + if e.h.StringToRaw { + ct = msgpackContainerBin + } else { + ct = msgpackContainerStr + } + } else { + ct = msgpackContainerRawLegacy + } + e.writeContainerLen(ct, len(s)) + if len(s) > 0 { + e.w.writestr(s) + } +} + +func (e *msgpackEncDriverIO) EncodeStringNoEscape4Json(v string) { e.EncodeString(v) } + +func (e *msgpackEncDriverIO) EncodeStringBytesRaw(bs []byte) { + if e.h.WriteExt { + e.writeContainerLen(msgpackContainerBin, len(bs)) + } else { + e.writeContainerLen(msgpackContainerRawLegacy, len(bs)) + } + if len(bs) > 0 { + e.w.writeb(bs) + } +} + +func (e *msgpackEncDriverIO) EncodeBytes(v []byte) { + if v == nil { + e.writeNilBytes() + return + } + e.EncodeStringBytesRaw(v) +} + +func (e *msgpackEncDriverIO) writeNilOr(v byte) { + if !e.h.NilCollectionToZeroLength { + v = mpNil + } + e.w.writen1(v) +} + +func (e *msgpackEncDriverIO) writeNilArray() { + e.writeNilOr(mpFixArrayMin) +} + +func (e *msgpackEncDriverIO) writeNilMap() { + e.writeNilOr(mpFixMapMin) +} + +func (e *msgpackEncDriverIO) writeNilBytes() { + e.writeNilOr(mpFixStrMin) +} + +func (e *msgpackEncDriverIO) writeContainerLen(ct msgpackContainerType, l int) { + if ct.fixCutoff > 0 && l < int(ct.fixCutoff) { + e.w.writen1(ct.bFixMin | byte(l)) + } else if ct.b8 > 0 && l < 256 { + e.w.writen2(ct.b8, uint8(l)) + } else if l < 65536 { + e.w.writen1(ct.b16) + e.w.writen2(bigen.PutUint16(uint16(l))) + } else { + e.w.writen1(ct.b32) + e.w.writen4(bigen.PutUint32(uint32(l))) + } +} + +func (d *msgpackDecDriverIO) DecodeNaked() { + if !d.bdRead { + d.readNextBd() + } + bd := d.bd + n := d.d.naked() + var decodeFurther bool + + switch bd { + case mpNil: + n.v = valueTypeNil + d.bdRead = false + case mpFalse: + n.v = valueTypeBool + n.b = false + case mpTrue: + n.v = valueTypeBool + n.b = true + + case mpFloat: + n.v = valueTypeFloat + n.f = float64(math.Float32frombits(bigen.Uint32(d.r.readn4()))) + case mpDouble: + n.v = valueTypeFloat + n.f = math.Float64frombits(bigen.Uint64(d.r.readn8())) + + case mpUint8: + n.v = valueTypeUint + n.u = uint64(d.r.readn1()) + case mpUint16: + n.v = valueTypeUint + n.u = uint64(bigen.Uint16(d.r.readn2())) + case mpUint32: + n.v = valueTypeUint + n.u = uint64(bigen.Uint32(d.r.readn4())) + case mpUint64: + n.v = valueTypeUint + n.u = uint64(bigen.Uint64(d.r.readn8())) + + case mpInt8: + n.v = valueTypeInt + n.i = int64(int8(d.r.readn1())) + case mpInt16: + n.v = valueTypeInt + n.i = int64(int16(bigen.Uint16(d.r.readn2()))) + case mpInt32: + n.v = valueTypeInt + n.i = int64(int32(bigen.Uint32(d.r.readn4()))) + case mpInt64: + n.v = valueTypeInt + n.i = int64(int64(bigen.Uint64(d.r.readn8()))) + + default: + switch { + case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax: + + n.v = valueTypeInt + n.i = int64(int8(bd)) + case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax: + + n.v = valueTypeInt + n.i = int64(int8(bd)) + case bd == mpStr8, bd == mpStr16, bd == mpStr32, bd >= mpFixStrMin && bd <= mpFixStrMax: + d.d.fauxUnionReadRawBytes(d, d.h.WriteExt, d.h.RawToString) + + case bd == mpBin8, bd == mpBin16, bd == mpBin32: + d.d.fauxUnionReadRawBytes(d, false, d.h.RawToString) + case bd == mpArray16, bd == mpArray32, bd >= mpFixArrayMin && bd <= mpFixArrayMax: + n.v = valueTypeArray + decodeFurther = true + case bd == mpMap16, bd == mpMap32, bd >= mpFixMapMin && bd <= mpFixMapMax: + n.v = valueTypeMap + decodeFurther = true + case bd >= mpFixExt1 && bd <= mpFixExt16, bd >= mpExt8 && bd <= mpExt32: + n.v = valueTypeExt + clen := d.readExtLen() + n.u = uint64(d.r.readn1()) + if n.u == uint64(mpTimeExtTagU) { + n.v = valueTypeTime + n.t = d.decodeTime(clen) + } else { + n.l = d.r.readx(uint(clen)) + } + default: + halt.errorf("cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd)) + } + } + if !decodeFurther { + d.bdRead = false + } + if n.v == valueTypeUint && d.h.SignedInteger { + n.v = valueTypeInt + n.i = int64(n.u) + } +} + +func (d *msgpackDecDriverIO) nextValueBytes() (v []byte) { + if !d.bdRead { + d.readNextBd() + } + d.r.startRecording() + d.nextValueBytesBdReadR() + v = d.r.stopRecording() + d.bdRead = false + return +} + +func (d *msgpackDecDriverIO) nextValueBytesBdReadR() { + bd := d.bd + + var clen uint + + switch bd { + case mpNil, mpFalse, mpTrue: + case mpUint8, mpInt8: + d.r.readn1() + case mpUint16, mpInt16: + d.r.skip(2) + case mpFloat, mpUint32, mpInt32: + d.r.skip(4) + case mpDouble, mpUint64, mpInt64: + d.r.skip(8) + case mpStr8, mpBin8: + clen = uint(d.r.readn1()) + d.r.skip(clen) + case mpStr16, mpBin16: + x := d.r.readn2() + clen = uint(bigen.Uint16(x)) + d.r.skip(clen) + case mpStr32, mpBin32: + x := d.r.readn4() + clen = uint(bigen.Uint32(x)) + d.r.skip(clen) + case mpFixExt1: + d.r.readn1() + d.r.readn1() + case mpFixExt2: + d.r.readn1() + d.r.skip(2) + case mpFixExt4: + d.r.readn1() + d.r.skip(4) + case mpFixExt8: + d.r.readn1() + d.r.skip(8) + case mpFixExt16: + d.r.readn1() + d.r.skip(16) + case mpExt8: + clen = uint(d.r.readn1()) + d.r.readn1() + d.r.skip(clen) + case mpExt16: + x := d.r.readn2() + clen = uint(bigen.Uint16(x)) + d.r.readn1() + d.r.skip(clen) + case mpExt32: + x := d.r.readn4() + clen = uint(bigen.Uint32(x)) + d.r.readn1() + d.r.skip(clen) + case mpArray16: + x := d.r.readn2() + clen = uint(bigen.Uint16(x)) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + } + case mpArray32: + x := d.r.readn4() + clen = uint(bigen.Uint32(x)) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + } + case mpMap16: + x := d.r.readn2() + clen = uint(bigen.Uint16(x)) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + d.readNextBd() + d.nextValueBytesBdReadR() + } + case mpMap32: + x := d.r.readn4() + clen = uint(bigen.Uint32(x)) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + d.readNextBd() + d.nextValueBytesBdReadR() + } + default: + switch { + case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax: + case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax: + case bd >= mpFixStrMin && bd <= mpFixStrMax: + clen = uint(mpFixStrMin ^ bd) + d.r.skip(clen) + case bd >= mpFixArrayMin && bd <= mpFixArrayMax: + clen = uint(mpFixArrayMin ^ bd) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + } + case bd >= mpFixMapMin && bd <= mpFixMapMax: + clen = uint(mpFixMapMin ^ bd) + for i := uint(0); i < clen; i++ { + d.readNextBd() + d.nextValueBytesBdReadR() + d.readNextBd() + d.nextValueBytesBdReadR() + } + default: + halt.errorf("nextValueBytes: cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd)) + } + } + return +} + +func (d *msgpackDecDriverIO) decFloat4Int32() (f float32) { + fbits := bigen.Uint32(d.r.readn4()) + f = math.Float32frombits(fbits) + if !noFrac32(fbits) { + halt.errorf("assigning integer value from float32 with a fraction: %v", f) + } + return +} + +func (d *msgpackDecDriverIO) decFloat4Int64() (f float64) { + fbits := bigen.Uint64(d.r.readn8()) + f = math.Float64frombits(fbits) + if !noFrac64(fbits) { + halt.errorf("assigning integer value from float64 with a fraction: %v", f) + } + return +} + +func (d *msgpackDecDriverIO) DecodeInt64() (i int64) { + if d.advanceNil() { + return + } + switch d.bd { + case mpUint8: + i = int64(uint64(d.r.readn1())) + case mpUint16: + i = int64(uint64(bigen.Uint16(d.r.readn2()))) + case mpUint32: + i = int64(uint64(bigen.Uint32(d.r.readn4()))) + case mpUint64: + i = int64(bigen.Uint64(d.r.readn8())) + case mpInt8: + i = int64(int8(d.r.readn1())) + case mpInt16: + i = int64(int16(bigen.Uint16(d.r.readn2()))) + case mpInt32: + i = int64(int32(bigen.Uint32(d.r.readn4()))) + case mpInt64: + i = int64(bigen.Uint64(d.r.readn8())) + case mpFloat: + i = int64(d.decFloat4Int32()) + case mpDouble: + i = int64(d.decFloat4Int64()) + default: + switch { + case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax: + i = int64(int8(d.bd)) + case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax: + i = int64(int8(d.bd)) + default: + halt.errorf("cannot decode signed integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd)) + } + } + d.bdRead = false + return +} + +func (d *msgpackDecDriverIO) DecodeUint64() (ui uint64) { + if d.advanceNil() { + return + } + switch d.bd { + case mpUint8: + ui = uint64(d.r.readn1()) + case mpUint16: + ui = uint64(bigen.Uint16(d.r.readn2())) + case mpUint32: + ui = uint64(bigen.Uint32(d.r.readn4())) + case mpUint64: + ui = bigen.Uint64(d.r.readn8()) + case mpInt8: + if i := int64(int8(d.r.readn1())); i >= 0 { + ui = uint64(i) + } else { + halt.errorf("assigning negative signed value: %v, to unsigned type", i) + } + case mpInt16: + if i := int64(int16(bigen.Uint16(d.r.readn2()))); i >= 0 { + ui = uint64(i) + } else { + halt.errorf("assigning negative signed value: %v, to unsigned type", i) + } + case mpInt32: + if i := int64(int32(bigen.Uint32(d.r.readn4()))); i >= 0 { + ui = uint64(i) + } else { + halt.errorf("assigning negative signed value: %v, to unsigned type", i) + } + case mpInt64: + if i := int64(bigen.Uint64(d.r.readn8())); i >= 0 { + ui = uint64(i) + } else { + halt.errorf("assigning negative signed value: %v, to unsigned type", i) + } + case mpFloat: + if f := d.decFloat4Int32(); f >= 0 { + ui = uint64(f) + } else { + halt.errorf("assigning negative float value: %v, to unsigned type", f) + } + case mpDouble: + if f := d.decFloat4Int64(); f >= 0 { + ui = uint64(f) + } else { + halt.errorf("assigning negative float value: %v, to unsigned type", f) + } + default: + switch { + case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax: + ui = uint64(d.bd) + case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax: + halt.errorf("assigning negative signed value: %v, to unsigned type", int(d.bd)) + default: + halt.errorf("cannot decode unsigned integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd)) + } + } + d.bdRead = false + return +} + +func (d *msgpackDecDriverIO) DecodeFloat64() (f float64) { + if d.advanceNil() { + return + } + if d.bd == mpFloat { + f = float64(math.Float32frombits(bigen.Uint32(d.r.readn4()))) + } else if d.bd == mpDouble { + f = math.Float64frombits(bigen.Uint64(d.r.readn8())) + } else { + f = float64(d.DecodeInt64()) + } + d.bdRead = false + return +} + +func (d *msgpackDecDriverIO) DecodeBool() (b bool) { + if d.advanceNil() { + return + } + if d.bd == mpFalse || d.bd == 0 { + + } else if d.bd == mpTrue || d.bd == 1 { + b = true + } else { + halt.errorf("cannot decode bool: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd)) + } + d.bdRead = false + return +} + +func (d *msgpackDecDriverIO) DecodeBytes() (bs []byte, state dBytesAttachState) { + if d.advanceNil() { + return + } + + var cond bool + bd := d.bd + var clen int + if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 { + clen = d.readContainerLen(msgpackContainerBin) + } else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || + (bd >= mpFixStrMin && bd <= mpFixStrMax) { + clen = d.readContainerLen(msgpackContainerStr) + } else if bd == mpArray16 || bd == mpArray32 || + (bd >= mpFixArrayMin && bd <= mpFixArrayMax) { + slen := d.ReadArrayStart() + bs, cond = usableByteSlice(d.d.buf, slen) + for i := 0; i < len(bs); i++ { + bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8)) + } + for i := len(bs); i < slen; i++ { + bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8))) + } + if cond { + d.d.buf = bs + } + state = dBytesAttachBuffer + return + } else { + halt.errorf("invalid byte descriptor for decoding bytes, got: 0x%x", d.bd) + } + + d.bdRead = false + bs, cond = d.r.readxb(uint(clen)) + state = d.d.attachState(cond) + return +} + +func (d *msgpackDecDriverIO) DecodeStringAsBytes() (out []byte, state dBytesAttachState) { + out, state = d.DecodeBytes() + if d.h.ValidateUnicode && !utf8.Valid(out) { + halt.errorf("DecodeStringAsBytes: invalid UTF-8: %s", out) + } + return +} + +func (d *msgpackDecDriverIO) readNextBd() { + d.bd = d.r.readn1() + d.bdRead = true +} + +func (d *msgpackDecDriverIO) advanceNil() (null bool) { + if !d.bdRead { + d.readNextBd() + } + if d.bd == mpNil { + d.bdRead = false + return true + } + return +} + +func (d *msgpackDecDriverIO) TryNil() (v bool) { + return d.advanceNil() +} + +func (d *msgpackDecDriverIO) ContainerType() (vt valueType) { + if !d.bdRead { + d.readNextBd() + } + bd := d.bd + if bd == mpNil { + d.bdRead = false + return valueTypeNil + } else if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 { + return valueTypeBytes + } else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || + (bd >= mpFixStrMin && bd <= mpFixStrMax) { + if d.h.WriteExt || d.h.RawToString { + return valueTypeString + } + return valueTypeBytes + } else if bd == mpArray16 || bd == mpArray32 || (bd >= mpFixArrayMin && bd <= mpFixArrayMax) { + return valueTypeArray + } else if bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) { + return valueTypeMap + } + return valueTypeUnset +} + +func (d *msgpackDecDriverIO) readContainerLen(ct msgpackContainerType) (clen int) { + bd := d.bd + if bd == ct.b8 { + clen = int(d.r.readn1()) + } else if bd == ct.b16 { + clen = int(bigen.Uint16(d.r.readn2())) + } else if bd == ct.b32 { + clen = int(bigen.Uint32(d.r.readn4())) + } else if (ct.bFixMin & bd) == ct.bFixMin { + clen = int(ct.bFixMin ^ bd) + } else { + halt.errorf("cannot read container length: %s: hex: %x, decimal: %d", msgBadDesc, bd, bd) + } + d.bdRead = false + return +} + +func (d *msgpackDecDriverIO) ReadMapStart() int { + if d.advanceNil() { + return containerLenNil + } + return d.readContainerLen(msgpackContainerMap) +} + +func (d *msgpackDecDriverIO) ReadArrayStart() int { + if d.advanceNil() { + return containerLenNil + } + return d.readContainerLen(msgpackContainerList) +} + +func (d *msgpackDecDriverIO) readExtLen() (clen int) { + switch d.bd { + case mpFixExt1: + clen = 1 + case mpFixExt2: + clen = 2 + case mpFixExt4: + clen = 4 + case mpFixExt8: + clen = 8 + case mpFixExt16: + clen = 16 + case mpExt8: + clen = int(d.r.readn1()) + case mpExt16: + clen = int(bigen.Uint16(d.r.readn2())) + case mpExt32: + clen = int(bigen.Uint32(d.r.readn4())) + default: + halt.errorf("decoding ext bytes: found unexpected byte: %x", d.bd) + } + return +} + +func (d *msgpackDecDriverIO) DecodeTime() (t time.Time) { + + if d.advanceNil() { + return + } + bd := d.bd + var clen int + if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 { + clen = d.readContainerLen(msgpackContainerBin) + } else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || + (bd >= mpFixStrMin && bd <= mpFixStrMax) { + clen = d.readContainerLen(msgpackContainerStr) + } else { + + d.bdRead = false + b2 := d.r.readn1() + if d.bd == mpFixExt4 && b2 == mpTimeExtTagU { + clen = 4 + } else if d.bd == mpFixExt8 && b2 == mpTimeExtTagU { + clen = 8 + } else if d.bd == mpExt8 && b2 == 12 && d.r.readn1() == mpTimeExtTagU { + clen = 12 + } else { + halt.errorf("invalid stream for decoding time as extension: got 0x%x, 0x%x", d.bd, b2) + } + } + return d.decodeTime(clen) +} + +func (d *msgpackDecDriverIO) decodeTime(clen int) (t time.Time) { + d.bdRead = false + switch clen { + case 4: + t = time.Unix(int64(bigen.Uint32(d.r.readn4())), 0).UTC() + case 8: + tv := bigen.Uint64(d.r.readn8()) + t = time.Unix(int64(tv&0x00000003ffffffff), int64(tv>>34)).UTC() + case 12: + nsec := bigen.Uint32(d.r.readn4()) + sec := bigen.Uint64(d.r.readn8()) + t = time.Unix(int64(sec), int64(nsec)).UTC() + default: + halt.errorf("invalid length of bytes for decoding time - expecting 4 or 8 or 12, got %d", clen) + } + return +} + +func (d *msgpackDecDriverIO) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) { + xbs, _, _, ok := d.decodeExtV(ext != nil, xtag) + if !ok { + return + } + if ext == SelfExt { + sideDecode(d.h, &d.h.sideDecPool, func(sd decoderI) { oneOffDecode(sd, rv, xbs, basetype, true) }) + } else { + ext.ReadExt(rv, xbs) + } +} + +func (d *msgpackDecDriverIO) DecodeRawExt(re *RawExt) { + xbs, realxtag, state, ok := d.decodeExtV(false, 0) + if !ok { + return + } + re.Tag = uint64(realxtag) + re.setData(xbs, state >= dBytesAttachViewZerocopy) +} + +func (d *msgpackDecDriverIO) decodeExtV(verifyTag bool, xtagIn uint64) (xbs []byte, xtag byte, bstate dBytesAttachState, ok bool) { + if xtagIn > 0xff { + halt.errorf("ext: tag must be <= 0xff; got: %v", xtagIn) + } + if d.advanceNil() { + return + } + tag := uint8(xtagIn) + xbd := d.bd + if xbd == mpBin8 || xbd == mpBin16 || xbd == mpBin32 { + xbs, bstate = d.DecodeBytes() + } else if xbd == mpStr8 || xbd == mpStr16 || xbd == mpStr32 || + (xbd >= mpFixStrMin && xbd <= mpFixStrMax) { + xbs, bstate = d.DecodeStringAsBytes() + } else { + clen := d.readExtLen() + xtag = d.r.readn1() + if verifyTag && xtag != tag { + halt.errorf("wrong extension tag - got %b, expecting %v", xtag, tag) + } + xbs, ok = d.r.readxb(uint(clen)) + bstate = d.d.attachState(ok) + + } + d.bdRead = false + ok = true + return +} + +func (d *msgpackEncDriverIO) init(hh Handle, shared *encoderBase, enc encoderI) (fp interface{}) { + callMake(&d.w) + d.h = hh.(*MsgpackHandle) + d.e = shared + if shared.bytes { + fp = msgpackFpEncBytes + } else { + fp = msgpackFpEncIO + } + + d.init2(enc) + return +} + +func (e *msgpackEncDriverIO) writeBytesAsis(b []byte) { e.w.writeb(b) } + +func (e *msgpackEncDriverIO) writerEnd() { e.w.end() } + +func (e *msgpackEncDriverIO) resetOutBytes(out *[]byte) { + e.w.resetBytes(*out, out) +} + +func (e *msgpackEncDriverIO) resetOutIO(out io.Writer) { + e.w.resetIO(out, e.h.WriterBufferSize, &e.e.blist) +} + +func (d *msgpackDecDriverIO) init(hh Handle, shared *decoderBase, dec decoderI) (fp interface{}) { + callMake(&d.r) + d.h = hh.(*MsgpackHandle) + d.d = shared + if shared.bytes { + fp = msgpackFpDecBytes + } else { + fp = msgpackFpDecIO + } + + d.init2(dec) + return +} + +func (d *msgpackDecDriverIO) NumBytesRead() int { + return int(d.r.numread()) +} + +func (d *msgpackDecDriverIO) resetInBytes(in []byte) { + d.r.resetBytes(in) +} + +func (d *msgpackDecDriverIO) resetInIO(r io.Reader) { + d.r.resetIO(r, d.h.ReaderBufferSize, d.h.MaxInitLen, &d.d.blist) +} + +func (d *msgpackDecDriverIO) descBd() string { + return sprintf("%v (%s)", d.bd, mpdesc(d.bd)) +} + +func (d *msgpackDecDriverIO) DecodeFloat32() (f float32) { + return float32(chkOvf.Float32V(d.DecodeFloat64())) +} |