summaryrefslogtreecommitdiff
path: root/vendor/github.com/ugorji/go/codec/encode.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/ugorji/go/codec/encode.go')
-rw-r--r--vendor/github.com/ugorji/go/codec/encode.go1652
1 files changed, 0 insertions, 1652 deletions
diff --git a/vendor/github.com/ugorji/go/codec/encode.go b/vendor/github.com/ugorji/go/codec/encode.go
deleted file mode 100644
index b203036b4..000000000
--- a/vendor/github.com/ugorji/go/codec/encode.go
+++ /dev/null
@@ -1,1652 +0,0 @@
-//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"
- "reflect"
- "slices"
- "sort"
- "strconv"
- "sync"
- "time"
-)
-
-type helperEncDriver[T encDriver] struct{}
-
-// encFn encapsulates the captured variables and the encode function.
-// This way, we only do some calculations one times, and pass to the
-// code block that should be called (encapsulated in a function)
-// instead of executing the checks every time.
-type encFn[T encDriver] struct {
- i encFnInfo
- fe func(*encoder[T], *encFnInfo, reflect.Value)
- // _ [1]uint64 // padding (cache-aligned)
-}
-
-type encRtidFn[T encDriver] struct {
- rtid uintptr
- fn *encFn[T]
-}
-
-// Encoder writes an object to an output stream in a supported format.
-//
-// Encoder is NOT safe for concurrent use i.e. a Encoder cannot be used
-// concurrently in multiple goroutines.
-//
-// However, as Encoder could be allocation heavy to initialize, a Reset method is provided
-// so its state can be reused to decode new input streams repeatedly.
-// This is the idiomatic way to use.
-type encoder[T encDriver] struct {
- dh helperEncDriver[T]
- fp *fastpathEs[T]
- e T
- encoderBase
-}
-
-func (e *encoder[T]) rawExt(_ *encFnInfo, rv reflect.Value) {
- if re := rv2i(rv).(*RawExt); re == nil {
- e.e.EncodeNil()
- } else {
- e.e.EncodeRawExt(re)
- }
-}
-
-func (e *encoder[T]) ext(f *encFnInfo, rv reflect.Value) {
- e.e.EncodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn)
-}
-
-func (e *encoder[T]) selferMarshal(_ *encFnInfo, rv reflect.Value) {
- rv2i(rv).(Selfer).CodecEncodeSelf(&Encoder{e})
-}
-
-func (e *encoder[T]) binaryMarshal(_ *encFnInfo, rv reflect.Value) {
- bs, fnerr := rv2i(rv).(encoding.BinaryMarshaler).MarshalBinary()
- e.marshalRaw(bs, fnerr)
-}
-
-func (e *encoder[T]) textMarshal(_ *encFnInfo, rv reflect.Value) {
- bs, fnerr := rv2i(rv).(encoding.TextMarshaler).MarshalText()
- e.marshalUtf8(bs, fnerr)
-}
-
-func (e *encoder[T]) jsonMarshal(_ *encFnInfo, rv reflect.Value) {
- bs, fnerr := rv2i(rv).(jsonMarshaler).MarshalJSON()
- e.marshalAsis(bs, fnerr)
-}
-
-func (e *encoder[T]) raw(_ *encFnInfo, rv reflect.Value) {
- e.rawBytes(rv2i(rv).(Raw))
-}
-
-func (e *encoder[T]) 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 *encoder[T]) 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 *encoder[T]) kBool(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeBool(rvGetBool(rv))
-}
-
-func (e *encoder[T]) kTime(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeTime(rvGetTime(rv))
-}
-
-func (e *encoder[T]) kString(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeString(rvGetString(rv))
-}
-
-func (e *encoder[T]) kFloat32(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeFloat32(rvGetFloat32(rv))
-}
-
-func (e *encoder[T]) kFloat64(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeFloat64(rvGetFloat64(rv))
-}
-
-func (e *encoder[T]) kComplex64(_ *encFnInfo, rv reflect.Value) {
- e.encodeComplex64(rvGetComplex64(rv))
-}
-
-func (e *encoder[T]) kComplex128(_ *encFnInfo, rv reflect.Value) {
- e.encodeComplex128(rvGetComplex128(rv))
-}
-
-func (e *encoder[T]) kInt(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeInt(int64(rvGetInt(rv)))
-}
-
-func (e *encoder[T]) kInt8(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeInt(int64(rvGetInt8(rv)))
-}
-
-func (e *encoder[T]) kInt16(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeInt(int64(rvGetInt16(rv)))
-}
-
-func (e *encoder[T]) kInt32(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeInt(int64(rvGetInt32(rv)))
-}
-
-func (e *encoder[T]) kInt64(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeInt(int64(rvGetInt64(rv)))
-}
-
-func (e *encoder[T]) kUint(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUint(rv)))
-}
-
-func (e *encoder[T]) kUint8(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUint8(rv)))
-}
-
-func (e *encoder[T]) kUint16(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUint16(rv)))
-}
-
-func (e *encoder[T]) kUint32(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUint32(rv)))
-}
-
-func (e *encoder[T]) kUint64(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUint64(rv)))
-}
-
-func (e *encoder[T]) kUintptr(_ *encFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUintptr(rv)))
-}
-
-func (e *encoder[T]) kSeqFn(rt reflect.Type) (fn *encFn[T]) {
- // if kind is reflect.Interface, do not pre-determine the encoding type,
- // because preEncodeValue may break it down to a concrete type and kInterface will bomb.
- if rt = baseRT(rt); rt.Kind() != reflect.Interface {
- fn = e.fn(rt)
- }
- return
-}
-
-func (e *encoder[T]) 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) // e.mapStart(l / 2)
-
- var fn *encFn[T]
- builtin := ti.tielem.flagEncBuiltin
- if !builtin {
- fn = e.kSeqFn(ti.elem)
- }
-
- // simulate do...while, since we already handled case of 0-length
- 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 { // j%2 == 0 {
- e.c = containerMapKey
- e.e.WriteMapElemKey(false)
- } else {
- e.mapElemValue()
- }
- }
- e.c = 0
- e.e.WriteMapEnd()
-
- // for j := 0; j < l; j++ {
- // if j&1 == 0 { // j%2 == 0 {
- // e.mapElemKey(j == 0)
- // } else {
- // e.mapElemValue()
- // }
- // rvv := rvSliceIndex(rv, j, ti)
- // if builtin {
- // e.encode(rv2i(baseRVRV(rvv)))
- // } else {
- // e.encodeValue(rvv, fn)
- // }
- // }
- // e.mapEnd()
-}
-
-func (e *encoder[T]) 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 *encFn[T]
- 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)
- }
-
- // if ti.tielem.flagEncBuiltin {
- // for j := 0; j < l; j++ {
- // e.arrayElem()
- // e.encode(rv2i(baseRVRV(rIndex(rv, j, ti))))
- // }
- // } else {
- // fn := e.kSeqFn(ti.elem)
- // for j := 0; j < l; j++ {
- // e.arrayElem()
- // e.encodeValue(rvArrayIndex(rv, j, ti), fn)
- // }
- // }
-
- e.c = 0
- e.e.WriteArrayEnd()
-}
-
-func (e *encoder[T]) 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 *encoder[T]) 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) {
- // 'uint8TypId == rt2id(f.ti.elem)' checks types having underlying []byte
- e.e.EncodeBytes(rvGetBytes(rv))
- } else {
- e.kArrayW(rv, f.ti, true)
- }
-}
-
-func (e *encoder[T]) 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)) // bytes from array never nil
- } else {
- e.kArrayW(rv, f.ti, false)
- }
-}
-
-func (e *encoder[T]) kSliceBytesChan(rv reflect.Value) {
- // do not use range, so that the number of elements encoded
- // does not change, and encoding does not hang waiting on someone to close chan.
-
- 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: // only consume available
- for {
- select {
- case b := <-ch:
- bs = append(bs, b)
- default:
- break L1
- }
- }
- case timeout > 0: // consume until timeout
- tt := time.NewTimer(timeout)
- for {
- select {
- case b := <-ch:
- bs = append(bs, b)
- case <-tt.C:
- // close(tt.C)
- break L1
- }
- }
- default: // consume until close
- 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 *encoder[T]) kStructFieldKey(keyType valueType, encName string) {
- // use if (not switch) block, so that branch prediction picks valueTypeString first
- 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())
- }
- // e.dh.encStructFieldKey(e.e, encName, keyType, encNameAsciiAlphaNum, e.js)
-}
-
-func (e *encoder[T]) kStructSimple(f *encFnInfo, rv reflect.Value) {
- _ = e.e // early asserts e, e.e are not nil once
- tisfi := f.ti.sfi.source()
-
- // To bypass encodeValue, we need to handle cases where
- // the field is an interface kind. To do this, we need to handle an
- // interface or a pointer to an interface differently.
- //
- // Easiest to just delegate to encodeValue.
-
- chkCirRef := e.h.CheckCircularRef
- var si *structFieldInfo
- var j int
- // use value of chkCirRef ie if true, then send the addr of the value
- if f.ti.toArray || e.h.StructToArray { // toArray
- 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 *encoder[T]) kStruct(f *encFnInfo, rv reflect.Value) {
- _ = e.e // early asserts e, e.e are not nil once
- 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 {
- // kv.r = si.path.field(rv, false, si.encBuiltin || !chkCirRef)
- // if si.omitEmpty && isEmptyValue(kv.r, e.h.TypeInfos, recur) {
- // continue
- // }
- if si.omitEmpty {
- kv.r = si.fieldNoAlloc(rv, false) // test actual field val
- 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)
-
- // When there are missing fields, and Canonical flag is set,
- // we cannot have the missing fields and struct fields sorted independently.
- // We have to capture them together and sort as a unit.
-
- 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))
- }
- //e.encodeI(sf.intf) // MARKER inlined
- }
- }
- } 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))
- }
- // e.encodeI(v.i) // MARKER inlined
- j++
- }
- }
-
- e.c = 0
- e.e.WriteMapEnd()
- } else {
- newlen = len(tisfi)
- for i, si := range tisfi { // use unsorted array (to match sequence in struct)
- // kv.r = si.path.field(rv, false, si.encBuiltin || !chkCirRef)
- // kv.r = si.path.field(rv, false, !si.omitEmpty || si.encBuiltin || !chkCirRef)
- if si.omitEmpty {
- // use the zero value.
- // if a reference or struct, set to nil (so you do not output too much)
- kv.r = si.fieldNoAlloc(rv, false) // test actual field val
- if isEmptyContainerValue(kv.r, e.h.TypeInfos, recur) {
- kv.r = reflect.Value{} //encode as nil
- }
- } else {
- kv.r = si.fieldNoAlloc(rv, si.encBuiltin || !chkCirRef)
- }
- kv.v = si
- fkvs[i] = kv
- }
-
- if newlen == 0 {
- e.e.WriteArrayEmpty()
- goto END
- }
-
- // encode it all
- 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:
- // do not use defer. Instead, use explicit pool return at end of function.
- // defer has a cost we are trying to avoid.
- // If there is a panic and these slices are not returned, it is ok.
- e.slist.put(fkvs)
-}
-
-func (e *encoder[T]) kMap(f *encFnInfo, rv reflect.Value) {
- _ = e.e // early asserts e, e.e are not nil once
- l := rvLenMap(rv)
- if l == 0 {
- e.e.WriteMapEmpty()
- return
- }
- e.mapStart(l)
-
- // determine the underlying key and val encFn's for the map.
- // This eliminates some work which is done for each loop iteration i.e.
- // rv.Type(), ref.ValueOf(rt).Pointer(), then check map/list for fn.
- //
- // However, if kind is reflect.Interface, do not pre-determine the
- // encoding type, because preEncodeValue may break it down to
- // a concrete type and kInterface will bomb.
-
- var keyFn, valFn *encFn[T]
-
- 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) // rtkeyid
- 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 *encoder[T]) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, keyFn, valFn *encFn[T]) {
- _ = e.e // early asserts e, e.e are not nil once
- // The base kind of the type of the map key is sufficient for ordering.
- // We only do out of band if that kind is not ordered (number or string), bool or time.Time.
- // If the key is a predeclared type, directly call methods on encDriver e.g. EncodeString
- // but if not, call encodeValue, in case it has an extension registered or otherwise.
- rtkey := ti.key
- rtkeydecl := rtkey.PkgPath() == "" && rtkey.Name() != "" // key type is predeclared
-
- mks := rv.MapKeys()
- rtkeyKind := rtkey.Kind()
- mparams := getMapReqParams(ti)
-
- // kfast := mapKeyFastKindFor(rtkeyKind)
- // visindirect := mapStoresElemIndirect(uintptr(ti.elemsize))
- // visref := refBitset.isset(ti.elemkind)
-
- switch rtkeyKind {
- case reflect.Bool:
- // though bool keys make no sense in a map, it *could* happen.
- // in that case, we MUST support it in reflection mode,
- // as that is the fallback for even codecgen and others.
-
- // sort the keys so that false comes before true
- // ie if 2 keys in order (true, false), then swap them
- 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
- }
-
- // out-of-band
- // first encode each key to a []byte first, then sort them, then record
- 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 *encoder[T]) init(h Handle) {
- initHandle(h)
- callMake(&e.e)
- e.hh = h
- e.h = h.getBasicHandle()
- // e.be = e.hh.isBinary()
- e.err = errEncoderNotInitialized
-
- // e.fp = fastpathEList[T]()
- e.fp = e.e.init(h, &e.encoderBase, e).(*fastpathEs[T])
-
- 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 *encoder[T]) 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
-}
-
-// Encode writes an object into a stream.
-//
-// Encoding can be configured via the struct tag for the fields.
-// The key (in the struct tags) that we look at is configurable.
-//
-// By default, we look up the "codec" key in the struct field's tags,
-// and fall bak to the "json" key if "codec" is absent.
-// That key in struct field's tag value is the key name,
-// followed by an optional comma and options.
-//
-// To set an option on all fields (e.g. omitempty on all fields), you
-// can create a field called _struct, and set flags on it. The options
-// which can be set on _struct are:
-// - omitempty: so all fields are omitted if empty
-// - toarray: so struct is encoded as an array
-// - int: so struct key names are encoded as signed integers (instead of strings)
-// - uint: so struct key names are encoded as unsigned integers (instead of strings)
-// - float: so struct key names are encoded as floats (instead of strings)
-//
-// More details on these below.
-//
-// Struct values "usually" encode as maps. Each exported struct field is encoded unless:
-// - the field's tag is "-", OR
-// - the field is empty (empty or the zero value) and its tag specifies the "omitempty" option.
-//
-// When encoding as a map, the first string in the tag (before the comma)
-// is the map key string to use when encoding.
-// ...
-// This key is typically encoded as a string.
-// However, there are instances where the encoded stream has mapping keys encoded as numbers.
-// For example, some cbor streams have keys as integer codes in the stream, but they should map
-// to fields in a structured object. Consequently, a struct is the natural representation in code.
-// For these, configure the struct to encode/decode the keys as numbers (instead of string).
-// This is done with the int,uint or float option on the _struct field (see above).
-//
-// However, struct values may encode as arrays. This happens when:
-// - StructToArray Encode option is set, OR
-// - the tag on the _struct field sets the "toarray" option
-//
-// Note that omitempty is ignored when encoding struct values as arrays,
-// as an entry must be encoded for each field, to maintain its position.
-//
-// Values with types that implement MapBySlice are encoded as stream maps.
-//
-// The empty values (for omitempty option) are false, 0, any nil pointer
-// or interface value, and any array, slice, map, or string of length zero.
-//
-// Anonymous fields are encoded inline except:
-// - the struct tag specifies a replacement name (first value)
-// - the field is of an interface type
-//
-// Examples:
-//
-// // NOTE: 'json:' can be used as struct tag key, in place 'codec:' below.
-// type MyStruct struct {
-// _struct bool `codec:",omitempty"` //set omitempty for every field
-// Field1 string `codec:"-"` //skip this field
-// Field2 int `codec:"myName"` //Use key "myName" in encode stream
-// Field3 int32 `codec:",omitempty"` //use key "Field3". Omit if empty.
-// Field4 bool `codec:"f4,omitempty"` //use key "f4". Omit if empty.
-// io.Reader //use key "Reader".
-// MyStruct `codec:"my1" //use key "my1".
-// MyStruct //inline it
-// ...
-// }
-//
-// type MyStruct struct {
-// _struct bool `codec:",toarray"` //encode struct as an array
-// }
-//
-// type MyStruct struct {
-// _struct bool `codec:",uint"` //encode struct with "unsigned integer" keys
-// Field1 string `codec:"1"` //encode Field1 key using: EncodeInt(1)
-// Field2 string `codec:"2"` //encode Field2 key using: EncodeInt(2)
-// }
-//
-// The mode of encoding is based on the type of the value. When a value is seen:
-// - If a Selfer, call its CodecEncodeSelf method
-// - If an extension is registered for it, call that extension function
-// - If implements encoding.(Binary|Text|JSON)Marshaler, call Marshal(Binary|Text|JSON) method
-// - Else encode it based on its reflect.Kind
-//
-// Note that struct field names and keys in map[string]XXX will be treated as symbols.
-// Some formats support symbols (e.g. binc) and will properly encode the string
-// only once in the stream, and use a tag to refer to it thereafter.
-//
-// Note that an error from an Encode call will make the Encoder unusable moving forward.
-// This is because the state of the Encoder, it's output stream, etc are no longer stable.
-// Any subsequent calls to Encode will trigger the same error.
-func (e *encoder[T]) Encode(v interface{}) (err error) {
- // tried to use closure, as runtime optimizes defer with no params.
- // This seemed to be causing weird issues (like circular reference found, unexpected panic, etc).
- // Also, see https://github.com/golang/go/issues/14939#issuecomment-417836139
- defer panicValToErr(e, callRecoverSentinel, &e.err, &err, debugging)
- e.mustEncode(v)
- return
-}
-
-// MustEncode is like Encode, but panics if unable to Encode.
-//
-// Note: This provides insight to the code location that triggered the error.
-//
-// Note that an error from an Encode call will make the Encoder unusable moving forward.
-// This is because the state of the Encoder, it's output stream, etc are no longer stable.
-// Any subsequent calls to Encode will trigger the same error.
-func (e *encoder[T]) MustEncode(v interface{}) {
- defer panicValToErr(e, callRecoverSentinel, &e.err, nil, true)
- e.mustEncode(v)
- return
-}
-
-func (e *encoder[T]) 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.encodeI(v) // MARKER inlined
- e.calls--
- if e.calls == 0 {
- e.e.atEndOfEncode()
- e.e.writerEnd()
- }
-}
-
-func (e *encoder[T]) encodeI(iv interface{}) {
- if !e.encodeBuiltin(iv) {
- e.encodeR(reflect.ValueOf(iv))
- }
-}
-
-func (e *encoder[T]) encodeIB(iv interface{}) {
- if !e.encodeBuiltin(iv) {
- // panic("invalid type passed to encodeBuiltin")
- // halt.errorf("invalid type passed to encodeBuiltin: %T", iv)
- // MARKER: calling halt.errorf pulls in fmt.Sprintf/Errorf which makes this non-inlineable
- halt.errorStr("[should not happen] invalid type passed to encodeBuiltin")
- }
-}
-
-func (e *encoder[T]) encodeR(base reflect.Value) {
- e.encodeValue(base, nil)
-}
-
-func (e *encoder[T]) encodeBuiltin(iv interface{}) (ok bool) {
- ok = true
- switch v := iv.(type) {
- case nil:
- e.e.EncodeNil()
- // case Selfer:
- 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) // e.e.EncodeStringBytesRaw(v)
- default:
- // we can't check non-predefined types, as they might be a Selfer or extension.
- ok = !skipFastpathTypeSwitchInDirectCall && e.dh.fastpathEncodeTypeSwitch(iv, e)
- }
- return
-}
-
-// encodeValue will encode a value.
-//
-// Note that encodeValue will handle nil in the stream early, so that the
-// subsequent calls i.e. kXXX methods, etc do not have to handle it themselves.
-func (e *encoder[T]) encodeValue(rv reflect.Value, fn *encFn[T]) {
- // MARKER: We check if value is nil here, so that the kXXX method do not have to.
- // if a valid fn is passed, it MUST BE for the dereferenced type of rv
-
- var ciPushes int
- // if e.h.CheckCircularRef {
- // ciPushes = e.ci.pushRV(rv)
- // }
-
- 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()
- // fn = nil // underlying type still same - no change
- 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 // underlying type may change, so prompt a reset
- 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 { // typically, addrE = false, so check it first
- // keep rv same
- } 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 *encoder[T]) encodeValueNonNil(rv reflect.Value, fn *encFn[T]) {
- // only call this if a primitive (number, bool, string) OR
- // a non-nil collection (map/slice/chan).
- //
- // Expects fn to be non-nil
- if fn.i.addrE { // typically, addrE = false, so check it first
- 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 *encoder[T]) 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 *encoder[T]) marshalUtf8(bs []byte, fnerr error) {
- halt.onerror(fnerr)
- if bs == nil {
- e.e.EncodeNil()
- } else {
- e.e.EncodeString(stringView(bs))
- }
-}
-
-func (e *encoder[T]) marshalAsis(bs []byte, fnerr error) {
- halt.onerror(fnerr)
- if bs == nil {
- e.e.EncodeNil()
- } else {
- e.e.writeBytesAsis(bs) // e.asis(bs)
- }
-}
-
-func (e *encoder[T]) marshalRaw(bs []byte, fnerr error) {
- halt.onerror(fnerr)
- e.e.EncodeBytes(bs)
-}
-
-func (e *encoder[T]) rawBytes(vv Raw) {
- v := []byte(vv)
- if !e.h.Raw {
- halt.errorBytes("Raw values cannot be encoded: ", v)
- }
- e.e.writeBytesAsis(v)
-}
-
-func (e *encoder[T]) fn(t reflect.Type) *encFn[T] {
- return e.dh.encFnViaBH(t, e.rtidFn, e.h, e.fp, false)
-}
-
-func (e *encoder[T]) fnNoExt(t reflect.Type) *encFn[T] {
- return e.dh.encFnViaBH(t, e.rtidFnNoExt, e.h, e.fp, true)
-}
-
-// ---- container tracker methods
-// Note: We update the .c after calling the callback.
-//
-// Callbacks ie Write(Map|Array)XXX should not use the containerState.
-// It is there for post-callback use.
-// Instead, callbacks have a parameter to tell if first time or not.
-//
-// Some code is commented out below, as they are manually inlined.
-// Commented code is retained here for convernience.
-
-func (e *encoder[T]) mapStart(length int) {
- e.e.WriteMapStart(length)
- e.c = containerMapStart
-}
-
-// func (e *encoder[T]) mapElemKey(firstTime bool) {
-// e.e.WriteMapElemKey(firstTime)
-// e.c = containerMapKey
-// }
-
-func (e *encoder[T]) mapElemValue() {
- e.e.WriteMapElemValue()
- e.c = containerMapValue
-}
-
-// func (e *encoder[T]) mapEnd() {
-// e.e.WriteMapEnd()
-// e.c = 0
-// }
-
-func (e *encoder[T]) arrayStart(length int) {
- e.e.WriteArrayStart(length)
- e.c = containerArrayStart
-}
-
-// func (e *encoder[T]) arrayElem(firstTime bool) {
-// e.e.WriteArrayElem(firstTime)
-// e.c = containerArrayElem
-// }
-
-// func (e *encoder[T]) arrayEnd() {
-// e.e.WriteArrayEnd()
-// e.c = 0
-// }
-
-// ----------
-
-func (e *encoder[T]) writerEnd() {
- e.e.writerEnd()
-}
-
-func (e *encoder[T]) atEndOfEncode() {
- e.e.atEndOfEncode()
-}
-
-// Reset resets the Encoder with a new output stream.
-//
-// This accommodates using the state of the Encoder,
-// where it has "cached" information about sub-engines.
-func (e *encoder[T]) Reset(w io.Writer) {
- if e.bytes {
- halt.onerror(errEncNoResetBytesWithWriter)
- }
- e.reset()
- if w == nil {
- w = io.Discard
- }
- e.e.resetOutIO(w)
-}
-
-// ResetBytes resets the Encoder with a new destination output []byte.
-func (e *encoder[T]) ResetBytes(out *[]byte) {
- if !e.bytes {
- halt.onerror(errEncNoResetWriterWithBytes)
- }
- e.resetBytes(out)
-}
-
-// only call this iff you are sure it is a bytes encoder
-func (e *encoder[T]) resetBytes(out *[]byte) {
- e.reset()
- if out == nil {
- out = &bytesEncAppenderDefOut
- }
- e.e.resetOutBytes(out)
-}
-
-// ----
-
-func (helperEncDriver[T]) newEncoderBytes(out *[]byte, h Handle) *encoder[T] {
- var c1 encoder[T]
- c1.bytes = true
- c1.init(h)
- c1.ResetBytes(out)
- return &c1
-}
-
-func (helperEncDriver[T]) newEncoderIO(out io.Writer, h Handle) *encoder[T] {
- var c1 encoder[T]
- c1.bytes = false
- c1.init(h)
- c1.Reset(out)
- return &c1
-}
-
-func (helperEncDriver[T]) encFnloadFastpathUnderlying(ti *typeInfo, fp *fastpathEs[T]) (f *fastpathE[T], 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 (helperEncDriver[T]) encFindRtidFn(s []encRtidFn[T], rtid uintptr) (i uint, fn *encFn[T]) {
- // binary search. Adapted from sort/search.go. Use goto (not for loop) to allow inlining.
- var h uint // var h, i uint
- var j = uint(len(s))
-LOOP:
- if i < j {
- h = (i + j) >> 1 // avoid overflow when computing h // h = i + (j-i)/2
- 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 (helperEncDriver[T]) encFromRtidFnSlice(fns *atomicRtidFnSlice) (s []encRtidFn[T]) {
- if v := fns.load(); v != nil {
- s = *(lowLevelToPtr[[]encRtidFn[T]](v))
- }
- return
-}
-
-func (dh helperEncDriver[T]) encFnViaBH(rt reflect.Type, fns *atomicRtidFnSlice,
- x *BasicHandle, fp *fastpathEs[T], checkExt bool) (fn *encFn[T]) {
- return dh.encFnVia(rt, fns, x.typeInfos(), &x.mu, x.extHandle, fp,
- checkExt, x.CheckCircularRef, x.timeBuiltin, x.binaryHandle, x.jsonHandle)
-}
-
-func (dh helperEncDriver[T]) encFnVia(rt reflect.Type, fns *atomicRtidFnSlice,
- tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathEs[T],
- checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFn[T]) {
- rtid := rt2id(rt)
- var sp []encRtidFn[T] = 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 helperEncDriver[T]) encFnViaLoader(rt reflect.Type, rtid uintptr, fns *atomicRtidFnSlice,
- tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathEs[T],
- checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFn[T]) {
-
- fn = dh.encFnLoad(rt, rtid, tinfos, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json)
- var sp []encRtidFn[T]
- mu.Lock()
- sp = dh.encFromRtidFnSlice(fns)
- // since this is an atomic load/store, we MUST use a different array each time,
- // else we have a data race when a store is happening simultaneously with a encFindRtidFn call.
- if sp == nil {
- sp = []encRtidFn[T]{{rtid, fn}}
- fns.store(ptrToLowLevel(&sp))
- } else {
- idx, fn2 := dh.encFindRtidFn(sp, rtid)
- if fn2 == nil {
- sp2 := make([]encRtidFn[T], len(sp)+1)
- copy(sp2[idx+1:], sp[idx:])
- copy(sp2, sp[:idx])
- sp2[idx] = encRtidFn[T]{rtid, fn}
- fns.store(ptrToLowLevel(&sp2))
- }
- }
- mu.Unlock()
- return
-}
-
-func (dh helperEncDriver[T]) encFnLoad(rt reflect.Type, rtid uintptr, tinfos *TypeInfos,
- exth extHandle, fp *fastpathEs[T],
- checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFn[T]) {
- fn = new(encFn[T])
- fi := &(fn.i)
- ti := tinfos.get(rtid, rt)
- fi.ti = ti
- rk := reflect.Kind(ti.kind)
-
- // anything can be an extension except the built-in ones: time, raw and rawext.
- // ensure we check for these types, then if extension, before checking if
- // it implementes one of the pre-declared interfaces.
-
- // fi.addrEf = true
-
- if rtid == timeTypId && timeBuiltin {
- fn.fe = (*encoder[T]).kTime
- } else if rtid == rawTypId {
- fn.fe = (*encoder[T]).raw
- } else if rtid == rawExtTypId {
- fn.fe = (*encoder[T]).rawExt
- fi.addrE = true
- } else if xfFn := exth.getExt(rtid, checkExt); xfFn != nil {
- fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
- fn.fe = (*encoder[T]).ext
- if rk == reflect.Struct || rk == reflect.Array {
- fi.addrE = true
- }
- } else if ti.flagSelfer || ti.flagSelferPtr {
- fn.fe = (*encoder[T]).selferMarshal
- fi.addrE = ti.flagSelferPtr
- } else if supportMarshalInterfaces && binaryEncoding &&
- (ti.flagBinaryMarshaler || ti.flagBinaryMarshalerPtr) &&
- (ti.flagBinaryUnmarshaler || ti.flagBinaryUnmarshalerPtr) {
- fn.fe = (*encoder[T]).binaryMarshal
- fi.addrE = ti.flagBinaryMarshalerPtr
- } else if supportMarshalInterfaces && !binaryEncoding && json &&
- (ti.flagJsonMarshaler || ti.flagJsonMarshalerPtr) &&
- (ti.flagJsonUnmarshaler || ti.flagJsonUnmarshalerPtr) {
- //If JSON, we should check JSONMarshal before textMarshal
- fn.fe = (*encoder[T]).jsonMarshal
- fi.addrE = ti.flagJsonMarshalerPtr
- } else if supportMarshalInterfaces && !binaryEncoding &&
- (ti.flagTextMarshaler || ti.flagTextMarshalerPtr) &&
- (ti.flagTextUnmarshaler || ti.flagTextUnmarshalerPtr) {
- fn.fe = (*encoder[T]).textMarshal
- fi.addrE = ti.flagTextMarshalerPtr
- } else {
- if fastpathEnabled && (rk == reflect.Map || rk == reflect.Slice || rk == reflect.Array) {
- // by default (without using unsafe),
- // if an array is not addressable, converting from an array to a slice
- // requires an allocation (see helper_not_unsafe.go: func rvGetSlice4Array).
- //
- // (Non-addressable arrays mostly occur as keys/values from a map).
- //
- // However, fastpath functions are mostly for slices of numbers or strings,
- // which are small by definition and thus allocation should be fast/cheap in time.
- //
- // Consequently, the value of doing this quick allocation to elide the overhead cost of
- // non-optimized (not-unsafe) reflection is a fair price.
- var rtid2 uintptr
- if !ti.flagHasPkgPath { // un-named type (slice or mpa or array)
- rtid2 = rtid
- if rk == reflect.Array {
- rtid2 = rt2id(ti.key) // ti.key for arrays = reflect.SliceOf(ti.elem)
- }
- if idx, ok := fastpathAvIndex(rtid2); ok {
- fn.fe = fp[idx].encfn
- }
- } else { // named type (with underlying type of map or slice or array)
- // try to use mapping for underlying type
- xfe, xrt := dh.encFnloadFastpathUnderlying(ti, fp)
- if xfe != nil {
- xfnf := xfe.encfn
- fn.fe = func(e *encoder[T], xf *encFnInfo, xrv reflect.Value) {
- xfnf(e, xf, rvConvert(xrv, xrt))
- }
- }
- }
- }
- if fn.fe == nil {
- switch rk {
- case reflect.Bool:
- fn.fe = (*encoder[T]).kBool
- case reflect.String:
- // Do not use different functions based on StringToRaw option, as that will statically
- // set the function for a string type, and if the Handle is modified thereafter,
- // behaviour is non-deterministic
- // i.e. DO NOT DO:
- // if x.StringToRaw {
- // fn.fe = (*encoder[T]).kStringToRaw
- // } else {
- // fn.fe = (*encoder[T]).kStringEnc
- // }
-
- fn.fe = (*encoder[T]).kString
- case reflect.Int:
- fn.fe = (*encoder[T]).kInt
- case reflect.Int8:
- fn.fe = (*encoder[T]).kInt8
- case reflect.Int16:
- fn.fe = (*encoder[T]).kInt16
- case reflect.Int32:
- fn.fe = (*encoder[T]).kInt32
- case reflect.Int64:
- fn.fe = (*encoder[T]).kInt64
- case reflect.Uint:
- fn.fe = (*encoder[T]).kUint
- case reflect.Uint8:
- fn.fe = (*encoder[T]).kUint8
- case reflect.Uint16:
- fn.fe = (*encoder[T]).kUint16
- case reflect.Uint32:
- fn.fe = (*encoder[T]).kUint32
- case reflect.Uint64:
- fn.fe = (*encoder[T]).kUint64
- case reflect.Uintptr:
- fn.fe = (*encoder[T]).kUintptr
- case reflect.Float32:
- fn.fe = (*encoder[T]).kFloat32
- case reflect.Float64:
- fn.fe = (*encoder[T]).kFloat64
- case reflect.Complex64:
- fn.fe = (*encoder[T]).kComplex64
- case reflect.Complex128:
- fn.fe = (*encoder[T]).kComplex128
- case reflect.Chan:
- fn.fe = (*encoder[T]).kChan
- case reflect.Slice:
- fn.fe = (*encoder[T]).kSlice
- case reflect.Array:
- fn.fe = (*encoder[T]).kArray
- case reflect.Struct:
- if ti.simple {
- fn.fe = (*encoder[T]).kStructSimple
- } else {
- fn.fe = (*encoder[T]).kStruct
- }
- case reflect.Map:
- fn.fe = (*encoder[T]).kMap
- case reflect.Interface:
- // encode: reflect.Interface are handled already by preEncodeValue
- fn.fe = (*encoder[T]).kErr
- default:
- // reflect.Ptr and reflect.Interface are handled already by preEncodeValue
- fn.fe = (*encoder[T]).kErr
- }
- }
- }
- return
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-02 11:34:59 +0000