diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index 55d29ed532c..958b5817a1d 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -708,7 +708,7 @@ }, { "ImportPath": "github.com/ugorji/go/codec", - "Rev": "8a2a3a8c488c3ebd98f422a965260278267a0551" + "Rev": "f1f1a805ed361a0e078bb537e4ea78cd37dcf065" }, { "ImportPath": "github.com/vaughan0/go-ini", diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/0doc.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/0doc.go index dd8b589de07..caa7e0a3b50 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/0doc.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/0doc.go @@ -98,7 +98,21 @@ with the standard net/rpc package. Usage -Typical usage model: +The Handle is SAFE for concurrent READ, but NOT SAFE for concurrent modification. + +The Encoder and Decoder are NOT safe for concurrent use. + +Consequently, the usage model is basically: + + - Create and initialize the Handle before any use. + Once created, DO NOT modify it. + - Multiple Encoders or Decoders can now use the Handle concurrently. + They only read information off the Handle (never write). + - However, each Encoder or Decoder MUST not be used concurrently + - To re-use an Encoder/Decoder, call Reset(...) on it first. + This allows you use state maintained on the Encoder/Decoder. + +Sample usage model: // create and configure Handle var ( @@ -148,3 +162,32 @@ Typical usage model: */ package codec +// Benefits of go-codec: +// +// - encoding/json always reads whole file into memory first. +// This makes it unsuitable for parsing very large files. +// - encoding/xml cannot parse into a map[string]interface{} +// I found this out on reading https://github.com/clbanning/mxj + +// TODO: +// +// - (En|De)coder should store an error when it occurs. +// Until reset, subsequent calls return that error that was stored. +// This means that free panics must go away. +// All errors must be raised through errorf method. +// - Decoding using a chan is good, but incurs concurrency costs. +// This is because there's no fast way to use a channel without it +// having to switch goroutines constantly. +// Callback pattern is still the best. Maybe cnsider supporting something like: +// type X struct { +// Name string +// Ys []Y +// Ys chan <- Y +// Ys func(interface{}) -> call this interface for each entry in there. +// } +// - Consider adding a isZeroer interface { isZero() bool } +// It is used within isEmpty, for omitEmpty support. +// - Consider making Handle used AS-IS within the encoding/decoding session. +// This means that we don't cache Handle information within the (En|De)coder, +// except we really need it at Reset(...) +// - Handle recursive types during encoding/decoding? diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/binc.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/binc.go index 645376479ae..c884d14dce5 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/binc.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/binc.go @@ -59,8 +59,8 @@ type bincEncDriver struct { e *Encoder w encWriter m map[string]uint16 // symbols - s uint16 // symbols sequencer b [scratchByteArrayLen]byte + s uint16 // symbols sequencer encNoSeparator } @@ -318,9 +318,9 @@ func (e *bincEncDriver) encLenNumber(bd byte, v uint64) { //------------------------------------ type bincDecSymbol struct { - i uint16 s string b []byte + i uint16 } type bincDecDriver struct { @@ -329,7 +329,6 @@ type bincDecDriver struct { r decReader br bool // bytes reader bdRead bool - bdType valueType bd byte vd byte vs byte @@ -347,24 +346,23 @@ func (d *bincDecDriver) readNextBd() { d.vd = d.bd >> 4 d.vs = d.bd & 0x0f d.bdRead = true - d.bdType = valueTypeUnset } -func (d *bincDecDriver) IsContainerType(vt valueType) (b bool) { - switch vt { - case valueTypeNil: - return d.vd == bincVdSpecial && d.vs == bincSpNil - case valueTypeBytes: - return d.vd == bincVdByteArray - case valueTypeString: - return d.vd == bincVdString - case valueTypeArray: - return d.vd == bincVdArray - case valueTypeMap: - return d.vd == bincVdMap +func (d *bincDecDriver) ContainerType() (vt valueType) { + if d.vd == bincVdSpecial && d.vs == bincSpNil { + return valueTypeNil + } else if d.vd == bincVdByteArray { + return valueTypeBytes + } else if d.vd == bincVdString { + return valueTypeString + } else if d.vd == bincVdArray { + return valueTypeArray + } else if d.vd == bincVdMap { + return valueTypeMap + } else { + // d.d.errorf("isContainerType: unsupported parameter: %v", vt) } - d.d.errorf("isContainerType: unsupported parameter: %v", vt) - return // "unreachable" + return valueTypeUnset } func (d *bincDecDriver) TryDecodeAsNil() bool { @@ -695,7 +693,7 @@ func (d *bincDecDriver) decStringAndBytes(bs []byte, withString, zerocopy bool) if withString { s = string(bs2) } - d.s = append(d.s, bincDecSymbol{symbol, s, bs2}) + d.s = append(d.s, bincDecSymbol{i: symbol, s: s, b: bs2}) } default: d.d.errorf("Invalid d.vd. Expecting string:0x%x, bytearray:0x%x or symbol: 0x%x. Got: 0x%x", @@ -784,97 +782,95 @@ func (d *bincDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs []b return } -func (d *bincDecDriver) DecodeNaked() (v interface{}, vt valueType, decodeFurther bool) { +func (d *bincDecDriver) DecodeNaked() { if !d.bdRead { d.readNextBd() } + n := &d.d.n + var decodeFurther bool + switch d.vd { case bincVdSpecial: switch d.vs { case bincSpNil: - vt = valueTypeNil + n.v = valueTypeNil case bincSpFalse: - vt = valueTypeBool - v = false + n.v = valueTypeBool + n.b = false case bincSpTrue: - vt = valueTypeBool - v = true + n.v = valueTypeBool + n.b = true case bincSpNan: - vt = valueTypeFloat - v = math.NaN() + n.v = valueTypeFloat + n.f = math.NaN() case bincSpPosInf: - vt = valueTypeFloat - v = math.Inf(1) + n.v = valueTypeFloat + n.f = math.Inf(1) case bincSpNegInf: - vt = valueTypeFloat - v = math.Inf(-1) + n.v = valueTypeFloat + n.f = math.Inf(-1) case bincSpZeroFloat: - vt = valueTypeFloat - v = float64(0) + n.v = valueTypeFloat + n.f = float64(0) case bincSpZero: - vt = valueTypeUint - v = uint64(0) // int8(0) + n.v = valueTypeUint + n.u = uint64(0) // int8(0) case bincSpNegOne: - vt = valueTypeInt - v = int64(-1) // int8(-1) + n.v = valueTypeInt + n.i = int64(-1) // int8(-1) default: d.d.errorf("decodeNaked: Unrecognized special value 0x%x", d.vs) - return } case bincVdSmallInt: - vt = valueTypeUint - v = uint64(int8(d.vs)) + 1 // int8(d.vs) + 1 + n.v = valueTypeUint + n.u = uint64(int8(d.vs)) + 1 // int8(d.vs) + 1 case bincVdPosInt: - vt = valueTypeUint - v = d.decUint() + n.v = valueTypeUint + n.u = d.decUint() case bincVdNegInt: - vt = valueTypeInt - v = -(int64(d.decUint())) + n.v = valueTypeInt + n.i = -(int64(d.decUint())) case bincVdFloat: - vt = valueTypeFloat - v = d.decFloat() + n.v = valueTypeFloat + n.f = d.decFloat() case bincVdSymbol: - vt = valueTypeSymbol - v = d.DecodeString() + n.v = valueTypeSymbol + n.s = d.DecodeString() case bincVdString: - vt = valueTypeString - v = d.DecodeString() + n.v = valueTypeString + n.s = d.DecodeString() case bincVdByteArray: - vt = valueTypeBytes - v = d.DecodeBytes(nil, false, false) + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) case bincVdTimestamp: - vt = valueTypeTimestamp + n.v = valueTypeTimestamp tt, err := decodeTime(d.r.readx(int(d.vs))) if err != nil { panic(err) } - v = tt + n.t = tt case bincVdCustomExt: - vt = valueTypeExt + n.v = valueTypeExt l := d.decLen() - var re RawExt - re.Tag = uint64(d.r.readn1()) - re.Data = d.r.readx(l) - v = &re - vt = valueTypeExt + n.u = uint64(d.r.readn1()) + n.l = d.r.readx(l) case bincVdArray: - vt = valueTypeArray + n.v = valueTypeArray decodeFurther = true case bincVdMap: - vt = valueTypeMap + n.v = valueTypeMap decodeFurther = true default: d.d.errorf("decodeNaked: Unrecognized d.vd: 0x%x", d.vd) - return } if !decodeFurther { d.bdRead = false } - if vt == valueTypeUint && d.h.SignedInteger { - d.bdType = valueTypeInt - v = int64(v.(uint64)) + if n.v == valueTypeUint && d.h.SignedInteger { + n.v = valueTypeInt + n.i = int64(n.u) } return } @@ -898,6 +894,10 @@ type BincHandle struct { binaryEncodingType } +func (h *BincHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) { + return h.SetExt(rt, tag, &setExtWrapper{b: ext}) +} + func (h *BincHandle) newEncDriver(e *Encoder) encDriver { return &bincEncDriver{e: e, w: e.w} } @@ -906,8 +906,12 @@ func (h *BincHandle) newDecDriver(d *Decoder) decDriver { return &bincDecDriver{d: d, r: d.r, h: h, br: d.bytes} } -func (h *BincHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) { - return h.SetExt(rt, tag, &setExtWrapper{b: ext}) +func (e *bincEncDriver) reset() { + e.w = e.e.w +} + +func (d *bincDecDriver) reset() { + d.r = d.d.r } var _ decDriver = (*bincDecDriver)(nil) diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/cbor.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/cbor.go index 8b6e13a89e9..0e5d32b2ea9 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/cbor.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/cbor.go @@ -60,11 +60,11 @@ const ( // ------------------- type cborEncDriver struct { + noBuiltInTypes + encNoSeparator e *Encoder w encWriter h *CborHandle - noBuiltInTypes - encNoSeparator x [8]byte } @@ -175,11 +175,10 @@ type cborDecDriver struct { d *Decoder h *CborHandle r decReader + b [scratchByteArrayLen]byte br bool // bytes reader bdRead bool - bdType valueType bd byte - b [scratchByteArrayLen]byte noBuiltInTypes decNoSeparator } @@ -187,24 +186,23 @@ type cborDecDriver struct { func (d *cborDecDriver) readNextBd() { d.bd = d.r.readn1() d.bdRead = true - d.bdType = valueTypeUnset } -func (d *cborDecDriver) IsContainerType(vt valueType) (bv bool) { - switch vt { - case valueTypeNil: - return d.bd == cborBdNil - case valueTypeBytes: - return d.bd == cborBdIndefiniteBytes || (d.bd >= cborBaseBytes && d.bd < cborBaseString) - case valueTypeString: - return d.bd == cborBdIndefiniteString || (d.bd >= cborBaseString && d.bd < cborBaseArray) - case valueTypeArray: - return d.bd == cborBdIndefiniteArray || (d.bd >= cborBaseArray && d.bd < cborBaseMap) - case valueTypeMap: - return d.bd == cborBdIndefiniteMap || (d.bd >= cborBaseMap && d.bd < cborBaseTag) +func (d *cborDecDriver) ContainerType() (vt valueType) { + if d.bd == cborBdNil { + return valueTypeNil + } else if d.bd == cborBdIndefiniteBytes || (d.bd >= cborBaseBytes && d.bd < cborBaseString) { + return valueTypeBytes + } else if d.bd == cborBdIndefiniteString || (d.bd >= cborBaseString && d.bd < cborBaseArray) { + return valueTypeString + } else if d.bd == cborBdIndefiniteArray || (d.bd >= cborBaseArray && d.bd < cborBaseMap) { + return valueTypeArray + } else if d.bd == cborBdIndefiniteMap || (d.bd >= cborBaseMap && d.bd < cborBaseTag) { + return valueTypeMap + } else { + // d.d.errorf("isContainerType: unsupported parameter: %v", vt) } - d.d.errorf("isContainerType: unsupported parameter: %v", vt) - return // "unreachable" + return valueTypeUnset } func (d *cborDecDriver) TryDecodeAsNil() bool { @@ -446,71 +444,72 @@ func (d *cborDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxta return } -func (d *cborDecDriver) DecodeNaked() (v interface{}, vt valueType, decodeFurther bool) { +func (d *cborDecDriver) DecodeNaked() { if !d.bdRead { d.readNextBd() } + n := &d.d.n + var decodeFurther bool + switch d.bd { case cborBdNil: - vt = valueTypeNil + n.v = valueTypeNil case cborBdFalse: - vt = valueTypeBool - v = false + n.v = valueTypeBool + n.b = false case cborBdTrue: - vt = valueTypeBool - v = true + n.v = valueTypeBool + n.b = true case cborBdFloat16, cborBdFloat32: - vt = valueTypeFloat - v = d.DecodeFloat(true) + n.v = valueTypeFloat + n.f = d.DecodeFloat(true) case cborBdFloat64: - vt = valueTypeFloat - v = d.DecodeFloat(false) + n.v = valueTypeFloat + n.f = d.DecodeFloat(false) case cborBdIndefiniteBytes: - vt = valueTypeBytes - v = d.DecodeBytes(nil, false, false) + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) case cborBdIndefiniteString: - vt = valueTypeString - v = d.DecodeString() + n.v = valueTypeString + n.s = d.DecodeString() case cborBdIndefiniteArray: - vt = valueTypeArray + n.v = valueTypeArray decodeFurther = true case cborBdIndefiniteMap: - vt = valueTypeMap + n.v = valueTypeMap decodeFurther = true default: switch { case d.bd >= cborBaseUint && d.bd < cborBaseNegInt: if d.h.SignedInteger { - vt = valueTypeInt - v = d.DecodeInt(64) + n.v = valueTypeInt + n.i = d.DecodeInt(64) } else { - vt = valueTypeUint - v = d.DecodeUint(64) + n.v = valueTypeUint + n.u = d.DecodeUint(64) } case d.bd >= cborBaseNegInt && d.bd < cborBaseBytes: - vt = valueTypeInt - v = d.DecodeInt(64) + n.v = valueTypeInt + n.i = d.DecodeInt(64) case d.bd >= cborBaseBytes && d.bd < cborBaseString: - vt = valueTypeBytes - v = d.DecodeBytes(nil, false, false) + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) case d.bd >= cborBaseString && d.bd < cborBaseArray: - vt = valueTypeString - v = d.DecodeString() + n.v = valueTypeString + n.s = d.DecodeString() case d.bd >= cborBaseArray && d.bd < cborBaseMap: - vt = valueTypeArray + n.v = valueTypeArray decodeFurther = true case d.bd >= cborBaseMap && d.bd < cborBaseTag: - vt = valueTypeMap + n.v = valueTypeMap decodeFurther = true case d.bd >= cborBaseTag && d.bd < cborBaseSimple: - vt = valueTypeExt - var re RawExt - ui := d.decUint() + n.v = valueTypeExt + n.u = d.decUint() + n.l = nil d.bdRead = false - re.Tag = ui - d.d.decode(&re.Value) - v = &re + // d.d.decode(&re.Value) // handled by decode itself. // decodeFurther = true default: d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd) @@ -557,8 +556,12 @@ func (d *cborDecDriver) DecodeNaked() (v interface{}, vt valueType, decodeFurthe // // Now, vv contains the same string "one-byte" // type CborHandle struct { - BasicHandle binaryEncodingType + BasicHandle +} + +func (h *CborHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) { + return h.SetExt(rt, tag, &setExtWrapper{i: ext}) } func (h *CborHandle) newEncDriver(e *Encoder) encDriver { @@ -569,8 +572,12 @@ func (h *CborHandle) newDecDriver(d *Decoder) decDriver { return &cborDecDriver{d: d, r: d.r, h: h, br: d.bytes} } -func (h *CborHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) { - return h.SetExt(rt, tag, &setExtWrapper{i: ext}) +func (e *cborEncDriver) reset() { + e.w = e.e.w +} + +func (d *cborDecDriver) reset() { + d.r = d.d.r } var _ decDriver = (*cborDecDriver)(nil) diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/decode.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/decode.go index 71dd71c8928..b3b99f03670 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/decode.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/decode.go @@ -9,6 +9,7 @@ import ( "fmt" "io" "reflect" + "time" ) // Some tagging information for error messages. @@ -48,16 +49,23 @@ type decDriver interface { // this will check if the next token is a break. CheckBreak() bool TryDecodeAsNil() bool - // check if a container type: vt is one of: Bytes, String, Nil, Slice or Map. - // if vt param == valueTypeNil, and nil is seen in stream, consume the nil. - IsContainerType(vt valueType) bool + // vt is one of: Bytes, String, Nil, Slice or Map. Return unSet if not known. + ContainerType() (vt valueType) IsBuiltinType(rt uintptr) bool DecodeBuiltin(rt uintptr, v interface{}) - //decodeNaked: Numbers are decoded as int64, uint64, float64 only (no smaller sized number types). - //for extensions, decodeNaked must completely decode them as a *RawExt. - //extensions should also use readx to decode them, for efficiency. - //kInterface will extract the detached byte slice if it has to pass it outside its realm. - DecodeNaked() (v interface{}, vt valueType, decodeFurther bool) + + // DecodeNaked will decode primitives (number, bool, string, []byte) and RawExt. + // For maps and arrays, it will not do the decoding in-band, but will signal + // the decoder, so that is done later, by setting the decNaked.valueType field. + // + // Note: Numbers are decoded as int64, uint64, float64 only (no smaller sized number types). + // for extensions, DecodeNaked must read the tag and the []byte if it exists. + // if the []byte is not read, then kInterfaceNaked will treat it as a Handle + // that stores the subsequent value in-band, and complete reading the RawExt. + // + // extensions should also use readx to decode them, for efficiency. + // kInterface will extract the detached byte slice if it has to pass it outside its realm. + DecodeNaked() DecodeInt(bitsize uint8) (i int64) DecodeUint(bitsize uint8) (ui uint64) DecodeFloat(chkOverflow32 bool) (f float64) @@ -78,13 +86,15 @@ type decDriver interface { // decodeExt(verifyTag bool, tag byte) (xtag byte, xbs []byte) ReadMapStart() int ReadArrayStart() int - // ReadEnd registers the end of a map or array. - ReadEnd() + + reset() + uncacheRead() } type decNoSeparator struct{} -func (_ decNoSeparator) ReadEnd() {} +func (_ decNoSeparator) ReadEnd() {} +func (_ decNoSeparator) uncacheRead() {} type DecodeOptions struct { // MapType specifies type to use during schema-less decoding of a map in the stream. @@ -326,6 +336,13 @@ type bytesDecReader struct { t int // track start } +func (z *bytesDecReader) reset(in []byte) { + z.b = in + z.a = len(in) + z.c = 0 + z.t = 0 +} + func (z *bytesDecReader) numread() int { return z.c } @@ -460,12 +477,8 @@ func (f *decFnInfo) textUnmarshal(rv reflect.Value) { func (f *decFnInfo) jsonUnmarshal(rv reflect.Value) { tm := f.getValueForUnmarshalInterface(rv, f.ti.junmIndir).(jsonUnmarshaler) // bs := f.d.d.DecodeBytes(f.d.b[:], true, true) - // grab the bytes to be read, as UnmarshalJSON wants the full JSON to unmarshal it itself. - f.d.r.track() - f.d.swallow() - bs := f.d.r.stopTrack() - // fmt.Printf(">>>>>> REFLECTION JSON: %s\n", bs) - fnerr := tm.UnmarshalJSON(bs) + // grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself. + fnerr := tm.UnmarshalJSON(f.d.nextValueBytes()) if fnerr != nil { panic(fnerr) } @@ -549,63 +562,96 @@ func (f *decFnInfo) kInterfaceNaked() (rvn reflect.Value) { // nil interface: // use some hieristics to decode it appropriately // based on the detected next value in the stream. - v, vt, decodeFurther := f.d.d.DecodeNaked() - if vt == valueTypeNil { + d := f.d + d.d.DecodeNaked() + n := &d.n + if n.v == valueTypeNil { return } // We cannot decode non-nil stream value into nil interface with methods (e.g. io.Reader). - if num := f.ti.rt.NumMethod(); num > 0 { - f.d.errorf("cannot decode non-nil codec value into nil %v (%v methods)", f.ti.rt, num) + // if num := f.ti.rt.NumMethod(); num > 0 { + if f.ti.numMeth > 0 { + d.errorf("cannot decode non-nil codec value into nil %v (%v methods)", f.ti.rt, f.ti.numMeth) return } - var useRvn bool - switch vt { + // var useRvn bool + switch n.v { case valueTypeMap: - if f.d.h.MapType == nil { - var m2 map[interface{}]interface{} - v = &m2 + // if d.h.MapType == nil || d.h.MapType == mapIntfIntfTyp { + // } else if d.h.MapType == mapStrIntfTyp { // for json performance + // } + if d.mtid == 0 || d.mtid == mapIntfIntfTypId { + l := len(n.ms) + n.ms = append(n.ms, nil) + d.decode(&n.ms[l]) + rvn = reflect.ValueOf(&n.ms[l]).Elem() + n.ms = n.ms[:l] + } else if d.mtid == mapStrIntfTypId { // for json performance + l := len(n.ns) + n.ns = append(n.ns, nil) + d.decode(&n.ns[l]) + rvn = reflect.ValueOf(&n.ns[l]).Elem() + n.ns = n.ns[:l] } else { - rvn = reflect.New(f.d.h.MapType).Elem() - useRvn = true + rvn = reflect.New(d.h.MapType).Elem() + d.decodeValue(rvn, nil) } case valueTypeArray: - if f.d.h.SliceType == nil { - var m2 []interface{} - v = &m2 + // if d.h.SliceType == nil || d.h.SliceType == intfSliceTyp { + if d.stid == 0 || d.stid == intfSliceTypId { + l := len(n.ss) + n.ss = append(n.ss, nil) + d.decode(&n.ss[l]) + rvn = reflect.ValueOf(&n.ss[l]).Elem() + n.ss = n.ss[:l] } else { - rvn = reflect.New(f.d.h.SliceType).Elem() - useRvn = true + rvn = reflect.New(d.h.SliceType).Elem() + d.decodeValue(rvn, nil) } case valueTypeExt: - re := v.(*RawExt) - bfn := f.d.h.getExtForTag(re.Tag) + var v interface{} + tag, bytes := n.u, n.l // calling decode below might taint the values + if bytes == nil { + l := len(n.is) + n.is = append(n.is, nil) + v2 := &n.is[l] + n.is = n.is[:l] + d.decode(v2) + v = *v2 + } + bfn := d.h.getExtForTag(tag) if bfn == nil { - re.Data = detachZeroCopyBytes(f.d.bytes, nil, re.Data) - rvn = reflect.ValueOf(*re) + var re RawExt + re.Tag = tag + re.Data = detachZeroCopyBytes(d.bytes, nil, bytes) + rvn = reflect.ValueOf(re) } else { rvnA := reflect.New(bfn.rt) rvn = rvnA.Elem() - if re.Data != nil { - bfn.ext.ReadExt(rvnA.Interface(), re.Data) + if bytes != nil { + bfn.ext.ReadExt(rvnA.Interface(), bytes) } else { - bfn.ext.UpdateExt(rvnA.Interface(), re.Value) + bfn.ext.UpdateExt(rvnA.Interface(), v) } } - return - } - if decodeFurther { - if useRvn { - f.d.decodeValue(rvn, nil) - } else if v != nil { - // this v is a pointer, so we need to dereference it when done - f.d.decode(v) - rvn = reflect.ValueOf(v).Elem() - useRvn = true - } - } - - if !useRvn && v != nil { - rvn = reflect.ValueOf(v) + case valueTypeNil: + // no-op + case valueTypeInt: + rvn = reflect.ValueOf(&n.i).Elem() + case valueTypeUint: + rvn = reflect.ValueOf(&n.u).Elem() + case valueTypeFloat: + rvn = reflect.ValueOf(&n.f).Elem() + case valueTypeBool: + rvn = reflect.ValueOf(&n.b).Elem() + case valueTypeString, valueTypeSymbol: + rvn = reflect.ValueOf(&n.s).Elem() + case valueTypeBytes: + rvn = reflect.ValueOf(&n.l).Elem() + case valueTypeTimestamp: + rvn = reflect.ValueOf(&n.t).Elem() + default: + panic(fmt.Errorf("kInterfaceNaked: unexpected valueType: %d", n.v)) } return } @@ -655,10 +701,14 @@ func (f *decFnInfo) kStruct(rv reflect.Value) { fti := f.ti d := f.d dd := d.d - if dd.IsContainerType(valueTypeMap) { + cr := d.cr + ctyp := dd.ContainerType() + if ctyp == valueTypeMap { containerLen := dd.ReadMapStart() if containerLen == 0 { - dd.ReadEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } return } tisfi := fti.sfi @@ -666,8 +716,14 @@ func (f *decFnInfo) kStruct(rv reflect.Value) { if hasLen { for j := 0; j < containerLen; j++ { // rvkencname := dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapKey) + } rvkencname := stringView(dd.DecodeBytes(f.d.b[:], true, true)) // rvksi := ti.getForEncName(rvkencname) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if k := fti.indexForEncName(rvkencname); k > -1 { si := tisfi[k] if dd.TryDecodeAsNil() { @@ -682,8 +738,14 @@ func (f *decFnInfo) kStruct(rv reflect.Value) { } else { for j := 0; !dd.CheckBreak(); j++ { // rvkencname := dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapKey) + } rvkencname := stringView(dd.DecodeBytes(f.d.b[:], true, true)) // rvksi := ti.getForEncName(rvkencname) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if k := fti.indexForEncName(rvkencname); k > -1 { si := tisfi[k] if dd.TryDecodeAsNil() { @@ -695,12 +757,16 @@ func (f *decFnInfo) kStruct(rv reflect.Value) { d.structFieldNotFound(-1, rvkencname) } } - dd.ReadEnd() } - } else if dd.IsContainerType(valueTypeArray) { + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + } else if ctyp == valueTypeArray { containerLen := dd.ReadArrayStart() if containerLen == 0 { - dd.ReadEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } return } // Not much gain from doing it two ways for array. @@ -714,6 +780,9 @@ func (f *decFnInfo) kStruct(rv reflect.Value) { } else if dd.CheckBreak() { break } + if cr != nil { + cr.sendContainerState(containerArrayElem) + } if dd.TryDecodeAsNil() { si.setToZeroValue(rv) } else { @@ -723,10 +792,15 @@ func (f *decFnInfo) kStruct(rv reflect.Value) { if containerLen > len(fti.sfip) { // read remaining values and throw away for j := len(fti.sfip); j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } d.structFieldNotFound(j, "") } } - dd.ReadEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } else { f.d.error(onlyMapOrArrayCanDecodeIntoStructErr) return @@ -740,59 +814,50 @@ func (f *decFnInfo) kSlice(rv reflect.Value) { d := f.d dd := d.d rtelem0 := ti.rt.Elem() - - if dd.IsContainerType(valueTypeBytes) || dd.IsContainerType(valueTypeString) { - if ti.rtid == uint8SliceTypId || rtelem0.Kind() == reflect.Uint8 { - if f.seq == seqTypeChan { - bs2 := dd.DecodeBytes(nil, false, true) - ch := rv.Interface().(chan<- byte) - for _, b := range bs2 { - ch <- b - } - } else { - rvbs := rv.Bytes() - bs2 := dd.DecodeBytes(rvbs, false, false) - if rvbs == nil && bs2 != nil || rvbs != nil && bs2 == nil || len(bs2) != len(rvbs) { - if rv.CanSet() { - rv.SetBytes(bs2) - } else { - copy(rvbs, bs2) - } + ctyp := dd.ContainerType() + if ctyp == valueTypeBytes || ctyp == valueTypeString { + // you can only decode bytes or string in the stream into a slice or array of bytes + if !(ti.rtid == uint8SliceTypId || rtelem0.Kind() == reflect.Uint8) { + f.d.errorf("bytes or string in the stream must be decoded into a slice or array of bytes, not %v", ti.rt) + } + if f.seq == seqTypeChan { + bs2 := dd.DecodeBytes(nil, false, true) + ch := rv.Interface().(chan<- byte) + for _, b := range bs2 { + ch <- b + } + } else { + rvbs := rv.Bytes() + bs2 := dd.DecodeBytes(rvbs, false, false) + if rvbs == nil && bs2 != nil || rvbs != nil && bs2 == nil || len(bs2) != len(rvbs) { + if rv.CanSet() { + rv.SetBytes(bs2) + } else { + copy(rvbs, bs2) } } - return } + return } // array := f.seq == seqTypeChan - slh, containerLenS := d.decSliceHelperStart() - - var rvlen, numToRead int - var truncated bool // says that the len of the sequence is not same as the expected number of elements. - - numToRead = containerLenS // if truncated, reset numToRead - - // an array can never return a nil slice. so no need to check f.array here. - if rv.IsNil() { - // either chan or slice - if rvlen, truncated = decInferLen(containerLenS, f.d.h.MaxInitLen, int(rtelem0.Size())); truncated { - numToRead = rvlen - } - if f.seq == seqTypeSlice { - rv.Set(reflect.MakeSlice(ti.rt, rvlen, rvlen)) - } else if f.seq == seqTypeChan { - rv.Set(reflect.MakeChan(ti.rt, rvlen)) - } - } else { - rvlen = rv.Len() - } + slh, containerLenS := d.decSliceHelperStart() // only expects valueType(Array|Map) + // // an array can never return a nil slice. so no need to check f.array here. if containerLenS == 0 { - if f.seq == seqTypeSlice && rvlen != 0 { - rv.SetLen(0) + if f.seq == seqTypeSlice { + if rv.IsNil() { + rv.Set(reflect.MakeSlice(ti.rt, 0, 0)) + } else { + rv.SetLen(0) + } + } else if f.seq == seqTypeChan { + if rv.IsNil() { + rv.Set(reflect.MakeChan(ti.rt, 0)) + } } - // dd.ReadEnd() + slh.End() return } @@ -806,30 +871,48 @@ func (f *decFnInfo) kSlice(rv reflect.Value) { rv0 = rv rvChanged := false - rvcap := rv.Cap() - // for j := 0; j < containerLenS; j++ { - - if containerLenS >= 0 { // hasLen + var rvlen int + if containerLenS > 0 { // hasLen if f.seq == seqTypeChan { + if rv.IsNil() { + rvlen, _ = decInferLen(containerLenS, f.d.h.MaxInitLen, int(rtelem0.Size())) + rv.Set(reflect.MakeChan(ti.rt, rvlen)) + } // handle chan specially: for j := 0; j < containerLenS; j++ { rv9 = reflect.New(rtelem0).Elem() + slh.ElemContainerState(j) d.decodeValue(rv9, fn) rv.Send(rv9) } } else { // slice or array + var truncated bool // says len of sequence is not same as expected number of elements + numToRead := containerLenS // if truncated, reset numToRead + + rvcap := rv.Cap() + rvlen = rv.Len() if containerLenS > rvcap { if f.seq == seqTypeArray { d.arrayCannotExpand(rvlen, containerLenS) } else { oldRvlenGtZero := rvlen > 0 rvlen, truncated = decInferLen(containerLenS, f.d.h.MaxInitLen, int(rtelem0.Size())) - rv = reflect.MakeSlice(ti.rt, rvlen, rvlen) - if oldRvlenGtZero && !isImmutableKind(rtelem0.Kind()) { + if truncated { + if rvlen <= rvcap { + rv.SetLen(rvlen) + } else { + rv = reflect.MakeSlice(ti.rt, rvlen, rvlen) + rvChanged = true + } + } else { + rv = reflect.MakeSlice(ti.rt, rvlen, rvlen) + rvChanged = true + } + if rvChanged && oldRvlenGtZero && !isImmutableKind(rtelem0.Kind()) { reflect.Copy(rv, rv0) // only copy up to length NOT cap i.e. rv0.Slice(0, rvcap) } - rvChanged = true + rvcap = rvlen } numToRead = rvlen } else if containerLenS != rvlen { @@ -841,6 +924,7 @@ func (f *decFnInfo) kSlice(rv reflect.Value) { j := 0 // we read up to the numToRead for ; j < numToRead; j++ { + slh.ElemContainerState(j) d.decodeValue(rv.Index(j), fn) } @@ -849,6 +933,7 @@ func (f *decFnInfo) kSlice(rv reflect.Value) { if f.seq == seqTypeArray { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } else if truncated { // slice was truncated, as chan NOT in this block @@ -858,44 +943,59 @@ func (f *decFnInfo) kSlice(rv reflect.Value) { if resetSliceElemToZeroValue { rv9.Set(reflect.Zero(rtelem0)) } + slh.ElemContainerState(j) d.decodeValue(rv9, fn) } } } } else { - for j := 0; !dd.CheckBreak(); j++ { - var decodeIntoBlank bool - // if indefinite, etc, then expand the slice if necessary - if j >= rvlen { - if f.seq == seqTypeArray { - d.arrayCannotExpand(rvlen, j+1) - decodeIntoBlank = true - } else if f.seq == seqTypeSlice { - // rv = reflect.Append(rv, reflect.Zero(rtelem0)) // uses append logic, plus varargs - rv = expandSliceValue(rv, 1) - rv9 = rv.Index(j) - // rv.Index(rv.Len() - 1).Set(reflect.Zero(rtelem0)) - if resetSliceElemToZeroValue { - rv9.Set(reflect.Zero(rtelem0)) - } - rvlen++ - rvChanged = true - } - } else if f.seq != seqTypeChan { // slice or array - rv9 = rv.Index(j) - } + rvlen = rv.Len() + j := 0 + for ; !dd.CheckBreak(); j++ { if f.seq == seqTypeChan { + slh.ElemContainerState(j) rv9 = reflect.New(rtelem0).Elem() d.decodeValue(rv9, fn) rv.Send(rv9) - } else if decodeIntoBlank { - d.swallow() - } else { // seqTypeSlice - d.decodeValue(rv9, fn) + } else { + // if indefinite, etc, then expand the slice if necessary + var decodeIntoBlank bool + if j >= rvlen { + if f.seq == seqTypeArray { + d.arrayCannotExpand(rvlen, j+1) + decodeIntoBlank = true + } else { // if f.seq == seqTypeSlice + // rv = reflect.Append(rv, reflect.Zero(rtelem0)) // uses append logic, plus varargs + rv = expandSliceValue(rv, 1) + rv9 = rv.Index(j) + // rv.Index(rv.Len() - 1).Set(reflect.Zero(rtelem0)) + if resetSliceElemToZeroValue { + rv9.Set(reflect.Zero(rtelem0)) + } + rvlen++ + rvChanged = true + } + } else { // slice or array + rv9 = rv.Index(j) + } + slh.ElemContainerState(j) + if decodeIntoBlank { + d.swallow() + } else { // seqTypeSlice + d.decodeValue(rv9, fn) + } + } + } + if f.seq == seqTypeSlice { + if j < rvlen { + rv.SetLen(j) + } else if j == 0 && rv.IsNil() { + rv = reflect.MakeSlice(ti.rt, 0, 0) + rvChanged = true } } - slh.End() } + slh.End() if rvChanged { rv0.Set(rv) @@ -911,20 +1011,22 @@ func (f *decFnInfo) kMap(rv reflect.Value) { d := f.d dd := d.d containerLen := dd.ReadMapStart() - + cr := d.cr ti := f.ti if rv.IsNil() { rv.Set(reflect.MakeMap(ti.rt)) } if containerLen == 0 { - // It is not length-prefix style container. They have no End marker. - // dd.ReadMapEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } return } ktype, vtype := ti.rt.Key(), ti.rt.Elem() ktypeId := reflect.ValueOf(ktype).Pointer() + vtypeKind := vtype.Kind() var keyFn, valFn *decFn var xtyp reflect.Type for xtyp = ktype; xtyp.Kind() == reflect.Ptr; xtyp = xtyp.Elem() { @@ -933,13 +1035,12 @@ func (f *decFnInfo) kMap(rv reflect.Value) { for xtyp = vtype; xtyp.Kind() == reflect.Ptr; xtyp = xtyp.Elem() { } valFn = d.getDecFn(xtyp, true, true) - var mapGet bool + var mapGet, mapSet bool if !f.d.h.MapValueReset { // if pointer, mapGet = true // if interface, mapGet = true if !DecodeNakedAlways (else false) // if builtin, mapGet = false // else mapGet = true - vtypeKind := vtype.Kind() if vtypeKind == reflect.Ptr { mapGet = true } else if vtypeKind == reflect.Interface { @@ -951,12 +1052,15 @@ func (f *decFnInfo) kMap(rv reflect.Value) { } } - var rvk, rvv reflect.Value + var rvk, rvv, rvz reflect.Value // for j := 0; j < containerLen; j++ { if containerLen > 0 { for j := 0; j < containerLen; j++ { rvk = reflect.New(ktype).Elem() + if cr != nil { + cr.sendContainerState(containerMapKey) + } d.decodeValue(rvk, keyFn) // special case if a byte array. @@ -966,20 +1070,43 @@ func (f *decFnInfo) kMap(rv reflect.Value) { rvk = reflect.ValueOf(d.string(rvk.Bytes())) } } + mapSet = true // set to false if u do a get, and its a pointer, and exists if mapGet { rvv = rv.MapIndex(rvk) - if !rvv.IsValid() { - rvv = reflect.New(vtype).Elem() + if rvv.IsValid() { + if vtypeKind == reflect.Ptr { + mapSet = false + } + } else { + if rvz.IsValid() { + rvz.Set(reflect.Zero(vtype)) + } else { + rvz = reflect.New(vtype).Elem() + } + rvv = rvz } } else { - rvv = reflect.New(vtype).Elem() + if rvz.IsValid() { + rvz.Set(reflect.Zero(vtype)) + } else { + rvz = reflect.New(vtype).Elem() + } + rvv = rvz + } + if cr != nil { + cr.sendContainerState(containerMapValue) } d.decodeValue(rvv, valFn) - rv.SetMapIndex(rvk, rvv) + if mapSet { + rv.SetMapIndex(rvk, rvv) + } } } else { for j := 0; !dd.CheckBreak(); j++ { rvk = reflect.New(ktype).Elem() + if cr != nil { + cr.sendContainerState(containerMapKey) + } d.decodeValue(rvk, keyFn) // special case if a byte array. @@ -989,18 +1116,40 @@ func (f *decFnInfo) kMap(rv reflect.Value) { rvk = reflect.ValueOf(d.string(rvk.Bytes())) } } + mapSet = true // set to false if u do a get, and its a pointer, and exists if mapGet { rvv = rv.MapIndex(rvk) - if !rvv.IsValid() { - rvv = reflect.New(vtype).Elem() + if rvv.IsValid() { + if vtypeKind == reflect.Ptr { + mapSet = false + } + } else { + if rvz.IsValid() { + rvz.Set(reflect.Zero(vtype)) + } else { + rvz = reflect.New(vtype).Elem() + } + rvv = rvz } } else { - rvv = reflect.New(vtype).Elem() + if rvz.IsValid() { + rvz.Set(reflect.Zero(vtype)) + } else { + rvz = reflect.New(vtype).Elem() + } + rvv = rvz + } + if cr != nil { + cr.sendContainerState(containerMapValue) } d.decodeValue(rvv, valFn) - rv.SetMapIndex(rvk, rvv) + if mapSet { + rv.SetMapIndex(rvk, rvv) + } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } } @@ -1009,6 +1158,65 @@ type decRtidFn struct { fn decFn } +// decNaked is used to keep track of the primitives decoded. +// Without it, we would have to decode each primitive and wrap it +// in an interface{}, causing an allocation. +// In this model, the primitives are decoded in a "pseudo-atomic" fashion, +// so we can rest assured that no other decoding happens while these +// primitives are being decoded. +// +// maps and arrays are not handled by this mechanism. +// However, RawExt is, and we accomodate for extensions that decode +// RawExt from DecodeNaked, but need to decode the value subsequently. +// kInterfaceNaked and swallow, which call DecodeNaked, handle this caveat. +// +// However, decNaked also keeps some arrays of default maps and slices +// used in DecodeNaked. This way, we can get a pointer to it +// without causing a new heap allocation. +// +// kInterfaceNaked will ensure that there is no allocation for the common +// uses. +type decNaked struct { + // r RawExt // used for RawExt, uint, []byte. + u uint64 + i int64 + f float64 + l []byte + s string + t time.Time + b bool + v valueType + + // stacks for reducing allocation + is []interface{} + ms []map[interface{}]interface{} + ns []map[string]interface{} + ss [][]interface{} + // rs []RawExt + + // keep arrays at the bottom? Chance is that they are not used much. + ia [4]interface{} + ma [4]map[interface{}]interface{} + na [4]map[string]interface{} + sa [4][]interface{} + // ra [2]RawExt +} + +func (n *decNaked) reset() { + if n.ss != nil { + n.ss = n.ss[:0] + } + if n.is != nil { + n.is = n.is[:0] + } + if n.ms != nil { + n.ms = n.ms[:0] + } + if n.ns != nil { + n.ns = n.ns[:0] + } +} + // A Decoder reads and decodes an object from an input stream in the codec format. type Decoder struct { // hopefully, reduce derefencing cost by laying the decReader inside the Decoder. @@ -1019,32 +1227,84 @@ type Decoder struct { // as the handler MAY need to do some coordination. r decReader // sa [initCollectionCap]decRtidFn - s []decRtidFn - h *BasicHandle + h *BasicHandle + hh Handle - rb bytesDecReader - hh Handle be bool // is binary encoding bytes bool // is bytes reader js bool // is json handle + rb bytesDecReader ri ioDecReader - f map[uintptr]*decFn - is map[string]string // used for interning strings + cr containerStateRecv + + s []decRtidFn + f map[uintptr]*decFn // _ uintptr // for alignment purposes, so next one starts from a cache line - b [scratchByteArrayLen]byte + // cache the mapTypeId and sliceTypeId for faster comparisons + mtid uintptr + stid uintptr + + n decNaked + b [scratchByteArrayLen]byte + is map[string]string // used for interning strings } // NewDecoder returns a Decoder for decoding a stream of bytes from an io.Reader. // // For efficiency, Users are encouraged to pass in a memory buffered reader // (eg bufio.Reader, bytes.Buffer). -func NewDecoder(r io.Reader, h Handle) (d *Decoder) { - d = &Decoder{hh: h, h: h.getBasicHandle(), be: h.isBinary()} - // d.s = d.sa[:0] +func NewDecoder(r io.Reader, h Handle) *Decoder { + d := newDecoder(h) + d.Reset(r) + return d +} + +// NewDecoderBytes returns a Decoder which efficiently decodes directly +// from a byte slice with zero copying. +func NewDecoderBytes(in []byte, h Handle) *Decoder { + d := newDecoder(h) + d.ResetBytes(in) + return d +} + +func newDecoder(h Handle) *Decoder { + d := &Decoder{hh: h, h: h.getBasicHandle(), be: h.isBinary()} + n := &d.n + // n.rs = n.ra[:0] + n.ms = n.ma[:0] + n.is = n.ia[:0] + n.ns = n.na[:0] + n.ss = n.sa[:0] + _, d.js = h.(*JsonHandle) + if d.h.InternString { + d.is = make(map[string]string, 32) + } + d.d = h.newDecDriver(d) + d.cr, _ = d.d.(containerStateRecv) + // d.d = h.newDecDriver(decReaderT{true, &d.rb, &d.ri}) + return d +} + +func (d *Decoder) resetCommon() { + d.n.reset() + d.d.reset() + // reset all things which were cached from the Handle, + // but could be changed. + d.mtid, d.stid = 0, 0 + if d.h.MapType != nil { + d.mtid = reflect.ValueOf(d.h.MapType).Pointer() + } + if d.h.SliceType != nil { + d.stid = reflect.ValueOf(d.h.SliceType).Pointer() + } +} + +func (d *Decoder) Reset(r io.Reader) { d.ri.x = &d.b + // d.s = d.sa[:0] d.ri.bs.r = r var ok bool d.ri.br, ok = r.(decReaderByteScanner) @@ -1052,31 +1312,22 @@ func NewDecoder(r io.Reader, h Handle) (d *Decoder) { d.ri.br = &d.ri.bs } d.r = &d.ri - if d.h.InternString { - d.is = make(map[string]string, 32) - } - _, d.js = h.(*JsonHandle) - d.d = h.newDecDriver(d) - return + d.resetCommon() } -// NewDecoderBytes returns a Decoder which efficiently decodes directly -// from a byte slice with zero copying. -func NewDecoderBytes(in []byte, h Handle) (d *Decoder) { - d = &Decoder{hh: h, h: h.getBasicHandle(), be: h.isBinary(), bytes: true} +func (d *Decoder) ResetBytes(in []byte) { // d.s = d.sa[:0] - d.rb.b = in - d.rb.a = len(in) + d.rb.reset(in) d.r = &d.rb - if d.h.InternString { - d.is = make(map[string]string, 32) - } - _, d.js = h.(*JsonHandle) - d.d = h.newDecDriver(d) - // d.d = h.newDecDriver(decReaderT{true, &d.rb, &d.ri}) - return + d.resetCommon() } +// func (d *Decoder) sendContainerState(c containerState) { +// if d.cr != nil { +// d.cr.sendContainerState(c) +// } +// } + // Decode decodes the stream from reader and stores the result in the // value pointed to by v. v cannot be a nil pointer. v can also be // a reflect.Value of a pointer. @@ -1142,9 +1393,12 @@ func (d *Decoder) swallowViaHammer() { func (d *Decoder) swallow() { // smarter decode that just swallows the content dd := d.d - switch { - case dd.TryDecodeAsNil(): - case dd.IsContainerType(valueTypeMap): + if dd.TryDecodeAsNil() { + return + } + cr := d.cr + switch dd.ContainerType() { + case valueTypeMap: containerLen := dd.ReadMapStart() clenGtEqualZero := containerLen >= 0 for j := 0; ; j++ { @@ -1155,11 +1409,19 @@ func (d *Decoder) swallow() { } else if dd.CheckBreak() { break } + if cr != nil { + cr.sendContainerState(containerMapKey) + } d.swallow() + if cr != nil { + cr.sendContainerState(containerMapValue) + } d.swallow() } - dd.ReadEnd() - case dd.IsContainerType(valueTypeArray): + if cr != nil { + cr.sendContainerState(containerMapEnd) + } + case valueTypeArray: containerLenS := dd.ReadArrayStart() clenGtEqualZero := containerLenS >= 0 for j := 0; ; j++ { @@ -1170,17 +1432,30 @@ func (d *Decoder) swallow() { } else if dd.CheckBreak() { break } + if cr != nil { + cr.sendContainerState(containerArrayElem) + } d.swallow() } - dd.ReadEnd() - case dd.IsContainerType(valueTypeBytes): + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } + case valueTypeBytes: dd.DecodeBytes(d.b[:], false, true) - case dd.IsContainerType(valueTypeString): + case valueTypeString: dd.DecodeBytes(d.b[:], true, true) // dd.DecodeStringAsBytes(d.b[:]) default: // these are all primitives, which we can get from decodeNaked + // if RawExt using Value, complete the processing. dd.DecodeNaked() + if n := &d.n; n.v == valueTypeExt && n.l == nil { + l := len(n.is) + n.is = append(n.is, nil) + v2 := &n.is[l] + n.is = n.is[:l] + d.decode(v2) + } } } @@ -1230,14 +1505,20 @@ func (d *Decoder) decode(iv interface{}) { case *[]uint8: *v = nil case reflect.Value: - d.chkPtrValue(v) + if v.Kind() != reflect.Ptr || v.IsNil() { + d.errNotValidPtrValue(v) + } + // d.chkPtrValue(v) v = v.Elem() if v.IsValid() { v.Set(reflect.Zero(v.Type())) } default: rv := reflect.ValueOf(iv) - d.chkPtrValue(rv) + if rv.Kind() != reflect.Ptr || rv.IsNil() { + d.errNotValidPtrValue(rv) + } + // d.chkPtrValue(rv) rv = rv.Elem() if rv.IsValid() { rv.Set(reflect.Zero(rv.Type())) @@ -1255,7 +1536,10 @@ func (d *Decoder) decode(iv interface{}) { v.CodecDecodeSelf(d) case reflect.Value: - d.chkPtrValue(v) + if v.Kind() != reflect.Ptr || v.IsNil() { + d.errNotValidPtrValue(v) + } + // d.chkPtrValue(v) d.decodeValueNotNil(v.Elem(), nil) case *string: @@ -1325,7 +1609,10 @@ func (d *Decoder) preDecodeValue(rv reflect.Value, tryNil bool) (rv2 reflect.Val func (d *Decoder) decodeI(iv interface{}, checkPtr, tryNil, checkFastpath, checkCodecSelfer bool) { rv := reflect.ValueOf(iv) if checkPtr { - d.chkPtrValue(rv) + if rv.Kind() != reflect.Ptr || rv.IsNil() { + d.errNotValidPtrValue(rv) + } + // d.chkPtrValue(rv) } rv, proceed := d.preDecodeValue(rv, tryNil) if proceed { @@ -1529,6 +1816,10 @@ func (d *Decoder) chkPtrValue(rv reflect.Value) { if rv.Kind() == reflect.Ptr && !rv.IsNil() { return } + d.errNotValidPtrValue(rv) +} + +func (d *Decoder) errNotValidPtrValue(rv reflect.Value) { if !rv.IsValid() { d.error(cannotDecodeIntoNilErr) return @@ -1571,31 +1862,65 @@ func (d *Decoder) intern(s string) { } } +func (d *Decoder) nextValueBytes() []byte { + d.d.uncacheRead() + d.r.track() + d.swallow() + return d.r.stopTrack() +} + // -------------------------------------------------- // decSliceHelper assists when decoding into a slice, from a map or an array in the stream. // A slice can be set from a map or array in stream. This supports the MapBySlice interface. type decSliceHelper struct { - dd decDriver - ct valueType + d *Decoder + // ct valueType + array bool } func (d *Decoder) decSliceHelperStart() (x decSliceHelper, clen int) { - x.dd = d.d - if x.dd.IsContainerType(valueTypeArray) { - x.ct = valueTypeArray - clen = x.dd.ReadArrayStart() - } else if x.dd.IsContainerType(valueTypeMap) { - x.ct = valueTypeMap - clen = x.dd.ReadMapStart() * 2 + dd := d.d + ctyp := dd.ContainerType() + if ctyp == valueTypeArray { + x.array = true + clen = dd.ReadArrayStart() + } else if ctyp == valueTypeMap { + clen = dd.ReadMapStart() * 2 } else { - d.errorf("only encoded map or array can be decoded into a slice") + d.errorf("only encoded map or array can be decoded into a slice (%d)", ctyp) } + // x.ct = ctyp + x.d = d return } func (x decSliceHelper) End() { - x.dd.ReadEnd() + cr := x.d.cr + if cr == nil { + return + } + if x.array { + cr.sendContainerState(containerArrayEnd) + } else { + cr.sendContainerState(containerMapEnd) + } +} + +func (x decSliceHelper) ElemContainerState(index int) { + cr := x.d.cr + if cr == nil { + return + } + if x.array { + cr.sendContainerState(containerArrayElem) + } else { + if index%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } } func decByteSlice(r decReader, clen int, bs []byte) (bsOut []byte) { diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/encode.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/encode.go index 49c3a457716..99af6fa555a 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/encode.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/encode.go @@ -62,13 +62,14 @@ type encDriver interface { EncodeExt(v interface{}, xtag uint64, ext Ext, e *Encoder) EncodeArrayStart(length int) EncodeMapStart(length int) - EncodeEnd() EncodeString(c charEncoding, v string) EncodeSymbol(v string) EncodeStringBytes(c charEncoding, v []byte) //TODO //encBignum(f *big.Int) //encStringRunes(c charEncoding, v []rune) + + reset() } type encDriverAsis interface { @@ -158,6 +159,7 @@ func (o *simpleIoEncWriterWriter) Write(p []byte) (n int, err error) { // ioEncWriter implements encWriter and can write to an io.Writer implementation type ioEncWriter struct { w ioEncWriterWriter + s simpleIoEncWriterWriter // x [8]byte // temp byte array re-used internally for efficiency } @@ -382,30 +384,32 @@ func (f *encFnInfo) kSlice(rv reflect.Value) { // (don't call rv.Bytes, rv.Slice, etc). // E.g. type struct S{B [2]byte}; // Encode(S{}) will bomb on "panic: slice of unaddressable array". + e := f.e if f.seq != seqTypeArray { if rv.IsNil() { - f.e.e.EncodeNil() + e.e.EncodeNil() return } // If in this method, then there was no extension function defined. // So it's okay to treat as []byte. if ti.rtid == uint8SliceTypId { - f.e.e.EncodeStringBytes(c_RAW, rv.Bytes()) + e.e.EncodeStringBytes(c_RAW, rv.Bytes()) return } } + cr := e.cr rtelem := ti.rt.Elem() l := rv.Len() - if rtelem.Kind() == reflect.Uint8 { + if ti.rtid == uint8SliceTypId || rtelem.Kind() == reflect.Uint8 { switch f.seq { case seqTypeArray: - // if l == 0 { f.e.e.encodeStringBytes(c_RAW, nil) } else + // if l == 0 { e.e.encodeStringBytes(c_RAW, nil) } else if rv.CanAddr() { - f.e.e.EncodeStringBytes(c_RAW, rv.Slice(0, l).Bytes()) + e.e.EncodeStringBytes(c_RAW, rv.Slice(0, l).Bytes()) } else { var bs []byte - if l <= cap(f.e.b) { - bs = f.e.b[:l] + if l <= cap(e.b) { + bs = e.b[:l] } else { bs = make([]byte, l) } @@ -414,12 +418,12 @@ func (f *encFnInfo) kSlice(rv reflect.Value) { // for i := 0; i < l; i++ { // bs[i] = byte(rv.Index(i).Uint()) // } - f.e.e.EncodeStringBytes(c_RAW, bs) + e.e.EncodeStringBytes(c_RAW, bs) } case seqTypeSlice: - f.e.e.EncodeStringBytes(c_RAW, rv.Bytes()) + e.e.EncodeStringBytes(c_RAW, rv.Bytes()) case seqTypeChan: - bs := f.e.b[:0] + bs := e.b[:0] // 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. // for b := range rv.Interface().(<-chan byte) { @@ -429,22 +433,21 @@ func (f *encFnInfo) kSlice(rv reflect.Value) { for i := 0; i < l; i++ { bs = append(bs, <-ch) } - f.e.e.EncodeStringBytes(c_RAW, bs) + e.e.EncodeStringBytes(c_RAW, bs) } return } if ti.mbs { if l%2 == 1 { - f.e.errorf("mapBySlice requires even slice length, but got %v", l) + e.errorf("mapBySlice requires even slice length, but got %v", l) return } - f.e.e.EncodeMapStart(l / 2) + e.e.EncodeMapStart(l / 2) } else { - f.e.e.EncodeArrayStart(l) + e.e.EncodeArrayStart(l) } - e := f.e if l > 0 { for rtelem.Kind() == reflect.Ptr { rtelem = rtelem.Elem() @@ -459,29 +462,48 @@ func (f *encFnInfo) kSlice(rv reflect.Value) { } // TODO: Consider perf implication of encoding odd index values as symbols if type is string for j := 0; j < l; j++ { + if cr != nil { + if ti.mbs { + if l%2 == 0 { + cr.sendContainerState(containerMapKey) + } else { + cr.sendContainerState(containerMapValue) + } + } else { + cr.sendContainerState(containerArrayElem) + } + } if f.seq == seqTypeChan { if rv2, ok2 := rv.Recv(); ok2 { e.encodeValue(rv2, fn) + } else { + e.encode(nil) // WE HAVE TO DO SOMETHING, so nil if nothing received. } } else { e.encodeValue(rv.Index(j), fn) } } - } - f.e.e.EncodeEnd() + if cr != nil { + if ti.mbs { + cr.sendContainerState(containerMapEnd) + } else { + cr.sendContainerState(containerArrayEnd) + } + } } func (f *encFnInfo) kStruct(rv reflect.Value) { fti := f.ti e := f.e + cr := e.cr tisfi := fti.sfip toMap := !(fti.toArray || e.h.StructToArray) newlen := len(fti.sfi) // Use sync.Pool to reduce allocating slices unnecessarily. - // The cost of the occasional locking is less than the cost of locking. + // The cost of the occasional locking is less than the cost of new allocation. pool, poolv, fkvs := encStructPoolGet(newlen) // if toMap, use the sorted array. If toArray, use unsorted array (to match sequence in struct) @@ -519,7 +541,7 @@ func (f *encFnInfo) kStruct(rv reflect.Value) { // debugf(">>>> kStruct: newlen: %v", newlen) // sep := !e.be - ee := f.e.e //don't dereference everytime + ee := e.e //don't dereference everytime if toMap { ee.EncodeMapStart(newlen) @@ -527,21 +549,35 @@ func (f *encFnInfo) kStruct(rv reflect.Value) { asSymbols := e.h.AsSymbols == AsSymbolDefault || e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0 for j := 0; j < newlen; j++ { kv = fkvs[j] + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(kv.v) } else { ee.EncodeString(c_UTF8, kv.v) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encodeValue(kv.r, nil) } + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } else { ee.EncodeArrayStart(newlen) for j := 0; j < newlen; j++ { kv = fkvs[j] + if cr != nil { + cr.sendContainerState(containerArrayElem) + } e.encodeValue(kv.r, nil) } + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } - ee.EncodeEnd() // do not use defer. Instead, use explicit pool return at end of function. // defer has a cost we are trying to avoid. @@ -578,8 +614,11 @@ func (f *encFnInfo) kMap(rv reflect.Value) { l := rv.Len() ee.EncodeMapStart(l) e := f.e + cr := e.cr if l == 0 { - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } return } var asSymbols bool @@ -622,6 +661,9 @@ func (f *encFnInfo) kMap(rv reflect.Value) { e.kMapCanonical(rtkeyid, rtkey, rv, mks, valFn, asSymbols) } else { for j := range mks { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if keyTypeIsString { if asSymbols { ee.EncodeSymbol(mks[j].String()) @@ -631,15 +673,20 @@ func (f *encFnInfo) kMap(rv reflect.Value) { } else { e.encodeValue(mks[j], keyFn) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encodeValue(rv.MapIndex(mks[j]), valFn) } } - - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect.Value, mks []reflect.Value, valFn *encFn, asSymbols bool) { ee := e.e + cr := e.cr // we previously did out-of-band if an extension was registered. // This is not necessary, as the natural kind is sufficient for ordering. @@ -652,7 +699,13 @@ func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect. } sort.Sort(bytesRvSlice(mksv)) for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeStringBytes(c_RAW, mksv[i].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encodeValue(rv.MapIndex(mksv[i].r), valFn) } } else { @@ -666,7 +719,13 @@ func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect. } sort.Sort(boolRvSlice(mksv)) for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(mksv[i].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encodeValue(rv.MapIndex(mksv[i].r), valFn) } case reflect.String: @@ -678,11 +737,17 @@ func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect. } sort.Sort(stringRvSlice(mksv)) for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(mksv[i].v) } else { ee.EncodeString(c_UTF8, mksv[i].v) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encodeValue(rv.MapIndex(mksv[i].r), valFn) } case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr: @@ -694,7 +759,13 @@ func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect. } sort.Sort(uintRvSlice(mksv)) for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(mksv[i].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encodeValue(rv.MapIndex(mksv[i].r), valFn) } case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: @@ -706,7 +777,13 @@ func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect. } sort.Sort(intRvSlice(mksv)) for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(mksv[i].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encodeValue(rv.MapIndex(mksv[i].r), valFn) } case reflect.Float32: @@ -718,7 +795,13 @@ func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect. } sort.Sort(floatRvSlice(mksv)) for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(mksv[i].v)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encodeValue(rv.MapIndex(mksv[i].r), valFn) } case reflect.Float64: @@ -730,7 +813,13 @@ func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect. } sort.Sort(floatRvSlice(mksv)) for i := range mksv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(mksv[i].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encodeValue(rv.MapIndex(mksv[i].r), valFn) } default: @@ -749,7 +838,13 @@ func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect. } sort.Sort(bytesRvSlice(mksbv)) for j := range mksbv { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(mksbv[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encodeValue(rv.MapIndex(mksbv[j].r), valFn) } } @@ -787,12 +882,15 @@ type Encoder struct { wi ioEncWriter wb bytesEncWriter - h *BasicHandle - as encDriverAsis + h *BasicHandle hh Handle - f map[uintptr]*encFn - b [scratchByteArrayLen]byte + + cr containerStateRecv + as encDriverAsis + + f map[uintptr]*encFn + b [scratchByteArrayLen]byte } // NewEncoder returns an Encoder for encoding into an io.Writer. @@ -800,20 +898,8 @@ type Encoder struct { // For efficiency, Users are encouraged to pass in a memory buffered writer // (eg bufio.Writer, bytes.Buffer). func NewEncoder(w io.Writer, h Handle) *Encoder { - e := &Encoder{hh: h, h: h.getBasicHandle(), be: h.isBinary()} - ww, ok := w.(ioEncWriterWriter) - if !ok { - sww := simpleIoEncWriterWriter{w: w} - sww.bw, _ = w.(io.ByteWriter) - sww.sw, _ = w.(ioEncStringWriter) - ww = &sww - //ww = bufio.NewWriterSize(w, defEncByteBufSize) - } - e.wi.w = ww - e.w = &e.wi - _, e.js = h.(*JsonHandle) - e.e = h.newEncDriver(e) - e.as, _ = e.e.(encDriverAsis) + e := newEncoder(h) + e.Reset(w) return e } @@ -823,19 +909,56 @@ func NewEncoder(w io.Writer, h Handle) *Encoder { // It will potentially replace the output byte slice pointed to. // After encoding, the out parameter contains the encoded contents. func NewEncoderBytes(out *[]byte, h Handle) *Encoder { + e := newEncoder(h) + e.ResetBytes(out) + return e +} + +func newEncoder(h Handle) *Encoder { e := &Encoder{hh: h, h: h.getBasicHandle(), be: h.isBinary()} + _, e.js = h.(*JsonHandle) + e.e = h.newEncDriver(e) + e.as, _ = e.e.(encDriverAsis) + e.cr, _ = e.e.(containerStateRecv) + return e +} + +// Reset the Encoder with a new output stream. +// +// This accomodates using the state of the Encoder, +// where it has "cached" information about sub-engines. +func (e *Encoder) Reset(w io.Writer) { + ww, ok := w.(ioEncWriterWriter) + if ok { + e.wi.w = ww + } else { + sww := &e.wi.s + sww.w = w + sww.bw, _ = w.(io.ByteWriter) + sww.sw, _ = w.(ioEncStringWriter) + e.wi.w = sww + //ww = bufio.NewWriterSize(w, defEncByteBufSize) + } + e.w = &e.wi + e.e.reset() +} + +func (e *Encoder) ResetBytes(out *[]byte) { in := *out if in == nil { in = make([]byte, defEncByteBufSize) } - e.wb.b, e.wb.out = in, out + e.wb.b, e.wb.out, e.wb.c = in, out, 0 e.w = &e.wb - _, e.js = h.(*JsonHandle) - e.e = h.newEncDriver(e) - e.as, _ = e.e.(encDriverAsis) - return e + e.e.reset() } +// func (e *Encoder) sendContainerState(c containerState) { +// if e.cr != nil { +// e.cr.sendContainerState(c) +// } +// } + // Encode writes an object into a stream. // // Encoding can be configured via the struct tag for the fields. @@ -1020,26 +1143,24 @@ func (e *Encoder) encodeI(iv interface{}, checkFastpath, checkCodecSelfer bool) } func (e *Encoder) preEncodeValue(rv reflect.Value) (rv2 reflect.Value, proceed bool) { -LOOP: - for { - switch rv.Kind() { - case reflect.Ptr, reflect.Interface: - if rv.IsNil() { - e.e.EncodeNil() - return - } - rv = rv.Elem() - continue LOOP - case reflect.Slice, reflect.Map: - if rv.IsNil() { - e.e.EncodeNil() - return - } - case reflect.Invalid, reflect.Func: + // use a goto statement instead of a recursive function for ptr/interface. +TOP: + switch rv.Kind() { + case reflect.Ptr, reflect.Interface: + if rv.IsNil() { e.e.EncodeNil() return } - break + rv = rv.Elem() + goto TOP + case reflect.Slice, reflect.Map: + if rv.IsNil() { + e.e.EncodeNil() + return + } + case reflect.Invalid, reflect.Func: + e.e.EncodeNil() + return } return rv, true diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.generated.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.generated.go index cb5d6a694e9..d968a500fde 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.generated.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.generated.go @@ -1,4 +1,4 @@ -// //+build ignore +// +build !notfastpath // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. // Use of this source code is governed by a MIT license found in the LICENSE file. @@ -373,6 +373,9 @@ func init() { // -- -- fast path type switch func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool { + if !fastpathEnabled { + return false + } switch v := iv.(type) { case []interface{}: @@ -1731,12 +1734,16 @@ func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool { fastpathTV.EncMapBoolBoolV(*v, fastpathCheckNilTrue, e) default: + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) return false } return true } func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { + if !fastpathEnabled { + return false + } switch v := iv.(type) { case []interface{}: @@ -1815,12 +1822,16 @@ func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { fastpathTV.EncSliceBoolV(*v, fastpathCheckNilTrue, e) default: + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) return false } return true } func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool { + if !fastpathEnabled { + return false + } switch v := iv.(type) { case map[interface{}]interface{}: @@ -3117,15 +3128,21 @@ func (f *encFnInfo) fastpathEncSliceIntfR(rv reflect.Value) { } func (_ fastpathT) EncSliceIntfV(v []interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } e.encode(v2) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceStringR(rv reflect.Value) { @@ -3133,15 +3150,21 @@ func (f *encFnInfo) fastpathEncSliceStringR(rv reflect.Value) { } func (_ fastpathT) EncSliceStringV(v []string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeString(c_UTF8, v2) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceFloat32R(rv reflect.Value) { @@ -3149,15 +3172,21 @@ func (f *encFnInfo) fastpathEncSliceFloat32R(rv reflect.Value) { } func (_ fastpathT) EncSliceFloat32V(v []float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeFloat32(v2) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceFloat64R(rv reflect.Value) { @@ -3165,15 +3194,21 @@ func (f *encFnInfo) fastpathEncSliceFloat64R(rv reflect.Value) { } func (_ fastpathT) EncSliceFloat64V(v []float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeFloat64(v2) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceUintR(rv reflect.Value) { @@ -3181,15 +3216,21 @@ func (f *encFnInfo) fastpathEncSliceUintR(rv reflect.Value) { } func (_ fastpathT) EncSliceUintV(v []uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeUint(uint64(v2)) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceUint16R(rv reflect.Value) { @@ -3197,15 +3238,21 @@ func (f *encFnInfo) fastpathEncSliceUint16R(rv reflect.Value) { } func (_ fastpathT) EncSliceUint16V(v []uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeUint(uint64(v2)) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceUint32R(rv reflect.Value) { @@ -3213,15 +3260,21 @@ func (f *encFnInfo) fastpathEncSliceUint32R(rv reflect.Value) { } func (_ fastpathT) EncSliceUint32V(v []uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeUint(uint64(v2)) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceUint64R(rv reflect.Value) { @@ -3229,15 +3282,21 @@ func (f *encFnInfo) fastpathEncSliceUint64R(rv reflect.Value) { } func (_ fastpathT) EncSliceUint64V(v []uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeUint(uint64(v2)) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceUintptrR(rv reflect.Value) { @@ -3245,15 +3304,21 @@ func (f *encFnInfo) fastpathEncSliceUintptrR(rv reflect.Value) { } func (_ fastpathT) EncSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } e.encode(v2) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceIntR(rv reflect.Value) { @@ -3261,15 +3326,21 @@ func (f *encFnInfo) fastpathEncSliceIntR(rv reflect.Value) { } func (_ fastpathT) EncSliceIntV(v []int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeInt(int64(v2)) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceInt8R(rv reflect.Value) { @@ -3277,15 +3348,21 @@ func (f *encFnInfo) fastpathEncSliceInt8R(rv reflect.Value) { } func (_ fastpathT) EncSliceInt8V(v []int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeInt(int64(v2)) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceInt16R(rv reflect.Value) { @@ -3293,15 +3370,21 @@ func (f *encFnInfo) fastpathEncSliceInt16R(rv reflect.Value) { } func (_ fastpathT) EncSliceInt16V(v []int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeInt(int64(v2)) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceInt32R(rv reflect.Value) { @@ -3309,15 +3392,21 @@ func (f *encFnInfo) fastpathEncSliceInt32R(rv reflect.Value) { } func (_ fastpathT) EncSliceInt32V(v []int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeInt(int64(v2)) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceInt64R(rv reflect.Value) { @@ -3325,15 +3414,21 @@ func (f *encFnInfo) fastpathEncSliceInt64R(rv reflect.Value) { } func (_ fastpathT) EncSliceInt64V(v []int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeInt(int64(v2)) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncSliceBoolR(rv reflect.Value) { @@ -3341,15 +3436,21 @@ func (f *encFnInfo) fastpathEncSliceBoolR(rv reflect.Value) { } func (_ fastpathT) EncSliceBoolV(v []bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { + cr.sendContainerState(containerArrayElem) + } ee.EncodeBool(v2) } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerArrayEnd) + } } func (f *encFnInfo) fastpathEncMapIntfIntfR(rv reflect.Value) { @@ -3357,6 +3458,7 @@ func (f *encFnInfo) fastpathEncMapIntfIntfR(rv reflect.Value) { } func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3378,16 +3480,30 @@ func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfStringR(rv reflect.Value) { @@ -3395,6 +3511,7 @@ func (f *encFnInfo) fastpathEncMapIntfStringR(rv reflect.Value) { } func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3416,16 +3533,30 @@ func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, checkNil bool, e } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfUintR(rv reflect.Value) { @@ -3433,6 +3564,7 @@ func (f *encFnInfo) fastpathEncMapIntfUintR(rv reflect.Value) { } func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3454,16 +3586,30 @@ func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, checkNil bool, e *Enc } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfUint8R(rv reflect.Value) { @@ -3471,6 +3617,7 @@ func (f *encFnInfo) fastpathEncMapIntfUint8R(rv reflect.Value) { } func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3492,16 +3639,30 @@ func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, checkNil bool, e *E } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfUint16R(rv reflect.Value) { @@ -3509,6 +3670,7 @@ func (f *encFnInfo) fastpathEncMapIntfUint16R(rv reflect.Value) { } func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3530,16 +3692,30 @@ func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, checkNil bool, e } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfUint32R(rv reflect.Value) { @@ -3547,6 +3723,7 @@ func (f *encFnInfo) fastpathEncMapIntfUint32R(rv reflect.Value) { } func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3568,16 +3745,30 @@ func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, checkNil bool, e } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfUint64R(rv reflect.Value) { @@ -3585,6 +3776,7 @@ func (f *encFnInfo) fastpathEncMapIntfUint64R(rv reflect.Value) { } func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3606,16 +3798,30 @@ func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, checkNil bool, e } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfUintptrR(rv reflect.Value) { @@ -3623,6 +3829,7 @@ func (f *encFnInfo) fastpathEncMapIntfUintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3644,16 +3851,30 @@ func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfIntR(rv reflect.Value) { @@ -3661,6 +3882,7 @@ func (f *encFnInfo) fastpathEncMapIntfIntR(rv reflect.Value) { } func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3682,16 +3904,30 @@ func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, checkNil bool, e *Encod } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfInt8R(rv reflect.Value) { @@ -3699,6 +3935,7 @@ func (f *encFnInfo) fastpathEncMapIntfInt8R(rv reflect.Value) { } func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3720,16 +3957,30 @@ func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, checkNil bool, e *Enc } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfInt16R(rv reflect.Value) { @@ -3737,6 +3988,7 @@ func (f *encFnInfo) fastpathEncMapIntfInt16R(rv reflect.Value) { } func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3758,16 +4010,30 @@ func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, checkNil bool, e *E } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfInt32R(rv reflect.Value) { @@ -3775,6 +4041,7 @@ func (f *encFnInfo) fastpathEncMapIntfInt32R(rv reflect.Value) { } func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3796,16 +4063,30 @@ func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, checkNil bool, e *E } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfInt64R(rv reflect.Value) { @@ -3813,6 +4094,7 @@ func (f *encFnInfo) fastpathEncMapIntfInt64R(rv reflect.Value) { } func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3834,16 +4116,30 @@ func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, checkNil bool, e *E } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfFloat32R(rv reflect.Value) { @@ -3851,6 +4147,7 @@ func (f *encFnInfo) fastpathEncMapIntfFloat32R(rv reflect.Value) { } func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3872,16 +4169,30 @@ func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, checkNil bool, } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfFloat64R(rv reflect.Value) { @@ -3889,6 +4200,7 @@ func (f *encFnInfo) fastpathEncMapIntfFloat64R(rv reflect.Value) { } func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3910,16 +4222,30 @@ func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, checkNil bool, } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntfBoolR(rv reflect.Value) { @@ -3927,6 +4253,7 @@ func (f *encFnInfo) fastpathEncMapIntfBoolR(rv reflect.Value) { } func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3948,16 +4275,30 @@ func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, checkNil bool, e *Enc } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.asis(v2[j].v) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[v2[j].i]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringIntfR(rv reflect.Value) { @@ -3965,6 +4306,7 @@ func (f *encFnInfo) fastpathEncMapStringIntfR(rv reflect.Value) { } func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -3980,24 +4322,38 @@ func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, checkNil bool, e } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[string(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringStringR(rv reflect.Value) { @@ -4005,6 +4361,7 @@ func (f *encFnInfo) fastpathEncMapStringStringR(rv reflect.Value) { } func (_ fastpathT) EncMapStringStringV(v map[string]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4020,24 +4377,38 @@ func (_ fastpathT) EncMapStringStringV(v map[string]string, checkNil bool, e *En } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[string(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringUintR(rv reflect.Value) { @@ -4045,6 +4416,7 @@ func (f *encFnInfo) fastpathEncMapStringUintR(rv reflect.Value) { } func (_ fastpathT) EncMapStringUintV(v map[string]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4060,24 +4432,38 @@ func (_ fastpathT) EncMapStringUintV(v map[string]uint, checkNil bool, e *Encode } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[string(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringUint8R(rv reflect.Value) { @@ -4085,6 +4471,7 @@ func (f *encFnInfo) fastpathEncMapStringUint8R(rv reflect.Value) { } func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4100,24 +4487,38 @@ func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, checkNil bool, e *Enco } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[string(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringUint16R(rv reflect.Value) { @@ -4125,6 +4526,7 @@ func (f *encFnInfo) fastpathEncMapStringUint16R(rv reflect.Value) { } func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4140,24 +4542,38 @@ func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, checkNil bool, e *En } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[string(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringUint32R(rv reflect.Value) { @@ -4165,6 +4581,7 @@ func (f *encFnInfo) fastpathEncMapStringUint32R(rv reflect.Value) { } func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4180,24 +4597,38 @@ func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, checkNil bool, e *En } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[string(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringUint64R(rv reflect.Value) { @@ -4205,6 +4636,7 @@ func (f *encFnInfo) fastpathEncMapStringUint64R(rv reflect.Value) { } func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4220,24 +4652,38 @@ func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, checkNil bool, e *En } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[string(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringUintptrR(rv reflect.Value) { @@ -4245,6 +4691,7 @@ func (f *encFnInfo) fastpathEncMapStringUintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4260,24 +4707,38 @@ func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, checkNil bool, e * } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[string(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringIntR(rv reflect.Value) { @@ -4285,6 +4746,7 @@ func (f *encFnInfo) fastpathEncMapStringIntR(rv reflect.Value) { } func (_ fastpathT) EncMapStringIntV(v map[string]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4300,24 +4762,38 @@ func (_ fastpathT) EncMapStringIntV(v map[string]int, checkNil bool, e *Encoder) } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[string(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringInt8R(rv reflect.Value) { @@ -4325,6 +4801,7 @@ func (f *encFnInfo) fastpathEncMapStringInt8R(rv reflect.Value) { } func (_ fastpathT) EncMapStringInt8V(v map[string]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4340,24 +4817,38 @@ func (_ fastpathT) EncMapStringInt8V(v map[string]int8, checkNil bool, e *Encode } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[string(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringInt16R(rv reflect.Value) { @@ -4365,6 +4856,7 @@ func (f *encFnInfo) fastpathEncMapStringInt16R(rv reflect.Value) { } func (_ fastpathT) EncMapStringInt16V(v map[string]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4380,24 +4872,38 @@ func (_ fastpathT) EncMapStringInt16V(v map[string]int16, checkNil bool, e *Enco } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[string(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringInt32R(rv reflect.Value) { @@ -4405,6 +4911,7 @@ func (f *encFnInfo) fastpathEncMapStringInt32R(rv reflect.Value) { } func (_ fastpathT) EncMapStringInt32V(v map[string]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4420,24 +4927,38 @@ func (_ fastpathT) EncMapStringInt32V(v map[string]int32, checkNil bool, e *Enco } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[string(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringInt64R(rv reflect.Value) { @@ -4445,6 +4966,7 @@ func (f *encFnInfo) fastpathEncMapStringInt64R(rv reflect.Value) { } func (_ fastpathT) EncMapStringInt64V(v map[string]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4460,24 +4982,38 @@ func (_ fastpathT) EncMapStringInt64V(v map[string]int64, checkNil bool, e *Enco } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[string(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringFloat32R(rv reflect.Value) { @@ -4485,6 +5021,7 @@ func (f *encFnInfo) fastpathEncMapStringFloat32R(rv reflect.Value) { } func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4500,24 +5037,38 @@ func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, checkNil bool, e * } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[string(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringFloat64R(rv reflect.Value) { @@ -4525,6 +5076,7 @@ func (f *encFnInfo) fastpathEncMapStringFloat64R(rv reflect.Value) { } func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4540,24 +5092,38 @@ func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, checkNil bool, e * } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[string(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapStringBoolR(rv reflect.Value) { @@ -4565,6 +5131,7 @@ func (f *encFnInfo) fastpathEncMapStringBoolR(rv reflect.Value) { } func (_ fastpathT) EncMapStringBoolV(v map[string]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4580,24 +5147,38 @@ func (_ fastpathT) EncMapStringBoolV(v map[string]bool, checkNil bool, e *Encode } sort.Sort(stringSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[string(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32IntfR(rv reflect.Value) { @@ -4605,6 +5186,7 @@ func (f *encFnInfo) fastpathEncMapFloat32IntfR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4619,16 +5201,30 @@ func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, checkNil bool, } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[float32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32StringR(rv reflect.Value) { @@ -4636,6 +5232,7 @@ func (f *encFnInfo) fastpathEncMapFloat32StringR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4650,16 +5247,30 @@ func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, checkNil bool, e * } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[float32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32UintR(rv reflect.Value) { @@ -4667,6 +5278,7 @@ func (f *encFnInfo) fastpathEncMapFloat32UintR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4681,16 +5293,30 @@ func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, checkNil bool, e *Enco } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[float32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32Uint8R(rv reflect.Value) { @@ -4698,6 +5324,7 @@ func (f *encFnInfo) fastpathEncMapFloat32Uint8R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4712,16 +5339,30 @@ func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, checkNil bool, e *En } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[float32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32Uint16R(rv reflect.Value) { @@ -4729,6 +5370,7 @@ func (f *encFnInfo) fastpathEncMapFloat32Uint16R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4743,16 +5385,30 @@ func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, checkNil bool, e * } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[float32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32Uint32R(rv reflect.Value) { @@ -4760,6 +5416,7 @@ func (f *encFnInfo) fastpathEncMapFloat32Uint32R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4774,16 +5431,30 @@ func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, checkNil bool, e * } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[float32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32Uint64R(rv reflect.Value) { @@ -4791,6 +5462,7 @@ func (f *encFnInfo) fastpathEncMapFloat32Uint64R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4805,16 +5477,30 @@ func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, checkNil bool, e * } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[float32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32UintptrR(rv reflect.Value) { @@ -4822,6 +5508,7 @@ func (f *encFnInfo) fastpathEncMapFloat32UintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4836,16 +5523,30 @@ func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, e } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[float32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32IntR(rv reflect.Value) { @@ -4853,6 +5554,7 @@ func (f *encFnInfo) fastpathEncMapFloat32IntR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4867,16 +5569,30 @@ func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, checkNil bool, e *Encode } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[float32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32Int8R(rv reflect.Value) { @@ -4884,6 +5600,7 @@ func (f *encFnInfo) fastpathEncMapFloat32Int8R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4898,16 +5615,30 @@ func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, checkNil bool, e *Enco } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[float32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32Int16R(rv reflect.Value) { @@ -4915,6 +5646,7 @@ func (f *encFnInfo) fastpathEncMapFloat32Int16R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4929,16 +5661,30 @@ func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, checkNil bool, e *En } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[float32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32Int32R(rv reflect.Value) { @@ -4946,6 +5692,7 @@ func (f *encFnInfo) fastpathEncMapFloat32Int32R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4960,16 +5707,30 @@ func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, checkNil bool, e *En } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[float32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32Int64R(rv reflect.Value) { @@ -4977,6 +5738,7 @@ func (f *encFnInfo) fastpathEncMapFloat32Int64R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -4991,16 +5753,30 @@ func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, checkNil bool, e *En } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[float32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32Float32R(rv reflect.Value) { @@ -5008,6 +5784,7 @@ func (f *encFnInfo) fastpathEncMapFloat32Float32R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5022,16 +5799,30 @@ func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, checkNil bool, e } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[float32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32Float64R(rv reflect.Value) { @@ -5039,6 +5830,7 @@ func (f *encFnInfo) fastpathEncMapFloat32Float64R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5053,16 +5845,30 @@ func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, checkNil bool, e } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[float32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat32BoolR(rv reflect.Value) { @@ -5070,6 +5876,7 @@ func (f *encFnInfo) fastpathEncMapFloat32BoolR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5084,16 +5891,30 @@ func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, checkNil bool, e *Enco } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(float32(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[float32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat32(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64IntfR(rv reflect.Value) { @@ -5101,6 +5922,7 @@ func (f *encFnInfo) fastpathEncMapFloat64IntfR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5115,16 +5937,30 @@ func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, checkNil bool, } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[float64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64StringR(rv reflect.Value) { @@ -5132,6 +5968,7 @@ func (f *encFnInfo) fastpathEncMapFloat64StringR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5146,16 +5983,30 @@ func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, checkNil bool, e * } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[float64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64UintR(rv reflect.Value) { @@ -5163,6 +6014,7 @@ func (f *encFnInfo) fastpathEncMapFloat64UintR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5177,16 +6029,30 @@ func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, checkNil bool, e *Enco } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[float64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64Uint8R(rv reflect.Value) { @@ -5194,6 +6060,7 @@ func (f *encFnInfo) fastpathEncMapFloat64Uint8R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5208,16 +6075,30 @@ func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, checkNil bool, e *En } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[float64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64Uint16R(rv reflect.Value) { @@ -5225,6 +6106,7 @@ func (f *encFnInfo) fastpathEncMapFloat64Uint16R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5239,16 +6121,30 @@ func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, checkNil bool, e * } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[float64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64Uint32R(rv reflect.Value) { @@ -5256,6 +6152,7 @@ func (f *encFnInfo) fastpathEncMapFloat64Uint32R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5270,16 +6167,30 @@ func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, checkNil bool, e * } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[float64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64Uint64R(rv reflect.Value) { @@ -5287,6 +6198,7 @@ func (f *encFnInfo) fastpathEncMapFloat64Uint64R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5301,16 +6213,30 @@ func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, checkNil bool, e * } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[float64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64UintptrR(rv reflect.Value) { @@ -5318,6 +6244,7 @@ func (f *encFnInfo) fastpathEncMapFloat64UintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5332,16 +6259,30 @@ func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, e } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[float64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64IntR(rv reflect.Value) { @@ -5349,6 +6290,7 @@ func (f *encFnInfo) fastpathEncMapFloat64IntR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5363,16 +6305,30 @@ func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, checkNil bool, e *Encode } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[float64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64Int8R(rv reflect.Value) { @@ -5380,6 +6336,7 @@ func (f *encFnInfo) fastpathEncMapFloat64Int8R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5394,16 +6351,30 @@ func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, checkNil bool, e *Enco } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[float64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64Int16R(rv reflect.Value) { @@ -5411,6 +6382,7 @@ func (f *encFnInfo) fastpathEncMapFloat64Int16R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5425,16 +6397,30 @@ func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, checkNil bool, e *En } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[float64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64Int32R(rv reflect.Value) { @@ -5442,6 +6428,7 @@ func (f *encFnInfo) fastpathEncMapFloat64Int32R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5456,16 +6443,30 @@ func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, checkNil bool, e *En } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[float64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64Int64R(rv reflect.Value) { @@ -5473,6 +6474,7 @@ func (f *encFnInfo) fastpathEncMapFloat64Int64R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5487,16 +6489,30 @@ func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, checkNil bool, e *En } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[float64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64Float32R(rv reflect.Value) { @@ -5504,6 +6520,7 @@ func (f *encFnInfo) fastpathEncMapFloat64Float32R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5518,16 +6535,30 @@ func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, checkNil bool, e } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[float64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64Float64R(rv reflect.Value) { @@ -5535,6 +6566,7 @@ func (f *encFnInfo) fastpathEncMapFloat64Float64R(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5549,16 +6581,30 @@ func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, checkNil bool, e } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[float64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapFloat64BoolR(rv reflect.Value) { @@ -5566,6 +6612,7 @@ func (f *encFnInfo) fastpathEncMapFloat64BoolR(rv reflect.Value) { } func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5580,16 +6627,30 @@ func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, checkNil bool, e *Enco } sort.Sort(floatSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(float64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[float64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeFloat64(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintIntfR(rv reflect.Value) { @@ -5597,6 +6658,7 @@ func (f *encFnInfo) fastpathEncMapUintIntfR(rv reflect.Value) { } func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5611,16 +6673,30 @@ func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, checkNil bool, e *Enc } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uint(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintStringR(rv reflect.Value) { @@ -5628,6 +6704,7 @@ func (f *encFnInfo) fastpathEncMapUintStringR(rv reflect.Value) { } func (_ fastpathT) EncMapUintStringV(v map[uint]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5642,16 +6719,30 @@ func (_ fastpathT) EncMapUintStringV(v map[uint]string, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[uint(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintUintR(rv reflect.Value) { @@ -5659,6 +6750,7 @@ func (f *encFnInfo) fastpathEncMapUintUintR(rv reflect.Value) { } func (_ fastpathT) EncMapUintUintV(v map[uint]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5673,16 +6765,30 @@ func (_ fastpathT) EncMapUintUintV(v map[uint]uint, checkNil bool, e *Encoder) { } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintUint8R(rv reflect.Value) { @@ -5690,6 +6796,7 @@ func (f *encFnInfo) fastpathEncMapUintUint8R(rv reflect.Value) { } func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5704,16 +6811,30 @@ func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, checkNil bool, e *Encoder) } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintUint16R(rv reflect.Value) { @@ -5721,6 +6842,7 @@ func (f *encFnInfo) fastpathEncMapUintUint16R(rv reflect.Value) { } func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5735,16 +6857,30 @@ func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintUint32R(rv reflect.Value) { @@ -5752,6 +6888,7 @@ func (f *encFnInfo) fastpathEncMapUintUint32R(rv reflect.Value) { } func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5766,16 +6903,30 @@ func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintUint64R(rv reflect.Value) { @@ -5783,6 +6934,7 @@ func (f *encFnInfo) fastpathEncMapUintUint64R(rv reflect.Value) { } func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5797,16 +6949,30 @@ func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintUintptrR(rv reflect.Value) { @@ -5814,6 +6980,7 @@ func (f *encFnInfo) fastpathEncMapUintUintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5828,16 +6995,30 @@ func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uint(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintIntR(rv reflect.Value) { @@ -5845,6 +7026,7 @@ func (f *encFnInfo) fastpathEncMapUintIntR(rv reflect.Value) { } func (_ fastpathT) EncMapUintIntV(v map[uint]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5859,16 +7041,30 @@ func (_ fastpathT) EncMapUintIntV(v map[uint]int, checkNil bool, e *Encoder) { } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintInt8R(rv reflect.Value) { @@ -5876,6 +7072,7 @@ func (f *encFnInfo) fastpathEncMapUintInt8R(rv reflect.Value) { } func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5890,16 +7087,30 @@ func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, checkNil bool, e *Encoder) { } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintInt16R(rv reflect.Value) { @@ -5907,6 +7118,7 @@ func (f *encFnInfo) fastpathEncMapUintInt16R(rv reflect.Value) { } func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5921,16 +7133,30 @@ func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, checkNil bool, e *Encoder) } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintInt32R(rv reflect.Value) { @@ -5938,6 +7164,7 @@ func (f *encFnInfo) fastpathEncMapUintInt32R(rv reflect.Value) { } func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5952,16 +7179,30 @@ func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, checkNil bool, e *Encoder) } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintInt64R(rv reflect.Value) { @@ -5969,6 +7210,7 @@ func (f *encFnInfo) fastpathEncMapUintInt64R(rv reflect.Value) { } func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -5983,16 +7225,30 @@ func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, checkNil bool, e *Encoder) } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintFloat32R(rv reflect.Value) { @@ -6000,6 +7256,7 @@ func (f *encFnInfo) fastpathEncMapUintFloat32R(rv reflect.Value) { } func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6014,16 +7271,30 @@ func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[uint(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintFloat64R(rv reflect.Value) { @@ -6031,6 +7302,7 @@ func (f *encFnInfo) fastpathEncMapUintFloat64R(rv reflect.Value) { } func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6045,16 +7317,30 @@ func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[uint(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintBoolR(rv reflect.Value) { @@ -6062,6 +7348,7 @@ func (f *encFnInfo) fastpathEncMapUintBoolR(rv reflect.Value) { } func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6076,16 +7363,30 @@ func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, checkNil bool, e *Encoder) { } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[uint(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8IntfR(rv reflect.Value) { @@ -6093,6 +7394,7 @@ func (f *encFnInfo) fastpathEncMapUint8IntfR(rv reflect.Value) { } func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6107,16 +7409,30 @@ func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, checkNil bool, e *E } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uint8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8StringR(rv reflect.Value) { @@ -6124,6 +7440,7 @@ func (f *encFnInfo) fastpathEncMapUint8StringR(rv reflect.Value) { } func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6138,16 +7455,30 @@ func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[uint8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8UintR(rv reflect.Value) { @@ -6155,6 +7486,7 @@ func (f *encFnInfo) fastpathEncMapUint8UintR(rv reflect.Value) { } func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6169,16 +7501,30 @@ func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, checkNil bool, e *Encoder) } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8Uint8R(rv reflect.Value) { @@ -6186,6 +7532,7 @@ func (f *encFnInfo) fastpathEncMapUint8Uint8R(rv reflect.Value) { } func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6200,16 +7547,30 @@ func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8Uint16R(rv reflect.Value) { @@ -6217,6 +7578,7 @@ func (f *encFnInfo) fastpathEncMapUint8Uint16R(rv reflect.Value) { } func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6231,16 +7593,30 @@ func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8Uint32R(rv reflect.Value) { @@ -6248,6 +7624,7 @@ func (f *encFnInfo) fastpathEncMapUint8Uint32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6262,16 +7639,30 @@ func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8Uint64R(rv reflect.Value) { @@ -6279,6 +7670,7 @@ func (f *encFnInfo) fastpathEncMapUint8Uint64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6293,16 +7685,30 @@ func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8UintptrR(rv reflect.Value) { @@ -6310,6 +7716,7 @@ func (f *encFnInfo) fastpathEncMapUint8UintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6324,16 +7731,30 @@ func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uint8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8IntR(rv reflect.Value) { @@ -6341,6 +7762,7 @@ func (f *encFnInfo) fastpathEncMapUint8IntR(rv reflect.Value) { } func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6355,16 +7777,30 @@ func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, checkNil bool, e *Encoder) { } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8Int8R(rv reflect.Value) { @@ -6372,6 +7808,7 @@ func (f *encFnInfo) fastpathEncMapUint8Int8R(rv reflect.Value) { } func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6386,16 +7823,30 @@ func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, checkNil bool, e *Encoder) } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8Int16R(rv reflect.Value) { @@ -6403,6 +7854,7 @@ func (f *encFnInfo) fastpathEncMapUint8Int16R(rv reflect.Value) { } func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6417,16 +7869,30 @@ func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8Int32R(rv reflect.Value) { @@ -6434,6 +7900,7 @@ func (f *encFnInfo) fastpathEncMapUint8Int32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6448,16 +7915,30 @@ func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8Int64R(rv reflect.Value) { @@ -6465,6 +7946,7 @@ func (f *encFnInfo) fastpathEncMapUint8Int64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6479,16 +7961,30 @@ func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8Float32R(rv reflect.Value) { @@ -6496,6 +7992,7 @@ func (f *encFnInfo) fastpathEncMapUint8Float32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6510,16 +8007,30 @@ func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[uint8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8Float64R(rv reflect.Value) { @@ -6527,6 +8038,7 @@ func (f *encFnInfo) fastpathEncMapUint8Float64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6541,16 +8053,30 @@ func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[uint8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint8BoolR(rv reflect.Value) { @@ -6558,6 +8084,7 @@ func (f *encFnInfo) fastpathEncMapUint8BoolR(rv reflect.Value) { } func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6572,16 +8099,30 @@ func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, checkNil bool, e *Encoder) } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[uint8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16IntfR(rv reflect.Value) { @@ -6589,6 +8130,7 @@ func (f *encFnInfo) fastpathEncMapUint16IntfR(rv reflect.Value) { } func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6603,16 +8145,30 @@ func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, checkNil bool, e } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uint16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16StringR(rv reflect.Value) { @@ -6620,6 +8176,7 @@ func (f *encFnInfo) fastpathEncMapUint16StringR(rv reflect.Value) { } func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6634,16 +8191,30 @@ func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[uint16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16UintR(rv reflect.Value) { @@ -6651,6 +8222,7 @@ func (f *encFnInfo) fastpathEncMapUint16UintR(rv reflect.Value) { } func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6665,16 +8237,30 @@ func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16Uint8R(rv reflect.Value) { @@ -6682,6 +8268,7 @@ func (f *encFnInfo) fastpathEncMapUint16Uint8R(rv reflect.Value) { } func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6696,16 +8283,30 @@ func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16Uint16R(rv reflect.Value) { @@ -6713,6 +8314,7 @@ func (f *encFnInfo) fastpathEncMapUint16Uint16R(rv reflect.Value) { } func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6727,16 +8329,30 @@ func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16Uint32R(rv reflect.Value) { @@ -6744,6 +8360,7 @@ func (f *encFnInfo) fastpathEncMapUint16Uint32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6758,16 +8375,30 @@ func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16Uint64R(rv reflect.Value) { @@ -6775,6 +8406,7 @@ func (f *encFnInfo) fastpathEncMapUint16Uint64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6789,16 +8421,30 @@ func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16UintptrR(rv reflect.Value) { @@ -6806,6 +8452,7 @@ func (f *encFnInfo) fastpathEncMapUint16UintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6820,16 +8467,30 @@ func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uint16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16IntR(rv reflect.Value) { @@ -6837,6 +8498,7 @@ func (f *encFnInfo) fastpathEncMapUint16IntR(rv reflect.Value) { } func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6851,16 +8513,30 @@ func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, checkNil bool, e *Encoder) } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16Int8R(rv reflect.Value) { @@ -6868,6 +8544,7 @@ func (f *encFnInfo) fastpathEncMapUint16Int8R(rv reflect.Value) { } func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6882,16 +8559,30 @@ func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16Int16R(rv reflect.Value) { @@ -6899,6 +8590,7 @@ func (f *encFnInfo) fastpathEncMapUint16Int16R(rv reflect.Value) { } func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6913,16 +8605,30 @@ func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16Int32R(rv reflect.Value) { @@ -6930,6 +8636,7 @@ func (f *encFnInfo) fastpathEncMapUint16Int32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6944,16 +8651,30 @@ func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16Int64R(rv reflect.Value) { @@ -6961,6 +8682,7 @@ func (f *encFnInfo) fastpathEncMapUint16Int64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -6975,16 +8697,30 @@ func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16Float32R(rv reflect.Value) { @@ -6992,6 +8728,7 @@ func (f *encFnInfo) fastpathEncMapUint16Float32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7006,16 +8743,30 @@ func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[uint16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16Float64R(rv reflect.Value) { @@ -7023,6 +8774,7 @@ func (f *encFnInfo) fastpathEncMapUint16Float64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7037,16 +8789,30 @@ func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[uint16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint16BoolR(rv reflect.Value) { @@ -7054,6 +8820,7 @@ func (f *encFnInfo) fastpathEncMapUint16BoolR(rv reflect.Value) { } func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7068,16 +8835,30 @@ func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[uint16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32IntfR(rv reflect.Value) { @@ -7085,6 +8866,7 @@ func (f *encFnInfo) fastpathEncMapUint32IntfR(rv reflect.Value) { } func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7099,16 +8881,30 @@ func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, checkNil bool, e } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uint32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32StringR(rv reflect.Value) { @@ -7116,6 +8912,7 @@ func (f *encFnInfo) fastpathEncMapUint32StringR(rv reflect.Value) { } func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7130,16 +8927,30 @@ func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[uint32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32UintR(rv reflect.Value) { @@ -7147,6 +8958,7 @@ func (f *encFnInfo) fastpathEncMapUint32UintR(rv reflect.Value) { } func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7161,16 +8973,30 @@ func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32Uint8R(rv reflect.Value) { @@ -7178,6 +9004,7 @@ func (f *encFnInfo) fastpathEncMapUint32Uint8R(rv reflect.Value) { } func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7192,16 +9019,30 @@ func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32Uint16R(rv reflect.Value) { @@ -7209,6 +9050,7 @@ func (f *encFnInfo) fastpathEncMapUint32Uint16R(rv reflect.Value) { } func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7223,16 +9065,30 @@ func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32Uint32R(rv reflect.Value) { @@ -7240,6 +9096,7 @@ func (f *encFnInfo) fastpathEncMapUint32Uint32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7254,16 +9111,30 @@ func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32Uint64R(rv reflect.Value) { @@ -7271,6 +9142,7 @@ func (f *encFnInfo) fastpathEncMapUint32Uint64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7285,16 +9157,30 @@ func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32UintptrR(rv reflect.Value) { @@ -7302,6 +9188,7 @@ func (f *encFnInfo) fastpathEncMapUint32UintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7316,16 +9203,30 @@ func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uint32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32IntR(rv reflect.Value) { @@ -7333,6 +9234,7 @@ func (f *encFnInfo) fastpathEncMapUint32IntR(rv reflect.Value) { } func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7347,16 +9249,30 @@ func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, checkNil bool, e *Encoder) } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32Int8R(rv reflect.Value) { @@ -7364,6 +9280,7 @@ func (f *encFnInfo) fastpathEncMapUint32Int8R(rv reflect.Value) { } func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7378,16 +9295,30 @@ func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32Int16R(rv reflect.Value) { @@ -7395,6 +9326,7 @@ func (f *encFnInfo) fastpathEncMapUint32Int16R(rv reflect.Value) { } func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7409,16 +9341,30 @@ func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32Int32R(rv reflect.Value) { @@ -7426,6 +9372,7 @@ func (f *encFnInfo) fastpathEncMapUint32Int32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7440,16 +9387,30 @@ func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32Int64R(rv reflect.Value) { @@ -7457,6 +9418,7 @@ func (f *encFnInfo) fastpathEncMapUint32Int64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7471,16 +9433,30 @@ func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32Float32R(rv reflect.Value) { @@ -7488,6 +9464,7 @@ func (f *encFnInfo) fastpathEncMapUint32Float32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7502,16 +9479,30 @@ func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[uint32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32Float64R(rv reflect.Value) { @@ -7519,6 +9510,7 @@ func (f *encFnInfo) fastpathEncMapUint32Float64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7533,16 +9525,30 @@ func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[uint32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint32BoolR(rv reflect.Value) { @@ -7550,6 +9556,7 @@ func (f *encFnInfo) fastpathEncMapUint32BoolR(rv reflect.Value) { } func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7564,16 +9571,30 @@ func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[uint32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64IntfR(rv reflect.Value) { @@ -7581,6 +9602,7 @@ func (f *encFnInfo) fastpathEncMapUint64IntfR(rv reflect.Value) { } func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7595,16 +9617,30 @@ func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, checkNil bool, e } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uint64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64StringR(rv reflect.Value) { @@ -7612,6 +9648,7 @@ func (f *encFnInfo) fastpathEncMapUint64StringR(rv reflect.Value) { } func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7626,16 +9663,30 @@ func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[uint64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64UintR(rv reflect.Value) { @@ -7643,6 +9694,7 @@ func (f *encFnInfo) fastpathEncMapUint64UintR(rv reflect.Value) { } func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7657,16 +9709,30 @@ func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64Uint8R(rv reflect.Value) { @@ -7674,6 +9740,7 @@ func (f *encFnInfo) fastpathEncMapUint64Uint8R(rv reflect.Value) { } func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7688,16 +9755,30 @@ func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64Uint16R(rv reflect.Value) { @@ -7705,6 +9786,7 @@ func (f *encFnInfo) fastpathEncMapUint64Uint16R(rv reflect.Value) { } func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7719,16 +9801,30 @@ func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64Uint32R(rv reflect.Value) { @@ -7736,6 +9832,7 @@ func (f *encFnInfo) fastpathEncMapUint64Uint32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7750,16 +9847,30 @@ func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64Uint64R(rv reflect.Value) { @@ -7767,6 +9878,7 @@ func (f *encFnInfo) fastpathEncMapUint64Uint64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7781,16 +9893,30 @@ func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uint64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64UintptrR(rv reflect.Value) { @@ -7798,6 +9924,7 @@ func (f *encFnInfo) fastpathEncMapUint64UintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7812,16 +9939,30 @@ func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uint64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64IntR(rv reflect.Value) { @@ -7829,6 +9970,7 @@ func (f *encFnInfo) fastpathEncMapUint64IntR(rv reflect.Value) { } func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7843,16 +9985,30 @@ func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, checkNil bool, e *Encoder) } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64Int8R(rv reflect.Value) { @@ -7860,6 +10016,7 @@ func (f *encFnInfo) fastpathEncMapUint64Int8R(rv reflect.Value) { } func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7874,16 +10031,30 @@ func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64Int16R(rv reflect.Value) { @@ -7891,6 +10062,7 @@ func (f *encFnInfo) fastpathEncMapUint64Int16R(rv reflect.Value) { } func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7905,16 +10077,30 @@ func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64Int32R(rv reflect.Value) { @@ -7922,6 +10108,7 @@ func (f *encFnInfo) fastpathEncMapUint64Int32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7936,16 +10123,30 @@ func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64Int64R(rv reflect.Value) { @@ -7953,6 +10154,7 @@ func (f *encFnInfo) fastpathEncMapUint64Int64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7967,16 +10169,30 @@ func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uint64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64Float32R(rv reflect.Value) { @@ -7984,6 +10200,7 @@ func (f *encFnInfo) fastpathEncMapUint64Float32R(rv reflect.Value) { } func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -7998,16 +10215,30 @@ func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[uint64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64Float64R(rv reflect.Value) { @@ -8015,6 +10246,7 @@ func (f *encFnInfo) fastpathEncMapUint64Float64R(rv reflect.Value) { } func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8029,16 +10261,30 @@ func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[uint64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUint64BoolR(rv reflect.Value) { @@ -8046,6 +10292,7 @@ func (f *encFnInfo) fastpathEncMapUint64BoolR(rv reflect.Value) { } func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8060,16 +10307,30 @@ func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(uint64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[uint64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeUint(uint64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrIntfR(rv reflect.Value) { @@ -8077,6 +10338,7 @@ func (f *encFnInfo) fastpathEncMapUintptrIntfR(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8091,16 +10353,30 @@ func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uintptr(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrStringR(rv reflect.Value) { @@ -8108,6 +10384,7 @@ func (f *encFnInfo) fastpathEncMapUintptrStringR(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8122,16 +10399,30 @@ func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[uintptr(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrUintR(rv reflect.Value) { @@ -8139,6 +10430,7 @@ func (f *encFnInfo) fastpathEncMapUintptrUintR(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8153,16 +10445,30 @@ func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uintptr(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrUint8R(rv reflect.Value) { @@ -8170,6 +10476,7 @@ func (f *encFnInfo) fastpathEncMapUintptrUint8R(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8184,16 +10491,30 @@ func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uintptr(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrUint16R(rv reflect.Value) { @@ -8201,6 +10522,7 @@ func (f *encFnInfo) fastpathEncMapUintptrUint16R(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8215,16 +10537,30 @@ func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uintptr(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrUint32R(rv reflect.Value) { @@ -8232,6 +10568,7 @@ func (f *encFnInfo) fastpathEncMapUintptrUint32R(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8246,16 +10583,30 @@ func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uintptr(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrUint64R(rv reflect.Value) { @@ -8263,6 +10614,7 @@ func (f *encFnInfo) fastpathEncMapUintptrUint64R(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8277,16 +10629,30 @@ func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, e * } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[uintptr(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrUintptrR(rv reflect.Value) { @@ -8294,6 +10660,7 @@ func (f *encFnInfo) fastpathEncMapUintptrUintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8308,16 +10675,30 @@ func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, e } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[uintptr(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrIntR(rv reflect.Value) { @@ -8325,6 +10706,7 @@ func (f *encFnInfo) fastpathEncMapUintptrIntR(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8339,16 +10721,30 @@ func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, checkNil bool, e *Encode } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uintptr(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrInt8R(rv reflect.Value) { @@ -8356,6 +10752,7 @@ func (f *encFnInfo) fastpathEncMapUintptrInt8R(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8370,16 +10767,30 @@ func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uintptr(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrInt16R(rv reflect.Value) { @@ -8387,6 +10798,7 @@ func (f *encFnInfo) fastpathEncMapUintptrInt16R(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8401,16 +10813,30 @@ func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uintptr(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrInt32R(rv reflect.Value) { @@ -8418,6 +10844,7 @@ func (f *encFnInfo) fastpathEncMapUintptrInt32R(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8432,16 +10859,30 @@ func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uintptr(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrInt64R(rv reflect.Value) { @@ -8449,6 +10890,7 @@ func (f *encFnInfo) fastpathEncMapUintptrInt64R(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8463,16 +10905,30 @@ func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, checkNil bool, e *En } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[uintptr(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrFloat32R(rv reflect.Value) { @@ -8480,6 +10936,7 @@ func (f *encFnInfo) fastpathEncMapUintptrFloat32R(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8494,16 +10951,30 @@ func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, e } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[uintptr(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrFloat64R(rv reflect.Value) { @@ -8511,6 +10982,7 @@ func (f *encFnInfo) fastpathEncMapUintptrFloat64R(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8525,16 +10997,30 @@ func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, e } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[uintptr(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapUintptrBoolR(rv reflect.Value) { @@ -8542,6 +11028,7 @@ func (f *encFnInfo) fastpathEncMapUintptrBoolR(rv reflect.Value) { } func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8556,16 +11043,30 @@ func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, checkNil bool, e *Enco } sort.Sort(uintSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(uintptr(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[uintptr(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } e.encode(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntIntfR(rv reflect.Value) { @@ -8573,6 +11074,7 @@ func (f *encFnInfo) fastpathEncMapIntIntfR(rv reflect.Value) { } func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8587,16 +11089,30 @@ func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, checkNil bool, e *Encod } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[int(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntStringR(rv reflect.Value) { @@ -8604,6 +11120,7 @@ func (f *encFnInfo) fastpathEncMapIntStringR(rv reflect.Value) { } func (_ fastpathT) EncMapIntStringV(v map[int]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8618,16 +11135,30 @@ func (_ fastpathT) EncMapIntStringV(v map[int]string, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[int(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntUintR(rv reflect.Value) { @@ -8635,6 +11166,7 @@ func (f *encFnInfo) fastpathEncMapIntUintR(rv reflect.Value) { } func (_ fastpathT) EncMapIntUintV(v map[int]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8649,16 +11181,30 @@ func (_ fastpathT) EncMapIntUintV(v map[int]uint, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntUint8R(rv reflect.Value) { @@ -8666,6 +11212,7 @@ func (f *encFnInfo) fastpathEncMapIntUint8R(rv reflect.Value) { } func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8680,16 +11227,30 @@ func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntUint16R(rv reflect.Value) { @@ -8697,6 +11258,7 @@ func (f *encFnInfo) fastpathEncMapIntUint16R(rv reflect.Value) { } func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8711,16 +11273,30 @@ func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntUint32R(rv reflect.Value) { @@ -8728,6 +11304,7 @@ func (f *encFnInfo) fastpathEncMapIntUint32R(rv reflect.Value) { } func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8742,16 +11319,30 @@ func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntUint64R(rv reflect.Value) { @@ -8759,6 +11350,7 @@ func (f *encFnInfo) fastpathEncMapIntUint64R(rv reflect.Value) { } func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8773,16 +11365,30 @@ func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntUintptrR(rv reflect.Value) { @@ -8790,6 +11396,7 @@ func (f *encFnInfo) fastpathEncMapIntUintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8804,16 +11411,30 @@ func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[int(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntIntR(rv reflect.Value) { @@ -8821,6 +11442,7 @@ func (f *encFnInfo) fastpathEncMapIntIntR(rv reflect.Value) { } func (_ fastpathT) EncMapIntIntV(v map[int]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8835,16 +11457,30 @@ func (_ fastpathT) EncMapIntIntV(v map[int]int, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntInt8R(rv reflect.Value) { @@ -8852,6 +11488,7 @@ func (f *encFnInfo) fastpathEncMapIntInt8R(rv reflect.Value) { } func (_ fastpathT) EncMapIntInt8V(v map[int]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8866,16 +11503,30 @@ func (_ fastpathT) EncMapIntInt8V(v map[int]int8, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntInt16R(rv reflect.Value) { @@ -8883,6 +11534,7 @@ func (f *encFnInfo) fastpathEncMapIntInt16R(rv reflect.Value) { } func (_ fastpathT) EncMapIntInt16V(v map[int]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8897,16 +11549,30 @@ func (_ fastpathT) EncMapIntInt16V(v map[int]int16, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntInt32R(rv reflect.Value) { @@ -8914,6 +11580,7 @@ func (f *encFnInfo) fastpathEncMapIntInt32R(rv reflect.Value) { } func (_ fastpathT) EncMapIntInt32V(v map[int]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8928,16 +11595,30 @@ func (_ fastpathT) EncMapIntInt32V(v map[int]int32, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntInt64R(rv reflect.Value) { @@ -8945,6 +11626,7 @@ func (f *encFnInfo) fastpathEncMapIntInt64R(rv reflect.Value) { } func (_ fastpathT) EncMapIntInt64V(v map[int]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8959,16 +11641,30 @@ func (_ fastpathT) EncMapIntInt64V(v map[int]int64, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntFloat32R(rv reflect.Value) { @@ -8976,6 +11672,7 @@ func (f *encFnInfo) fastpathEncMapIntFloat32R(rv reflect.Value) { } func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -8990,16 +11687,30 @@ func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[int(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntFloat64R(rv reflect.Value) { @@ -9007,6 +11718,7 @@ func (f *encFnInfo) fastpathEncMapIntFloat64R(rv reflect.Value) { } func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9021,16 +11733,30 @@ func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[int(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapIntBoolR(rv reflect.Value) { @@ -9038,6 +11764,7 @@ func (f *encFnInfo) fastpathEncMapIntBoolR(rv reflect.Value) { } func (_ fastpathT) EncMapIntBoolV(v map[int]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9052,16 +11779,30 @@ func (_ fastpathT) EncMapIntBoolV(v map[int]bool, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[int(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8IntfR(rv reflect.Value) { @@ -9069,6 +11810,7 @@ func (f *encFnInfo) fastpathEncMapInt8IntfR(rv reflect.Value) { } func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9083,16 +11825,30 @@ func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, checkNil bool, e *Enc } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[int8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8StringR(rv reflect.Value) { @@ -9100,6 +11856,7 @@ func (f *encFnInfo) fastpathEncMapInt8StringR(rv reflect.Value) { } func (_ fastpathT) EncMapInt8StringV(v map[int8]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9114,16 +11871,30 @@ func (_ fastpathT) EncMapInt8StringV(v map[int8]string, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[int8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8UintR(rv reflect.Value) { @@ -9131,6 +11902,7 @@ func (f *encFnInfo) fastpathEncMapInt8UintR(rv reflect.Value) { } func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9145,16 +11917,30 @@ func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8Uint8R(rv reflect.Value) { @@ -9162,6 +11948,7 @@ func (f *encFnInfo) fastpathEncMapInt8Uint8R(rv reflect.Value) { } func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9176,16 +11963,30 @@ func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8Uint16R(rv reflect.Value) { @@ -9193,6 +11994,7 @@ func (f *encFnInfo) fastpathEncMapInt8Uint16R(rv reflect.Value) { } func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9207,16 +12009,30 @@ func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8Uint32R(rv reflect.Value) { @@ -9224,6 +12040,7 @@ func (f *encFnInfo) fastpathEncMapInt8Uint32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9238,16 +12055,30 @@ func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8Uint64R(rv reflect.Value) { @@ -9255,6 +12086,7 @@ func (f *encFnInfo) fastpathEncMapInt8Uint64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9269,16 +12101,30 @@ func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8UintptrR(rv reflect.Value) { @@ -9286,6 +12132,7 @@ func (f *encFnInfo) fastpathEncMapInt8UintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9300,16 +12147,30 @@ func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[int8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8IntR(rv reflect.Value) { @@ -9317,6 +12178,7 @@ func (f *encFnInfo) fastpathEncMapInt8IntR(rv reflect.Value) { } func (_ fastpathT) EncMapInt8IntV(v map[int8]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9331,16 +12193,30 @@ func (_ fastpathT) EncMapInt8IntV(v map[int8]int, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8Int8R(rv reflect.Value) { @@ -9348,6 +12224,7 @@ func (f *encFnInfo) fastpathEncMapInt8Int8R(rv reflect.Value) { } func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9362,16 +12239,30 @@ func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8Int16R(rv reflect.Value) { @@ -9379,6 +12270,7 @@ func (f *encFnInfo) fastpathEncMapInt8Int16R(rv reflect.Value) { } func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9393,16 +12285,30 @@ func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8Int32R(rv reflect.Value) { @@ -9410,6 +12316,7 @@ func (f *encFnInfo) fastpathEncMapInt8Int32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9424,16 +12331,30 @@ func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8Int64R(rv reflect.Value) { @@ -9441,6 +12362,7 @@ func (f *encFnInfo) fastpathEncMapInt8Int64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9455,16 +12377,30 @@ func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int8(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8Float32R(rv reflect.Value) { @@ -9472,6 +12408,7 @@ func (f *encFnInfo) fastpathEncMapInt8Float32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9486,16 +12423,30 @@ func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[int8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8Float64R(rv reflect.Value) { @@ -9503,6 +12454,7 @@ func (f *encFnInfo) fastpathEncMapInt8Float64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9517,16 +12469,30 @@ func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[int8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt8BoolR(rv reflect.Value) { @@ -9534,6 +12500,7 @@ func (f *encFnInfo) fastpathEncMapInt8BoolR(rv reflect.Value) { } func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9548,16 +12515,30 @@ func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int8(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[int8(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16IntfR(rv reflect.Value) { @@ -9565,6 +12546,7 @@ func (f *encFnInfo) fastpathEncMapInt16IntfR(rv reflect.Value) { } func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9579,16 +12561,30 @@ func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, checkNil bool, e *E } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[int16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16StringR(rv reflect.Value) { @@ -9596,6 +12592,7 @@ func (f *encFnInfo) fastpathEncMapInt16StringR(rv reflect.Value) { } func (_ fastpathT) EncMapInt16StringV(v map[int16]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9610,16 +12607,30 @@ func (_ fastpathT) EncMapInt16StringV(v map[int16]string, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[int16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16UintR(rv reflect.Value) { @@ -9627,6 +12638,7 @@ func (f *encFnInfo) fastpathEncMapInt16UintR(rv reflect.Value) { } func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9641,16 +12653,30 @@ func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16Uint8R(rv reflect.Value) { @@ -9658,6 +12684,7 @@ func (f *encFnInfo) fastpathEncMapInt16Uint8R(rv reflect.Value) { } func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9672,16 +12699,30 @@ func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16Uint16R(rv reflect.Value) { @@ -9689,6 +12730,7 @@ func (f *encFnInfo) fastpathEncMapInt16Uint16R(rv reflect.Value) { } func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9703,16 +12745,30 @@ func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16Uint32R(rv reflect.Value) { @@ -9720,6 +12776,7 @@ func (f *encFnInfo) fastpathEncMapInt16Uint32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9734,16 +12791,30 @@ func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16Uint64R(rv reflect.Value) { @@ -9751,6 +12822,7 @@ func (f *encFnInfo) fastpathEncMapInt16Uint64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9765,16 +12837,30 @@ func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16UintptrR(rv reflect.Value) { @@ -9782,6 +12868,7 @@ func (f *encFnInfo) fastpathEncMapInt16UintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9796,16 +12883,30 @@ func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, checkNil bool, e *En } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[int16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16IntR(rv reflect.Value) { @@ -9813,6 +12914,7 @@ func (f *encFnInfo) fastpathEncMapInt16IntR(rv reflect.Value) { } func (_ fastpathT) EncMapInt16IntV(v map[int16]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9827,16 +12929,30 @@ func (_ fastpathT) EncMapInt16IntV(v map[int16]int, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16Int8R(rv reflect.Value) { @@ -9844,6 +12960,7 @@ func (f *encFnInfo) fastpathEncMapInt16Int8R(rv reflect.Value) { } func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9858,16 +12975,30 @@ func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16Int16R(rv reflect.Value) { @@ -9875,6 +13006,7 @@ func (f *encFnInfo) fastpathEncMapInt16Int16R(rv reflect.Value) { } func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9889,16 +13021,30 @@ func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16Int32R(rv reflect.Value) { @@ -9906,6 +13052,7 @@ func (f *encFnInfo) fastpathEncMapInt16Int32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9920,16 +13067,30 @@ func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16Int64R(rv reflect.Value) { @@ -9937,6 +13098,7 @@ func (f *encFnInfo) fastpathEncMapInt16Int64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9951,16 +13113,30 @@ func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int16(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16Float32R(rv reflect.Value) { @@ -9968,6 +13144,7 @@ func (f *encFnInfo) fastpathEncMapInt16Float32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -9982,16 +13159,30 @@ func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, checkNil bool, e *En } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[int16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16Float64R(rv reflect.Value) { @@ -9999,6 +13190,7 @@ func (f *encFnInfo) fastpathEncMapInt16Float64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10013,16 +13205,30 @@ func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, checkNil bool, e *En } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[int16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt16BoolR(rv reflect.Value) { @@ -10030,6 +13236,7 @@ func (f *encFnInfo) fastpathEncMapInt16BoolR(rv reflect.Value) { } func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10044,16 +13251,30 @@ func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int16(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[int16(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32IntfR(rv reflect.Value) { @@ -10061,6 +13282,7 @@ func (f *encFnInfo) fastpathEncMapInt32IntfR(rv reflect.Value) { } func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10075,16 +13297,30 @@ func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, checkNil bool, e *E } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[int32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32StringR(rv reflect.Value) { @@ -10092,6 +13328,7 @@ func (f *encFnInfo) fastpathEncMapInt32StringR(rv reflect.Value) { } func (_ fastpathT) EncMapInt32StringV(v map[int32]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10106,16 +13343,30 @@ func (_ fastpathT) EncMapInt32StringV(v map[int32]string, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[int32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32UintR(rv reflect.Value) { @@ -10123,6 +13374,7 @@ func (f *encFnInfo) fastpathEncMapInt32UintR(rv reflect.Value) { } func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10137,16 +13389,30 @@ func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32Uint8R(rv reflect.Value) { @@ -10154,6 +13420,7 @@ func (f *encFnInfo) fastpathEncMapInt32Uint8R(rv reflect.Value) { } func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10168,16 +13435,30 @@ func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32Uint16R(rv reflect.Value) { @@ -10185,6 +13466,7 @@ func (f *encFnInfo) fastpathEncMapInt32Uint16R(rv reflect.Value) { } func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10199,16 +13481,30 @@ func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32Uint32R(rv reflect.Value) { @@ -10216,6 +13512,7 @@ func (f *encFnInfo) fastpathEncMapInt32Uint32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10230,16 +13527,30 @@ func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32Uint64R(rv reflect.Value) { @@ -10247,6 +13558,7 @@ func (f *encFnInfo) fastpathEncMapInt32Uint64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10261,16 +13573,30 @@ func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32UintptrR(rv reflect.Value) { @@ -10278,6 +13604,7 @@ func (f *encFnInfo) fastpathEncMapInt32UintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10292,16 +13619,30 @@ func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, checkNil bool, e *En } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[int32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32IntR(rv reflect.Value) { @@ -10309,6 +13650,7 @@ func (f *encFnInfo) fastpathEncMapInt32IntR(rv reflect.Value) { } func (_ fastpathT) EncMapInt32IntV(v map[int32]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10323,16 +13665,30 @@ func (_ fastpathT) EncMapInt32IntV(v map[int32]int, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32Int8R(rv reflect.Value) { @@ -10340,6 +13696,7 @@ func (f *encFnInfo) fastpathEncMapInt32Int8R(rv reflect.Value) { } func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10354,16 +13711,30 @@ func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32Int16R(rv reflect.Value) { @@ -10371,6 +13742,7 @@ func (f *encFnInfo) fastpathEncMapInt32Int16R(rv reflect.Value) { } func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10385,16 +13757,30 @@ func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32Int32R(rv reflect.Value) { @@ -10402,6 +13788,7 @@ func (f *encFnInfo) fastpathEncMapInt32Int32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10416,16 +13803,30 @@ func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32Int64R(rv reflect.Value) { @@ -10433,6 +13834,7 @@ func (f *encFnInfo) fastpathEncMapInt32Int64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10447,16 +13849,30 @@ func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int32(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32Float32R(rv reflect.Value) { @@ -10464,6 +13880,7 @@ func (f *encFnInfo) fastpathEncMapInt32Float32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10478,16 +13895,30 @@ func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, checkNil bool, e *En } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[int32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32Float64R(rv reflect.Value) { @@ -10495,6 +13926,7 @@ func (f *encFnInfo) fastpathEncMapInt32Float64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10509,16 +13941,30 @@ func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, checkNil bool, e *En } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[int32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt32BoolR(rv reflect.Value) { @@ -10526,6 +13972,7 @@ func (f *encFnInfo) fastpathEncMapInt32BoolR(rv reflect.Value) { } func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10540,16 +13987,30 @@ func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int32(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[int32(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64IntfR(rv reflect.Value) { @@ -10557,6 +14018,7 @@ func (f *encFnInfo) fastpathEncMapInt64IntfR(rv reflect.Value) { } func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10571,16 +14033,30 @@ func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, checkNil bool, e *E } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[int64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64StringR(rv reflect.Value) { @@ -10588,6 +14064,7 @@ func (f *encFnInfo) fastpathEncMapInt64StringR(rv reflect.Value) { } func (_ fastpathT) EncMapInt64StringV(v map[int64]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10602,16 +14079,30 @@ func (_ fastpathT) EncMapInt64StringV(v map[int64]string, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[int64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64UintR(rv reflect.Value) { @@ -10619,6 +14110,7 @@ func (f *encFnInfo) fastpathEncMapInt64UintR(rv reflect.Value) { } func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10633,16 +14125,30 @@ func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64Uint8R(rv reflect.Value) { @@ -10650,6 +14156,7 @@ func (f *encFnInfo) fastpathEncMapInt64Uint8R(rv reflect.Value) { } func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10664,16 +14171,30 @@ func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64Uint16R(rv reflect.Value) { @@ -10681,6 +14202,7 @@ func (f *encFnInfo) fastpathEncMapInt64Uint16R(rv reflect.Value) { } func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10695,16 +14217,30 @@ func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64Uint32R(rv reflect.Value) { @@ -10712,6 +14248,7 @@ func (f *encFnInfo) fastpathEncMapInt64Uint32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10726,16 +14263,30 @@ func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64Uint64R(rv reflect.Value) { @@ -10743,6 +14294,7 @@ func (f *encFnInfo) fastpathEncMapInt64Uint64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10757,16 +14309,30 @@ func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, checkNil bool, e *Enco } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[int64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64UintptrR(rv reflect.Value) { @@ -10774,6 +14340,7 @@ func (f *encFnInfo) fastpathEncMapInt64UintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10788,16 +14355,30 @@ func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, checkNil bool, e *En } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[int64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64IntR(rv reflect.Value) { @@ -10805,6 +14386,7 @@ func (f *encFnInfo) fastpathEncMapInt64IntR(rv reflect.Value) { } func (_ fastpathT) EncMapInt64IntV(v map[int64]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10819,16 +14401,30 @@ func (_ fastpathT) EncMapInt64IntV(v map[int64]int, checkNil bool, e *Encoder) { } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64Int8R(rv reflect.Value) { @@ -10836,6 +14432,7 @@ func (f *encFnInfo) fastpathEncMapInt64Int8R(rv reflect.Value) { } func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10850,16 +14447,30 @@ func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64Int16R(rv reflect.Value) { @@ -10867,6 +14478,7 @@ func (f *encFnInfo) fastpathEncMapInt64Int16R(rv reflect.Value) { } func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10881,16 +14493,30 @@ func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64Int32R(rv reflect.Value) { @@ -10898,6 +14524,7 @@ func (f *encFnInfo) fastpathEncMapInt64Int32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10912,16 +14539,30 @@ func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64Int64R(rv reflect.Value) { @@ -10929,6 +14570,7 @@ func (f *encFnInfo) fastpathEncMapInt64Int64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10943,16 +14585,30 @@ func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, checkNil bool, e *Encode } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[int64(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64Float32R(rv reflect.Value) { @@ -10960,6 +14616,7 @@ func (f *encFnInfo) fastpathEncMapInt64Float32R(rv reflect.Value) { } func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -10974,16 +14631,30 @@ func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, checkNil bool, e *En } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[int64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64Float64R(rv reflect.Value) { @@ -10991,6 +14662,7 @@ func (f *encFnInfo) fastpathEncMapInt64Float64R(rv reflect.Value) { } func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11005,16 +14677,30 @@ func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, checkNil bool, e *En } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[int64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapInt64BoolR(rv reflect.Value) { @@ -11022,6 +14708,7 @@ func (f *encFnInfo) fastpathEncMapInt64BoolR(rv reflect.Value) { } func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11036,16 +14723,30 @@ func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, checkNil bool, e *Encoder) } sort.Sort(intSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(int64(k2))) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[int64(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeInt(int64(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolIntfR(rv reflect.Value) { @@ -11053,6 +14754,7 @@ func (f *encFnInfo) fastpathEncMapBoolIntfR(rv reflect.Value) { } func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11067,16 +14769,30 @@ func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, checkNil bool, e *Enc } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[bool(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolStringR(rv reflect.Value) { @@ -11084,6 +14800,7 @@ func (f *encFnInfo) fastpathEncMapBoolStringR(rv reflect.Value) { } func (_ fastpathT) EncMapBoolStringV(v map[bool]string, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11098,16 +14815,30 @@ func (_ fastpathT) EncMapBoolStringV(v map[bool]string, checkNil bool, e *Encode } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v[bool(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeString(c_UTF8, v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolUintR(rv reflect.Value) { @@ -11115,6 +14846,7 @@ func (f *encFnInfo) fastpathEncMapBoolUintR(rv reflect.Value) { } func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11129,16 +14861,30 @@ func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, checkNil bool, e *Encoder) { } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[bool(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolUint8R(rv reflect.Value) { @@ -11146,6 +14892,7 @@ func (f *encFnInfo) fastpathEncMapBoolUint8R(rv reflect.Value) { } func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11160,16 +14907,30 @@ func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, checkNil bool, e *Encoder) } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[bool(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolUint16R(rv reflect.Value) { @@ -11177,6 +14938,7 @@ func (f *encFnInfo) fastpathEncMapBoolUint16R(rv reflect.Value) { } func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11191,16 +14953,30 @@ func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, checkNil bool, e *Encode } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[bool(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolUint32R(rv reflect.Value) { @@ -11208,6 +14984,7 @@ func (f *encFnInfo) fastpathEncMapBoolUint32R(rv reflect.Value) { } func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11222,16 +14999,30 @@ func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, checkNil bool, e *Encode } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[bool(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolUint64R(rv reflect.Value) { @@ -11239,6 +15030,7 @@ func (f *encFnInfo) fastpathEncMapBoolUint64R(rv reflect.Value) { } func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11253,16 +15045,30 @@ func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, checkNil bool, e *Encode } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v[bool(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeUint(uint64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolUintptrR(rv reflect.Value) { @@ -11270,6 +15076,7 @@ func (f *encFnInfo) fastpathEncMapBoolUintptrR(rv reflect.Value) { } func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11284,16 +15091,30 @@ func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, checkNil bool, e *Enco } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v[bool(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } e.encode(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolIntR(rv reflect.Value) { @@ -11301,6 +15122,7 @@ func (f *encFnInfo) fastpathEncMapBoolIntR(rv reflect.Value) { } func (_ fastpathT) EncMapBoolIntV(v map[bool]int, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11315,16 +15137,30 @@ func (_ fastpathT) EncMapBoolIntV(v map[bool]int, checkNil bool, e *Encoder) { } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[bool(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolInt8R(rv reflect.Value) { @@ -11332,6 +15168,7 @@ func (f *encFnInfo) fastpathEncMapBoolInt8R(rv reflect.Value) { } func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11346,16 +15183,30 @@ func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, checkNil bool, e *Encoder) { } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[bool(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolInt16R(rv reflect.Value) { @@ -11363,6 +15214,7 @@ func (f *encFnInfo) fastpathEncMapBoolInt16R(rv reflect.Value) { } func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11377,16 +15229,30 @@ func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, checkNil bool, e *Encoder) } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[bool(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolInt32R(rv reflect.Value) { @@ -11394,6 +15260,7 @@ func (f *encFnInfo) fastpathEncMapBoolInt32R(rv reflect.Value) { } func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11408,16 +15275,30 @@ func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, checkNil bool, e *Encoder) } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[bool(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolInt64R(rv reflect.Value) { @@ -11425,6 +15306,7 @@ func (f *encFnInfo) fastpathEncMapBoolInt64R(rv reflect.Value) { } func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11439,16 +15321,30 @@ func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, checkNil bool, e *Encoder) } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v[bool(k2)])) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeInt(int64(v2)) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolFloat32R(rv reflect.Value) { @@ -11456,6 +15352,7 @@ func (f *encFnInfo) fastpathEncMapBoolFloat32R(rv reflect.Value) { } func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11470,16 +15367,30 @@ func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, checkNil bool, e *Enco } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v[bool(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat32(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolFloat64R(rv reflect.Value) { @@ -11487,6 +15398,7 @@ func (f *encFnInfo) fastpathEncMapBoolFloat64R(rv reflect.Value) { } func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11501,16 +15413,30 @@ func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, checkNil bool, e *Enco } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v[bool(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeFloat64(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } func (f *encFnInfo) fastpathEncMapBoolBoolR(rv reflect.Value) { @@ -11518,6 +15444,7 @@ func (f *encFnInfo) fastpathEncMapBoolBoolR(rv reflect.Value) { } func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -11532,22 +15459,39 @@ func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, checkNil bool, e *Encoder) { } sort.Sort(boolSlice(v2)) for _, k2 := range v2 { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(bool(k2)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v[bool(k2)]) } } else { for k2, v2 := range v { + if cr != nil { + cr.sendContainerState(containerMapKey) + } ee.EncodeBool(k2) + if cr != nil { + cr.sendContainerState(containerMapValue) + } ee.EncodeBool(v2) } } - ee.EncodeEnd() + if cr != nil { + cr.sendContainerState(containerMapEnd) + } } // -- decode // -- -- fast path type switch func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool { + if !fastpathEnabled { + return false + } switch v := iv.(type) { case []interface{}: @@ -13719,6 +17663,7 @@ func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool { } default: + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) return false } return true @@ -13746,8 +17691,7 @@ func (f fastpathT) DecSliceIntfX(vp *[]interface{}, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool, - d *Decoder) (_ []interface{}, changed bool) { +func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool, d *Decoder) (_ []interface{}, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -13758,59 +17702,83 @@ func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 16); xtrunc { - x2read = xlen - } - v = make([]interface{}, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []interface{}{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 16); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 16) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]interface{}, xlen) + } + } else { + v = make([]interface{}, xlen) } - v = make([]interface{}, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) d.decode(&v[j]) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, nil) + slh.ElemContainerState(j) d.decode(&v[j]) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []interface{}{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]interface{}, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, nil) @@ -13819,15 +17787,21 @@ func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { d.decode(&v[j]) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -13851,8 +17825,7 @@ func (f fastpathT) DecSliceStringX(vp *[]string, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, - d *Decoder) (_ []string, changed bool) { +func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d *Decoder) (_ []string, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -13863,59 +17836,83 @@ func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 16); xtrunc { - x2read = xlen - } - v = make([]string, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []string{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 16); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 16) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]string, xlen) + } + } else { + v = make([]string, xlen) } - v = make([]string, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = dd.DecodeString() } if xtrunc { for ; j < containerLenS; j++ { v = append(v, "") + slh.ElemContainerState(j) v[j] = dd.DecodeString() } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []string{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]string, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, "") @@ -13924,14 +17921,20 @@ func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = dd.DecodeString() } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -13955,8 +17958,7 @@ func (f fastpathT) DecSliceFloat32X(vp *[]float32, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool, - d *Decoder) (_ []float32, changed bool) { +func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool, d *Decoder) (_ []float32, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -13967,59 +17969,83 @@ func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4); xtrunc { - x2read = xlen - } - v = make([]float32, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []float32{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]float32, xlen) + } + } else { + v = make([]float32, xlen) } - v = make([]float32, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = float32(dd.DecodeFloat(true)) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = float32(dd.DecodeFloat(true)) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []float32{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]float32, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -14028,14 +18054,20 @@ func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = float32(dd.DecodeFloat(true)) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -14059,8 +18091,7 @@ func (f fastpathT) DecSliceFloat64X(vp *[]float64, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool, - d *Decoder) (_ []float64, changed bool) { +func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool, d *Decoder) (_ []float64, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -14071,59 +18102,83 @@ func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen - } - v = make([]float64, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []float64{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]float64, xlen) + } + } else { + v = make([]float64, xlen) } - v = make([]float64, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = dd.DecodeFloat(false) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = dd.DecodeFloat(false) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []float64{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]float64, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -14132,14 +18187,20 @@ func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = dd.DecodeFloat(false) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -14163,8 +18224,7 @@ func (f fastpathT) DecSliceUintX(vp *[]uint, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, - d *Decoder) (_ []uint, changed bool) { +func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d *Decoder) (_ []uint, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -14175,59 +18235,83 @@ func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen - } - v = make([]uint, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []uint{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]uint, xlen) + } + } else { + v = make([]uint, xlen) } - v = make([]uint, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = uint(dd.DecodeUint(uintBitsize)) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = uint(dd.DecodeUint(uintBitsize)) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []uint{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]uint, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -14236,14 +18320,20 @@ func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = uint(dd.DecodeUint(uintBitsize)) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -14267,8 +18357,7 @@ func (f fastpathT) DecSliceUint16X(vp *[]uint16, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, - d *Decoder) (_ []uint16, changed bool) { +func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d *Decoder) (_ []uint16, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -14279,59 +18368,83 @@ func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 2); xtrunc { - x2read = xlen - } - v = make([]uint16, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []uint16{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 2); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 2) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]uint16, xlen) + } + } else { + v = make([]uint16, xlen) } - v = make([]uint16, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = uint16(dd.DecodeUint(16)) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = uint16(dd.DecodeUint(16)) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []uint16{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]uint16, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -14340,14 +18453,20 @@ func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = uint16(dd.DecodeUint(16)) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -14371,8 +18490,7 @@ func (f fastpathT) DecSliceUint32X(vp *[]uint32, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, - d *Decoder) (_ []uint32, changed bool) { +func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d *Decoder) (_ []uint32, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -14383,59 +18501,83 @@ func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4); xtrunc { - x2read = xlen - } - v = make([]uint32, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []uint32{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]uint32, xlen) + } + } else { + v = make([]uint32, xlen) } - v = make([]uint32, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = uint32(dd.DecodeUint(32)) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = uint32(dd.DecodeUint(32)) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []uint32{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]uint32, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -14444,14 +18586,20 @@ func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = uint32(dd.DecodeUint(32)) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -14475,8 +18623,7 @@ func (f fastpathT) DecSliceUint64X(vp *[]uint64, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, - d *Decoder) (_ []uint64, changed bool) { +func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d *Decoder) (_ []uint64, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -14487,59 +18634,83 @@ func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen - } - v = make([]uint64, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []uint64{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]uint64, xlen) + } + } else { + v = make([]uint64, xlen) } - v = make([]uint64, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = dd.DecodeUint(64) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = dd.DecodeUint(64) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []uint64{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]uint64, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -14548,14 +18719,20 @@ func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = dd.DecodeUint(64) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -14579,8 +18756,7 @@ func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool, - d *Decoder) (_ []uintptr, changed bool) { +func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool, d *Decoder) (_ []uintptr, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -14591,59 +18767,83 @@ func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen - } - v = make([]uintptr, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []uintptr{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]uintptr, xlen) + } + } else { + v = make([]uintptr, xlen) } - v = make([]uintptr, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = uintptr(dd.DecodeUint(uintBitsize)) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = uintptr(dd.DecodeUint(uintBitsize)) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []uintptr{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]uintptr, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -14652,14 +18852,20 @@ func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = uintptr(dd.DecodeUint(uintBitsize)) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -14683,8 +18889,7 @@ func (f fastpathT) DecSliceIntX(vp *[]int, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, - d *Decoder) (_ []int, changed bool) { +func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d *Decoder) (_ []int, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -14695,59 +18900,83 @@ func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen - } - v = make([]int, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []int{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]int, xlen) + } + } else { + v = make([]int, xlen) } - v = make([]int, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = int(dd.DecodeInt(intBitsize)) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = int(dd.DecodeInt(intBitsize)) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []int{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]int, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -14756,14 +18985,20 @@ func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = int(dd.DecodeInt(intBitsize)) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -14787,8 +19022,7 @@ func (f fastpathT) DecSliceInt8X(vp *[]int8, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, - d *Decoder) (_ []int8, changed bool) { +func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d *Decoder) (_ []int8, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -14799,59 +19033,83 @@ func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 1); xtrunc { - x2read = xlen - } - v = make([]int8, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []int8{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 1); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 1) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]int8, xlen) + } + } else { + v = make([]int8, xlen) } - v = make([]int8, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = int8(dd.DecodeInt(8)) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = int8(dd.DecodeInt(8)) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []int8{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]int8, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -14860,14 +19118,20 @@ func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = int8(dd.DecodeInt(8)) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -14891,8 +19155,7 @@ func (f fastpathT) DecSliceInt16X(vp *[]int16, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, - d *Decoder) (_ []int16, changed bool) { +func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d *Decoder) (_ []int16, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -14903,59 +19166,83 @@ func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 2); xtrunc { - x2read = xlen - } - v = make([]int16, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []int16{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 2); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 2) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]int16, xlen) + } + } else { + v = make([]int16, xlen) } - v = make([]int16, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = int16(dd.DecodeInt(16)) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = int16(dd.DecodeInt(16)) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []int16{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]int16, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -14964,14 +19251,20 @@ func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = int16(dd.DecodeInt(16)) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -14995,8 +19288,7 @@ func (f fastpathT) DecSliceInt32X(vp *[]int32, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, - d *Decoder) (_ []int32, changed bool) { +func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d *Decoder) (_ []int32, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -15007,59 +19299,83 @@ func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4); xtrunc { - x2read = xlen - } - v = make([]int32, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []int32{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 4) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]int32, xlen) + } + } else { + v = make([]int32, xlen) } - v = make([]int32, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = int32(dd.DecodeInt(32)) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = int32(dd.DecodeInt(32)) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []int32{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]int32, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -15068,14 +19384,20 @@ func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = int32(dd.DecodeInt(32)) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -15099,8 +19421,7 @@ func (f fastpathT) DecSliceInt64X(vp *[]int64, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, - d *Decoder) (_ []int64, changed bool) { +func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d *Decoder) (_ []int64, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -15111,59 +19432,83 @@ func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen - } - v = make([]int64, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []int64{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 8) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]int64, xlen) + } + } else { + v = make([]int64, xlen) } - v = make([]int64, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = dd.DecodeInt(64) } if xtrunc { for ; j < containerLenS; j++ { v = append(v, 0) + slh.ElemContainerState(j) v[j] = dd.DecodeInt(64) } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []int64{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]int64, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, 0) @@ -15172,14 +19517,20 @@ func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = dd.DecodeInt(64) } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -15203,8 +19554,7 @@ func (f fastpathT) DecSliceBoolX(vp *[]bool, checkNil bool, d *Decoder) { *vp = v } } -func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, - d *Decoder) (_ []bool, changed bool) { +func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d *Decoder) (_ []bool, changed bool) { dd := d.d if checkNil && dd.TryDecodeAsNil() { @@ -15215,59 +19565,83 @@ func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 1); xtrunc { - x2read = xlen - } - v = make([]bool, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] + if canChange { + if v == nil { + v = []bool{} + } else if len(v) != 0 { + v = v[:0] + } changed = true } - return v, changed + slh.End() + return } if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 1); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, 1) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]bool, xlen) + } + } else { + v = make([]bool, xlen) } - v = make([]bool, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true + if canChange { + v = v[:containerLenS] + changed = true + } } - j := 0 for ; j < x2read; j++ { + slh.ElemContainerState(j) v[j] = dd.DecodeBool() } if xtrunc { for ; j < containerLenS; j++ { v = append(v, false) + slh.ElemContainerState(j) v[j] = dd.DecodeBool() } } else if !canChange { for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { + breakFound := dd.CheckBreak() + if breakFound { + if canChange { + if v == nil { + v = []bool{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]bool, 1, 4) + changed = true + } j := 0 - for ; !dd.CheckBreak(); j++ { + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, false) @@ -15276,14 +19650,20 @@ func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d.arrayCannotExpand(len(v), j+1) } } + slh.ElemContainerState(j) if j < len(v) { v[j] = dd.DecodeBool() } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -15308,6 +19688,7 @@ func (f fastpathT) DecMapIntfIntfX(vp *map[interface{}]interface{}, checkNil boo func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -15327,11 +19708,17 @@ func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -15344,11 +19731,17 @@ func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -15359,7 +19752,9 @@ func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -15385,6 +19780,7 @@ func (f fastpathT) DecMapIntfStringX(vp *map[interface{}]string, checkNil bool, func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -15404,11 +19800,17 @@ func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, checkNil bool, ca var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -15416,17 +19818,25 @@ func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, checkNil bool, ca } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -15452,6 +19862,7 @@ func (f fastpathT) DecMapIntfUintX(vp *map[interface{}]uint, checkNil bool, d *D func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -15471,11 +19882,17 @@ func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, checkNil bool, canCha var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -15483,17 +19900,25 @@ func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, checkNil bool, canCha } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -15519,6 +19944,7 @@ func (f fastpathT) DecMapIntfUint8X(vp *map[interface{}]uint8, checkNil bool, d func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -15538,11 +19964,17 @@ func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, checkNil bool, canC var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -15550,17 +19982,25 @@ func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, checkNil bool, canC } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -15586,6 +20026,7 @@ func (f fastpathT) DecMapIntfUint16X(vp *map[interface{}]uint16, checkNil bool, func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -15605,11 +20046,17 @@ func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, checkNil bool, ca var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -15617,17 +20064,25 @@ func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, checkNil bool, ca } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -15653,6 +20108,7 @@ func (f fastpathT) DecMapIntfUint32X(vp *map[interface{}]uint32, checkNil bool, func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -15672,11 +20128,17 @@ func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, checkNil bool, ca var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -15684,17 +20146,25 @@ func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, checkNil bool, ca } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -15720,6 +20190,7 @@ func (f fastpathT) DecMapIntfUint64X(vp *map[interface{}]uint64, checkNil bool, func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -15739,11 +20210,17 @@ func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, checkNil bool, ca var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -15751,17 +20228,25 @@ func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, checkNil bool, ca } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -15787,6 +20272,7 @@ func (f fastpathT) DecMapIntfUintptrX(vp *map[interface{}]uintptr, checkNil bool func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -15806,11 +20292,17 @@ func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -15818,17 +20310,25 @@ func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -15854,6 +20354,7 @@ func (f fastpathT) DecMapIntfIntX(vp *map[interface{}]int, checkNil bool, d *Dec func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -15873,11 +20374,17 @@ func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, checkNil bool, canChang var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -15885,17 +20392,25 @@ func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, checkNil bool, canChang } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -15921,6 +20436,7 @@ func (f fastpathT) DecMapIntfInt8X(vp *map[interface{}]int8, checkNil bool, d *D func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -15940,11 +20456,17 @@ func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, checkNil bool, canCha var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -15952,17 +20474,25 @@ func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, checkNil bool, canCha } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -15988,6 +20518,7 @@ func (f fastpathT) DecMapIntfInt16X(vp *map[interface{}]int16, checkNil bool, d func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16007,11 +20538,17 @@ func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, checkNil bool, canC var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -16019,17 +20556,25 @@ func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, checkNil bool, canC } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16055,6 +20600,7 @@ func (f fastpathT) DecMapIntfInt32X(vp *map[interface{}]int32, checkNil bool, d func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16074,11 +20620,17 @@ func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, checkNil bool, canC var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -16086,17 +20638,25 @@ func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, checkNil bool, canC } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16122,6 +20682,7 @@ func (f fastpathT) DecMapIntfInt64X(vp *map[interface{}]int64, checkNil bool, d func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16141,11 +20702,17 @@ func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, checkNil bool, canC var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -16153,17 +20720,25 @@ func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, checkNil bool, canC } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16189,6 +20764,7 @@ func (f fastpathT) DecMapIntfFloat32X(vp *map[interface{}]float32, checkNil bool func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16208,11 +20784,17 @@ func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, checkNil bool, var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -16220,17 +20802,25 @@ func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, checkNil bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16256,6 +20846,7 @@ func (f fastpathT) DecMapIntfFloat64X(vp *map[interface{}]float64, checkNil bool func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16275,11 +20866,17 @@ func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, checkNil bool, var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -16287,17 +20884,25 @@ func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, checkNil bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16323,6 +20928,7 @@ func (f fastpathT) DecMapIntfBoolX(vp *map[interface{}]bool, checkNil bool, d *D func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, checkNil bool, canChange bool, d *Decoder) (_ map[interface{}]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16342,11 +20948,17 @@ func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, checkNil bool, canCha var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -16354,17 +20966,25 @@ func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, checkNil bool, canCha } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) } + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16390,6 +21010,7 @@ func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, checkNil bool, func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[string]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16409,7 +21030,13 @@ func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, checkNil bool, ca var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -16422,7 +21049,13 @@ func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, checkNil bool, ca } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -16433,7 +21066,9 @@ func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, checkNil bool, ca v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16459,6 +21094,7 @@ func (f fastpathT) DecMapStringStringX(vp *map[string]string, checkNil bool, d * func (_ fastpathT) DecMapStringStringV(v map[string]string, checkNil bool, canChange bool, d *Decoder) (_ map[string]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16478,7 +21114,13 @@ func (_ fastpathT) DecMapStringStringV(v map[string]string, checkNil bool, canCh var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -16486,13 +21128,21 @@ func (_ fastpathT) DecMapStringStringV(v map[string]string, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16518,6 +21168,7 @@ func (f fastpathT) DecMapStringUintX(vp *map[string]uint, checkNil bool, d *Deco func (_ fastpathT) DecMapStringUintV(v map[string]uint, checkNil bool, canChange bool, d *Decoder) (_ map[string]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16537,7 +21188,13 @@ func (_ fastpathT) DecMapStringUintV(v map[string]uint, checkNil bool, canChange var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -16545,13 +21202,21 @@ func (_ fastpathT) DecMapStringUintV(v map[string]uint, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16577,6 +21242,7 @@ func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, checkNil bool, d *De func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[string]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16596,7 +21262,13 @@ func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, checkNil bool, canChan var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -16604,13 +21276,21 @@ func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16636,6 +21316,7 @@ func (f fastpathT) DecMapStringUint16X(vp *map[string]uint16, checkNil bool, d * func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[string]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16655,7 +21336,13 @@ func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, checkNil bool, canCh var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -16663,13 +21350,21 @@ func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16695,6 +21390,7 @@ func (f fastpathT) DecMapStringUint32X(vp *map[string]uint32, checkNil bool, d * func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[string]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16714,7 +21410,13 @@ func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, checkNil bool, canCh var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -16722,13 +21424,21 @@ func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16754,6 +21464,7 @@ func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, checkNil bool, d * func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[string]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16773,7 +21484,13 @@ func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, checkNil bool, canCh var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -16781,13 +21498,21 @@ func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16813,6 +21538,7 @@ func (f fastpathT) DecMapStringUintptrX(vp *map[string]uintptr, checkNil bool, d func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[string]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16832,7 +21558,13 @@ func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, checkNil bool, can var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -16840,13 +21572,21 @@ func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16872,6 +21612,7 @@ func (f fastpathT) DecMapStringIntX(vp *map[string]int, checkNil bool, d *Decode func (_ fastpathT) DecMapStringIntV(v map[string]int, checkNil bool, canChange bool, d *Decoder) (_ map[string]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16891,7 +21632,13 @@ func (_ fastpathT) DecMapStringIntV(v map[string]int, checkNil bool, canChange b var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -16899,13 +21646,21 @@ func (_ fastpathT) DecMapStringIntV(v map[string]int, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16931,6 +21686,7 @@ func (f fastpathT) DecMapStringInt8X(vp *map[string]int8, checkNil bool, d *Deco func (_ fastpathT) DecMapStringInt8V(v map[string]int8, checkNil bool, canChange bool, d *Decoder) (_ map[string]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -16950,7 +21706,13 @@ func (_ fastpathT) DecMapStringInt8V(v map[string]int8, checkNil bool, canChange var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -16958,13 +21720,21 @@ func (_ fastpathT) DecMapStringInt8V(v map[string]int8, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -16990,6 +21760,7 @@ func (f fastpathT) DecMapStringInt16X(vp *map[string]int16, checkNil bool, d *De func (_ fastpathT) DecMapStringInt16V(v map[string]int16, checkNil bool, canChange bool, d *Decoder) (_ map[string]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17009,7 +21780,13 @@ func (_ fastpathT) DecMapStringInt16V(v map[string]int16, checkNil bool, canChan var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -17017,13 +21794,21 @@ func (_ fastpathT) DecMapStringInt16V(v map[string]int16, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17049,6 +21834,7 @@ func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, checkNil bool, d *De func (_ fastpathT) DecMapStringInt32V(v map[string]int32, checkNil bool, canChange bool, d *Decoder) (_ map[string]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17068,7 +21854,13 @@ func (_ fastpathT) DecMapStringInt32V(v map[string]int32, checkNil bool, canChan var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -17076,13 +21868,21 @@ func (_ fastpathT) DecMapStringInt32V(v map[string]int32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17108,6 +21908,7 @@ func (f fastpathT) DecMapStringInt64X(vp *map[string]int64, checkNil bool, d *De func (_ fastpathT) DecMapStringInt64V(v map[string]int64, checkNil bool, canChange bool, d *Decoder) (_ map[string]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17127,7 +21928,13 @@ func (_ fastpathT) DecMapStringInt64V(v map[string]int64, checkNil bool, canChan var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -17135,13 +21942,21 @@ func (_ fastpathT) DecMapStringInt64V(v map[string]int64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17167,6 +21982,7 @@ func (f fastpathT) DecMapStringFloat32X(vp *map[string]float32, checkNil bool, d func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, checkNil bool, canChange bool, d *Decoder) (_ map[string]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17186,7 +22002,13 @@ func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, checkNil bool, can var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -17194,13 +22016,21 @@ func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17226,6 +22056,7 @@ func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, checkNil bool, d func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, checkNil bool, canChange bool, d *Decoder) (_ map[string]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17245,7 +22076,13 @@ func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, checkNil bool, can var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -17253,13 +22090,21 @@ func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17285,6 +22130,7 @@ func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, checkNil bool, d *Deco func (_ fastpathT) DecMapStringBoolV(v map[string]bool, checkNil bool, canChange bool, d *Decoder) (_ map[string]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17304,7 +22150,13 @@ func (_ fastpathT) DecMapStringBoolV(v map[string]bool, checkNil bool, canChange var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -17312,13 +22164,21 @@ func (_ fastpathT) DecMapStringBoolV(v map[string]bool, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeString() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17344,6 +22204,7 @@ func (f fastpathT) DecMapFloat32IntfX(vp *map[float32]interface{}, checkNil bool func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[float32]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17363,7 +22224,13 @@ func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, checkNil bool, var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -17376,7 +22243,13 @@ func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, checkNil bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -17387,7 +22260,9 @@ func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, checkNil bool, v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17413,6 +22288,7 @@ func (f fastpathT) DecMapFloat32StringX(vp *map[float32]string, checkNil bool, d func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, checkNil bool, canChange bool, d *Decoder) (_ map[float32]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17432,7 +22308,13 @@ func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, checkNil bool, can var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -17440,13 +22322,21 @@ func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17472,6 +22362,7 @@ func (f fastpathT) DecMapFloat32UintX(vp *map[float32]uint, checkNil bool, d *De func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, checkNil bool, canChange bool, d *Decoder) (_ map[float32]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17491,7 +22382,13 @@ func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, checkNil bool, canChan var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -17499,13 +22396,21 @@ func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17531,6 +22436,7 @@ func (f fastpathT) DecMapFloat32Uint8X(vp *map[float32]uint8, checkNil bool, d * func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[float32]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17550,7 +22456,13 @@ func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, checkNil bool, canCh var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -17558,13 +22470,21 @@ func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17590,6 +22510,7 @@ func (f fastpathT) DecMapFloat32Uint16X(vp *map[float32]uint16, checkNil bool, d func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[float32]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17609,7 +22530,13 @@ func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, checkNil bool, can var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -17617,13 +22544,21 @@ func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17649,6 +22584,7 @@ func (f fastpathT) DecMapFloat32Uint32X(vp *map[float32]uint32, checkNil bool, d func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[float32]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17668,7 +22604,13 @@ func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, checkNil bool, can var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -17676,13 +22618,21 @@ func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17708,6 +22658,7 @@ func (f fastpathT) DecMapFloat32Uint64X(vp *map[float32]uint64, checkNil bool, d func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[float32]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17727,7 +22678,13 @@ func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, checkNil bool, can var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -17735,13 +22692,21 @@ func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17767,6 +22732,7 @@ func (f fastpathT) DecMapFloat32UintptrX(vp *map[float32]uintptr, checkNil bool, func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[float32]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17786,7 +22752,13 @@ func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, c var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -17794,13 +22766,21 @@ func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, c } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17826,6 +22806,7 @@ func (f fastpathT) DecMapFloat32IntX(vp *map[float32]int, checkNil bool, d *Deco func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, checkNil bool, canChange bool, d *Decoder) (_ map[float32]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17845,7 +22826,13 @@ func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, checkNil bool, canChange var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -17853,13 +22840,21 @@ func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17885,6 +22880,7 @@ func (f fastpathT) DecMapFloat32Int8X(vp *map[float32]int8, checkNil bool, d *De func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, checkNil bool, canChange bool, d *Decoder) (_ map[float32]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17904,7 +22900,13 @@ func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, checkNil bool, canChan var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -17912,13 +22914,21 @@ func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -17944,6 +22954,7 @@ func (f fastpathT) DecMapFloat32Int16X(vp *map[float32]int16, checkNil bool, d * func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, checkNil bool, canChange bool, d *Decoder) (_ map[float32]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -17963,7 +22974,13 @@ func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, checkNil bool, canCh var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -17971,13 +22988,21 @@ func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18003,6 +23028,7 @@ func (f fastpathT) DecMapFloat32Int32X(vp *map[float32]int32, checkNil bool, d * func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, checkNil bool, canChange bool, d *Decoder) (_ map[float32]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18022,7 +23048,13 @@ func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, checkNil bool, canCh var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -18030,13 +23062,21 @@ func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18062,6 +23102,7 @@ func (f fastpathT) DecMapFloat32Int64X(vp *map[float32]int64, checkNil bool, d * func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, checkNil bool, canChange bool, d *Decoder) (_ map[float32]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18081,7 +23122,13 @@ func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, checkNil bool, canCh var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -18089,13 +23136,21 @@ func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18121,6 +23176,7 @@ func (f fastpathT) DecMapFloat32Float32X(vp *map[float32]float32, checkNil bool, func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, checkNil bool, canChange bool, d *Decoder) (_ map[float32]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18140,7 +23196,13 @@ func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, checkNil bool, c var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -18148,13 +23210,21 @@ func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, checkNil bool, c } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18180,6 +23250,7 @@ func (f fastpathT) DecMapFloat32Float64X(vp *map[float32]float64, checkNil bool, func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, checkNil bool, canChange bool, d *Decoder) (_ map[float32]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18199,7 +23270,13 @@ func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, checkNil bool, c var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -18207,13 +23284,21 @@ func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, checkNil bool, c } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18239,6 +23324,7 @@ func (f fastpathT) DecMapFloat32BoolX(vp *map[float32]bool, checkNil bool, d *De func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, checkNil bool, canChange bool, d *Decoder) (_ map[float32]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18258,7 +23344,13 @@ func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, checkNil bool, canChan var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -18266,13 +23358,21 @@ func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = float32(dd.DecodeFloat(true)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18298,6 +23398,7 @@ func (f fastpathT) DecMapFloat64IntfX(vp *map[float64]interface{}, checkNil bool func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[float64]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18317,7 +23418,13 @@ func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, checkNil bool, var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -18330,7 +23437,13 @@ func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, checkNil bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -18341,7 +23454,9 @@ func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, checkNil bool, v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18367,6 +23482,7 @@ func (f fastpathT) DecMapFloat64StringX(vp *map[float64]string, checkNil bool, d func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, checkNil bool, canChange bool, d *Decoder) (_ map[float64]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18386,7 +23502,13 @@ func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, checkNil bool, can var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -18394,13 +23516,21 @@ func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18426,6 +23556,7 @@ func (f fastpathT) DecMapFloat64UintX(vp *map[float64]uint, checkNil bool, d *De func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, checkNil bool, canChange bool, d *Decoder) (_ map[float64]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18445,7 +23576,13 @@ func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, checkNil bool, canChan var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -18453,13 +23590,21 @@ func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18485,6 +23630,7 @@ func (f fastpathT) DecMapFloat64Uint8X(vp *map[float64]uint8, checkNil bool, d * func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[float64]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18504,7 +23650,13 @@ func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, checkNil bool, canCh var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -18512,13 +23664,21 @@ func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18544,6 +23704,7 @@ func (f fastpathT) DecMapFloat64Uint16X(vp *map[float64]uint16, checkNil bool, d func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[float64]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18563,7 +23724,13 @@ func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, checkNil bool, can var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -18571,13 +23738,21 @@ func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18603,6 +23778,7 @@ func (f fastpathT) DecMapFloat64Uint32X(vp *map[float64]uint32, checkNil bool, d func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[float64]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18622,7 +23798,13 @@ func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, checkNil bool, can var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -18630,13 +23812,21 @@ func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18662,6 +23852,7 @@ func (f fastpathT) DecMapFloat64Uint64X(vp *map[float64]uint64, checkNil bool, d func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[float64]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18681,7 +23872,13 @@ func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, checkNil bool, can var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -18689,13 +23886,21 @@ func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18721,6 +23926,7 @@ func (f fastpathT) DecMapFloat64UintptrX(vp *map[float64]uintptr, checkNil bool, func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[float64]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18740,7 +23946,13 @@ func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, c var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -18748,13 +23960,21 @@ func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, c } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18780,6 +24000,7 @@ func (f fastpathT) DecMapFloat64IntX(vp *map[float64]int, checkNil bool, d *Deco func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, checkNil bool, canChange bool, d *Decoder) (_ map[float64]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18799,7 +24020,13 @@ func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, checkNil bool, canChange var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -18807,13 +24034,21 @@ func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18839,6 +24074,7 @@ func (f fastpathT) DecMapFloat64Int8X(vp *map[float64]int8, checkNil bool, d *De func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, checkNil bool, canChange bool, d *Decoder) (_ map[float64]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18858,7 +24094,13 @@ func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, checkNil bool, canChan var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -18866,13 +24108,21 @@ func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18898,6 +24148,7 @@ func (f fastpathT) DecMapFloat64Int16X(vp *map[float64]int16, checkNil bool, d * func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, checkNil bool, canChange bool, d *Decoder) (_ map[float64]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18917,7 +24168,13 @@ func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, checkNil bool, canCh var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -18925,13 +24182,21 @@ func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -18957,6 +24222,7 @@ func (f fastpathT) DecMapFloat64Int32X(vp *map[float64]int32, checkNil bool, d * func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, checkNil bool, canChange bool, d *Decoder) (_ map[float64]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -18976,7 +24242,13 @@ func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, checkNil bool, canCh var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -18984,13 +24256,21 @@ func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19016,6 +24296,7 @@ func (f fastpathT) DecMapFloat64Int64X(vp *map[float64]int64, checkNil bool, d * func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, checkNil bool, canChange bool, d *Decoder) (_ map[float64]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19035,7 +24316,13 @@ func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, checkNil bool, canCh var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -19043,13 +24330,21 @@ func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19075,6 +24370,7 @@ func (f fastpathT) DecMapFloat64Float32X(vp *map[float64]float32, checkNil bool, func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, checkNil bool, canChange bool, d *Decoder) (_ map[float64]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19094,7 +24390,13 @@ func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, checkNil bool, c var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -19102,13 +24404,21 @@ func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, checkNil bool, c } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19134,6 +24444,7 @@ func (f fastpathT) DecMapFloat64Float64X(vp *map[float64]float64, checkNil bool, func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, checkNil bool, canChange bool, d *Decoder) (_ map[float64]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19153,7 +24464,13 @@ func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, checkNil bool, c var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -19161,13 +24478,21 @@ func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, checkNil bool, c } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19193,6 +24518,7 @@ func (f fastpathT) DecMapFloat64BoolX(vp *map[float64]bool, checkNil bool, d *De func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, checkNil bool, canChange bool, d *Decoder) (_ map[float64]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19212,7 +24538,13 @@ func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, checkNil bool, canChan var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -19220,13 +24552,21 @@ func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeFloat(false) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19252,6 +24592,7 @@ func (f fastpathT) DecMapUintIntfX(vp *map[uint]interface{}, checkNil bool, d *D func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[uint]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19271,7 +24612,13 @@ func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, checkNil bool, canCha var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -19284,7 +24631,13 @@ func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, checkNil bool, canCha } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -19295,7 +24648,9 @@ func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, checkNil bool, canCha v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19321,6 +24676,7 @@ func (f fastpathT) DecMapUintStringX(vp *map[uint]string, checkNil bool, d *Deco func (_ fastpathT) DecMapUintStringV(v map[uint]string, checkNil bool, canChange bool, d *Decoder) (_ map[uint]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19340,7 +24696,13 @@ func (_ fastpathT) DecMapUintStringV(v map[uint]string, checkNil bool, canChange var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -19348,13 +24710,21 @@ func (_ fastpathT) DecMapUintStringV(v map[uint]string, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19380,6 +24750,7 @@ func (f fastpathT) DecMapUintUintX(vp *map[uint]uint, checkNil bool, d *Decoder) func (_ fastpathT) DecMapUintUintV(v map[uint]uint, checkNil bool, canChange bool, d *Decoder) (_ map[uint]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19399,7 +24770,13 @@ func (_ fastpathT) DecMapUintUintV(v map[uint]uint, checkNil bool, canChange boo var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -19407,13 +24784,21 @@ func (_ fastpathT) DecMapUintUintV(v map[uint]uint, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19439,6 +24824,7 @@ func (f fastpathT) DecMapUintUint8X(vp *map[uint]uint8, checkNil bool, d *Decode func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[uint]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19458,7 +24844,13 @@ func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, checkNil bool, canChange b var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -19466,13 +24858,21 @@ func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19498,6 +24898,7 @@ func (f fastpathT) DecMapUintUint16X(vp *map[uint]uint16, checkNil bool, d *Deco func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[uint]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19517,7 +24918,13 @@ func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, checkNil bool, canChange var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -19525,13 +24932,21 @@ func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19557,6 +24972,7 @@ func (f fastpathT) DecMapUintUint32X(vp *map[uint]uint32, checkNil bool, d *Deco func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[uint]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19576,7 +24992,13 @@ func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, checkNil bool, canChange var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -19584,13 +25006,21 @@ func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19616,6 +25046,7 @@ func (f fastpathT) DecMapUintUint64X(vp *map[uint]uint64, checkNil bool, d *Deco func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[uint]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19635,7 +25066,13 @@ func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, checkNil bool, canChange var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -19643,13 +25080,21 @@ func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19675,6 +25120,7 @@ func (f fastpathT) DecMapUintUintptrX(vp *map[uint]uintptr, checkNil bool, d *De func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[uint]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19694,7 +25140,13 @@ func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, checkNil bool, canChan var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -19702,13 +25154,21 @@ func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19734,6 +25194,7 @@ func (f fastpathT) DecMapUintIntX(vp *map[uint]int, checkNil bool, d *Decoder) { func (_ fastpathT) DecMapUintIntV(v map[uint]int, checkNil bool, canChange bool, d *Decoder) (_ map[uint]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19753,7 +25214,13 @@ func (_ fastpathT) DecMapUintIntV(v map[uint]int, checkNil bool, canChange bool, var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -19761,13 +25228,21 @@ func (_ fastpathT) DecMapUintIntV(v map[uint]int, checkNil bool, canChange bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19793,6 +25268,7 @@ func (f fastpathT) DecMapUintInt8X(vp *map[uint]int8, checkNil bool, d *Decoder) func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, checkNil bool, canChange bool, d *Decoder) (_ map[uint]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19812,7 +25288,13 @@ func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, checkNil bool, canChange boo var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -19820,13 +25302,21 @@ func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19852,6 +25342,7 @@ func (f fastpathT) DecMapUintInt16X(vp *map[uint]int16, checkNil bool, d *Decode func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, checkNil bool, canChange bool, d *Decoder) (_ map[uint]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19871,7 +25362,13 @@ func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, checkNil bool, canChange b var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -19879,13 +25376,21 @@ func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19911,6 +25416,7 @@ func (f fastpathT) DecMapUintInt32X(vp *map[uint]int32, checkNil bool, d *Decode func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, checkNil bool, canChange bool, d *Decoder) (_ map[uint]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19930,7 +25436,13 @@ func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, checkNil bool, canChange b var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -19938,13 +25450,21 @@ func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -19970,6 +25490,7 @@ func (f fastpathT) DecMapUintInt64X(vp *map[uint]int64, checkNil bool, d *Decode func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, checkNil bool, canChange bool, d *Decoder) (_ map[uint]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -19989,7 +25510,13 @@ func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, checkNil bool, canChange b var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -19997,13 +25524,21 @@ func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20029,6 +25564,7 @@ func (f fastpathT) DecMapUintFloat32X(vp *map[uint]float32, checkNil bool, d *De func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, checkNil bool, canChange bool, d *Decoder) (_ map[uint]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20048,7 +25584,13 @@ func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, checkNil bool, canChan var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -20056,13 +25598,21 @@ func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20088,6 +25638,7 @@ func (f fastpathT) DecMapUintFloat64X(vp *map[uint]float64, checkNil bool, d *De func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, checkNil bool, canChange bool, d *Decoder) (_ map[uint]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20107,7 +25658,13 @@ func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, checkNil bool, canChan var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -20115,13 +25672,21 @@ func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20147,6 +25712,7 @@ func (f fastpathT) DecMapUintBoolX(vp *map[uint]bool, checkNil bool, d *Decoder) func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, checkNil bool, canChange bool, d *Decoder) (_ map[uint]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20166,7 +25732,13 @@ func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, checkNil bool, canChange boo var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -20174,13 +25746,21 @@ func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20206,6 +25786,7 @@ func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, checkNil bool, d func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20225,7 +25806,13 @@ func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, checkNil bool, canC var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -20238,7 +25825,13 @@ func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, checkNil bool, canC } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -20249,7 +25842,9 @@ func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, checkNil bool, canC v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20275,6 +25870,7 @@ func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, checkNil bool, d *De func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20294,7 +25890,13 @@ func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, checkNil bool, canChan var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -20302,13 +25904,21 @@ func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20334,6 +25944,7 @@ func (f fastpathT) DecMapUint8UintX(vp *map[uint8]uint, checkNil bool, d *Decode func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20353,7 +25964,13 @@ func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, checkNil bool, canChange b var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -20361,13 +25978,21 @@ func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20393,6 +26018,7 @@ func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, checkNil bool, d *Deco func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20412,7 +26038,13 @@ func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, checkNil bool, canChange var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -20420,13 +26052,21 @@ func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20452,6 +26092,7 @@ func (f fastpathT) DecMapUint8Uint16X(vp *map[uint8]uint16, checkNil bool, d *De func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20471,7 +26112,13 @@ func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, checkNil bool, canChan var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -20479,13 +26126,21 @@ func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20511,6 +26166,7 @@ func (f fastpathT) DecMapUint8Uint32X(vp *map[uint8]uint32, checkNil bool, d *De func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20530,7 +26186,13 @@ func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, checkNil bool, canChan var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -20538,13 +26200,21 @@ func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20570,6 +26240,7 @@ func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, checkNil bool, d *De func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20589,7 +26260,13 @@ func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, checkNil bool, canChan var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -20597,13 +26274,21 @@ func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20629,6 +26314,7 @@ func (f fastpathT) DecMapUint8UintptrX(vp *map[uint8]uintptr, checkNil bool, d * func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20648,7 +26334,13 @@ func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, canCh var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -20656,13 +26348,21 @@ func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20688,6 +26388,7 @@ func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, checkNil bool, d *Decoder) func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20707,7 +26408,13 @@ func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, checkNil bool, canChange boo var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -20715,13 +26422,21 @@ func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20747,6 +26462,7 @@ func (f fastpathT) DecMapUint8Int8X(vp *map[uint8]int8, checkNil bool, d *Decode func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20766,7 +26482,13 @@ func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, checkNil bool, canChange b var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -20774,13 +26496,21 @@ func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20806,6 +26536,7 @@ func (f fastpathT) DecMapUint8Int16X(vp *map[uint8]int16, checkNil bool, d *Deco func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20825,7 +26556,13 @@ func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, checkNil bool, canChange var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -20833,13 +26570,21 @@ func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20865,6 +26610,7 @@ func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, checkNil bool, d *Deco func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20884,7 +26630,13 @@ func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, checkNil bool, canChange var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -20892,13 +26644,21 @@ func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20924,6 +26684,7 @@ func (f fastpathT) DecMapUint8Int64X(vp *map[uint8]int64, checkNil bool, d *Deco func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -20943,7 +26704,13 @@ func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, checkNil bool, canChange var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -20951,13 +26718,21 @@ func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -20983,6 +26758,7 @@ func (f fastpathT) DecMapUint8Float32X(vp *map[uint8]float32, checkNil bool, d * func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21002,7 +26778,13 @@ func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, checkNil bool, canCh var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -21010,13 +26792,21 @@ func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21042,6 +26832,7 @@ func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, checkNil bool, d * func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21061,7 +26852,13 @@ func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, checkNil bool, canCh var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -21069,13 +26866,21 @@ func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21101,6 +26906,7 @@ func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, checkNil bool, d *Decode func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, checkNil bool, canChange bool, d *Decoder) (_ map[uint8]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21120,7 +26926,13 @@ func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, checkNil bool, canChange b var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -21128,13 +26940,21 @@ func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint8(dd.DecodeUint(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21160,6 +26980,7 @@ func (f fastpathT) DecMapUint16IntfX(vp *map[uint16]interface{}, checkNil bool, func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21179,7 +27000,13 @@ func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, checkNil bool, ca var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -21192,7 +27019,13 @@ func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, checkNil bool, ca } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -21203,7 +27036,9 @@ func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, checkNil bool, ca v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21229,6 +27064,7 @@ func (f fastpathT) DecMapUint16StringX(vp *map[uint16]string, checkNil bool, d * func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21248,7 +27084,13 @@ func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, checkNil bool, canCh var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -21256,13 +27098,21 @@ func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21288,6 +27138,7 @@ func (f fastpathT) DecMapUint16UintX(vp *map[uint16]uint, checkNil bool, d *Deco func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21307,7 +27158,13 @@ func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, checkNil bool, canChange var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -21315,13 +27172,21 @@ func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21347,6 +27212,7 @@ func (f fastpathT) DecMapUint16Uint8X(vp *map[uint16]uint8, checkNil bool, d *De func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21366,7 +27232,13 @@ func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, checkNil bool, canChan var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -21374,13 +27246,21 @@ func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21406,6 +27286,7 @@ func (f fastpathT) DecMapUint16Uint16X(vp *map[uint16]uint16, checkNil bool, d * func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21425,7 +27306,13 @@ func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, checkNil bool, canCh var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -21433,13 +27320,21 @@ func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21465,6 +27360,7 @@ func (f fastpathT) DecMapUint16Uint32X(vp *map[uint16]uint32, checkNil bool, d * func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21484,7 +27380,13 @@ func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, checkNil bool, canCh var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -21492,13 +27394,21 @@ func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21524,6 +27434,7 @@ func (f fastpathT) DecMapUint16Uint64X(vp *map[uint16]uint64, checkNil bool, d * func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21543,7 +27454,13 @@ func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, checkNil bool, canCh var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -21551,13 +27468,21 @@ func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21583,6 +27508,7 @@ func (f fastpathT) DecMapUint16UintptrX(vp *map[uint16]uintptr, checkNil bool, d func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21602,7 +27528,13 @@ func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, can var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -21610,13 +27542,21 @@ func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21642,6 +27582,7 @@ func (f fastpathT) DecMapUint16IntX(vp *map[uint16]int, checkNil bool, d *Decode func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21661,7 +27602,13 @@ func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, checkNil bool, canChange b var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -21669,13 +27616,21 @@ func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21701,6 +27656,7 @@ func (f fastpathT) DecMapUint16Int8X(vp *map[uint16]int8, checkNil bool, d *Deco func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21720,7 +27676,13 @@ func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, checkNil bool, canChange var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -21728,13 +27690,21 @@ func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21760,6 +27730,7 @@ func (f fastpathT) DecMapUint16Int16X(vp *map[uint16]int16, checkNil bool, d *De func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21779,7 +27750,13 @@ func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, checkNil bool, canChan var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -21787,13 +27764,21 @@ func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21819,6 +27804,7 @@ func (f fastpathT) DecMapUint16Int32X(vp *map[uint16]int32, checkNil bool, d *De func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21838,7 +27824,13 @@ func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, checkNil bool, canChan var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -21846,13 +27838,21 @@ func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21878,6 +27878,7 @@ func (f fastpathT) DecMapUint16Int64X(vp *map[uint16]int64, checkNil bool, d *De func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21897,7 +27898,13 @@ func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, checkNil bool, canChan var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -21905,13 +27912,21 @@ func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21937,6 +27952,7 @@ func (f fastpathT) DecMapUint16Float32X(vp *map[uint16]float32, checkNil bool, d func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -21956,7 +27972,13 @@ func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, checkNil bool, can var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -21964,13 +27986,21 @@ func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -21996,6 +28026,7 @@ func (f fastpathT) DecMapUint16Float64X(vp *map[uint16]float64, checkNil bool, d func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22015,7 +28046,13 @@ func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, checkNil bool, can var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -22023,13 +28060,21 @@ func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22055,6 +28100,7 @@ func (f fastpathT) DecMapUint16BoolX(vp *map[uint16]bool, checkNil bool, d *Deco func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, checkNil bool, canChange bool, d *Decoder) (_ map[uint16]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22074,7 +28120,13 @@ func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, checkNil bool, canChange var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -22082,13 +28134,21 @@ func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint16(dd.DecodeUint(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22114,6 +28174,7 @@ func (f fastpathT) DecMapUint32IntfX(vp *map[uint32]interface{}, checkNil bool, func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22133,7 +28194,13 @@ func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, checkNil bool, ca var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -22146,7 +28213,13 @@ func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, checkNil bool, ca } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -22157,7 +28230,9 @@ func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, checkNil bool, ca v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22183,6 +28258,7 @@ func (f fastpathT) DecMapUint32StringX(vp *map[uint32]string, checkNil bool, d * func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22202,7 +28278,13 @@ func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, checkNil bool, canCh var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -22210,13 +28292,21 @@ func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22242,6 +28332,7 @@ func (f fastpathT) DecMapUint32UintX(vp *map[uint32]uint, checkNil bool, d *Deco func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22261,7 +28352,13 @@ func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, checkNil bool, canChange var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -22269,13 +28366,21 @@ func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22301,6 +28406,7 @@ func (f fastpathT) DecMapUint32Uint8X(vp *map[uint32]uint8, checkNil bool, d *De func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22320,7 +28426,13 @@ func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, checkNil bool, canChan var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -22328,13 +28440,21 @@ func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22360,6 +28480,7 @@ func (f fastpathT) DecMapUint32Uint16X(vp *map[uint32]uint16, checkNil bool, d * func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22379,7 +28500,13 @@ func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, checkNil bool, canCh var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -22387,13 +28514,21 @@ func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22419,6 +28554,7 @@ func (f fastpathT) DecMapUint32Uint32X(vp *map[uint32]uint32, checkNil bool, d * func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22438,7 +28574,13 @@ func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, checkNil bool, canCh var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -22446,13 +28588,21 @@ func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22478,6 +28628,7 @@ func (f fastpathT) DecMapUint32Uint64X(vp *map[uint32]uint64, checkNil bool, d * func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22497,7 +28648,13 @@ func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, checkNil bool, canCh var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -22505,13 +28662,21 @@ func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22537,6 +28702,7 @@ func (f fastpathT) DecMapUint32UintptrX(vp *map[uint32]uintptr, checkNil bool, d func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22556,7 +28722,13 @@ func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, can var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -22564,13 +28736,21 @@ func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22596,6 +28776,7 @@ func (f fastpathT) DecMapUint32IntX(vp *map[uint32]int, checkNil bool, d *Decode func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22615,7 +28796,13 @@ func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, checkNil bool, canChange b var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -22623,13 +28810,21 @@ func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22655,6 +28850,7 @@ func (f fastpathT) DecMapUint32Int8X(vp *map[uint32]int8, checkNil bool, d *Deco func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22674,7 +28870,13 @@ func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, checkNil bool, canChange var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -22682,13 +28884,21 @@ func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22714,6 +28924,7 @@ func (f fastpathT) DecMapUint32Int16X(vp *map[uint32]int16, checkNil bool, d *De func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22733,7 +28944,13 @@ func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, checkNil bool, canChan var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -22741,13 +28958,21 @@ func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22773,6 +28998,7 @@ func (f fastpathT) DecMapUint32Int32X(vp *map[uint32]int32, checkNil bool, d *De func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22792,7 +29018,13 @@ func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, checkNil bool, canChan var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -22800,13 +29032,21 @@ func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22832,6 +29072,7 @@ func (f fastpathT) DecMapUint32Int64X(vp *map[uint32]int64, checkNil bool, d *De func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22851,7 +29092,13 @@ func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, checkNil bool, canChan var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -22859,13 +29106,21 @@ func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22891,6 +29146,7 @@ func (f fastpathT) DecMapUint32Float32X(vp *map[uint32]float32, checkNil bool, d func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22910,7 +29166,13 @@ func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, checkNil bool, can var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -22918,13 +29180,21 @@ func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -22950,6 +29220,7 @@ func (f fastpathT) DecMapUint32Float64X(vp *map[uint32]float64, checkNil bool, d func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -22969,7 +29240,13 @@ func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, checkNil bool, can var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -22977,13 +29254,21 @@ func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23009,6 +29294,7 @@ func (f fastpathT) DecMapUint32BoolX(vp *map[uint32]bool, checkNil bool, d *Deco func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, checkNil bool, canChange bool, d *Decoder) (_ map[uint32]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23028,7 +29314,13 @@ func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, checkNil bool, canChange var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -23036,13 +29328,21 @@ func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uint32(dd.DecodeUint(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23068,6 +29368,7 @@ func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, checkNil bool, func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23087,7 +29388,13 @@ func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, checkNil bool, ca var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -23100,7 +29407,13 @@ func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, checkNil bool, ca } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -23111,7 +29424,9 @@ func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, checkNil bool, ca v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23137,6 +29452,7 @@ func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, checkNil bool, d * func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23156,7 +29472,13 @@ func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, checkNil bool, canCh var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -23164,13 +29486,21 @@ func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23196,6 +29526,7 @@ func (f fastpathT) DecMapUint64UintX(vp *map[uint64]uint, checkNil bool, d *Deco func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23215,7 +29546,13 @@ func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, checkNil bool, canChange var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -23223,13 +29560,21 @@ func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23255,6 +29600,7 @@ func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, checkNil bool, d *De func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23274,7 +29620,13 @@ func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, checkNil bool, canChan var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -23282,13 +29634,21 @@ func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23314,6 +29674,7 @@ func (f fastpathT) DecMapUint64Uint16X(vp *map[uint64]uint16, checkNil bool, d * func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23333,7 +29694,13 @@ func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, checkNil bool, canCh var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -23341,13 +29708,21 @@ func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23373,6 +29748,7 @@ func (f fastpathT) DecMapUint64Uint32X(vp *map[uint64]uint32, checkNil bool, d * func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23392,7 +29768,13 @@ func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, checkNil bool, canCh var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -23400,13 +29782,21 @@ func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23432,6 +29822,7 @@ func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, checkNil bool, d * func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23451,7 +29842,13 @@ func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, checkNil bool, canCh var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -23459,13 +29856,21 @@ func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23491,6 +29896,7 @@ func (f fastpathT) DecMapUint64UintptrX(vp *map[uint64]uintptr, checkNil bool, d func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23510,7 +29916,13 @@ func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, can var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -23518,13 +29930,21 @@ func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23550,6 +29970,7 @@ func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, checkNil bool, d *Decode func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23569,7 +29990,13 @@ func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, checkNil bool, canChange b var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -23577,13 +30004,21 @@ func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23609,6 +30044,7 @@ func (f fastpathT) DecMapUint64Int8X(vp *map[uint64]int8, checkNil bool, d *Deco func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23628,7 +30064,13 @@ func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, checkNil bool, canChange var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -23636,13 +30078,21 @@ func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23668,6 +30118,7 @@ func (f fastpathT) DecMapUint64Int16X(vp *map[uint64]int16, checkNil bool, d *De func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23687,7 +30138,13 @@ func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, checkNil bool, canChan var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -23695,13 +30152,21 @@ func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23727,6 +30192,7 @@ func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, checkNil bool, d *De func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23746,7 +30212,13 @@ func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, checkNil bool, canChan var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -23754,13 +30226,21 @@ func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23786,6 +30266,7 @@ func (f fastpathT) DecMapUint64Int64X(vp *map[uint64]int64, checkNil bool, d *De func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23805,7 +30286,13 @@ func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, checkNil bool, canChan var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -23813,13 +30300,21 @@ func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23845,6 +30340,7 @@ func (f fastpathT) DecMapUint64Float32X(vp *map[uint64]float32, checkNil bool, d func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23864,7 +30360,13 @@ func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, checkNil bool, can var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -23872,13 +30374,21 @@ func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23904,6 +30414,7 @@ func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, checkNil bool, d func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23923,7 +30434,13 @@ func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, checkNil bool, can var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -23931,13 +30448,21 @@ func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -23963,6 +30488,7 @@ func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, checkNil bool, d *Deco func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, checkNil bool, canChange bool, d *Decoder) (_ map[uint64]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -23982,7 +30508,13 @@ func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, checkNil bool, canChange var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -23990,13 +30522,21 @@ func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeUint(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24022,6 +30562,7 @@ func (f fastpathT) DecMapUintptrIntfX(vp *map[uintptr]interface{}, checkNil bool func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24041,7 +30582,13 @@ func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -24054,7 +30601,13 @@ func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -24065,7 +30618,9 @@ func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24091,6 +30646,7 @@ func (f fastpathT) DecMapUintptrStringX(vp *map[uintptr]string, checkNil bool, d func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24110,7 +30666,13 @@ func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, checkNil bool, can var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -24118,13 +30680,21 @@ func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24150,6 +30720,7 @@ func (f fastpathT) DecMapUintptrUintX(vp *map[uintptr]uint, checkNil bool, d *De func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24169,7 +30740,13 @@ func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, checkNil bool, canChan var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -24177,13 +30754,21 @@ func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24209,6 +30794,7 @@ func (f fastpathT) DecMapUintptrUint8X(vp *map[uintptr]uint8, checkNil bool, d * func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24228,7 +30814,13 @@ func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, canCh var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -24236,13 +30828,21 @@ func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24268,6 +30868,7 @@ func (f fastpathT) DecMapUintptrUint16X(vp *map[uintptr]uint16, checkNil bool, d func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24287,7 +30888,13 @@ func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, can var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -24295,13 +30902,21 @@ func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24327,6 +30942,7 @@ func (f fastpathT) DecMapUintptrUint32X(vp *map[uintptr]uint32, checkNil bool, d func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24346,7 +30962,13 @@ func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, can var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -24354,13 +30976,21 @@ func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24386,6 +31016,7 @@ func (f fastpathT) DecMapUintptrUint64X(vp *map[uintptr]uint64, checkNil bool, d func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24405,7 +31036,13 @@ func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, can var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -24413,13 +31050,21 @@ func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, can } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24445,6 +31090,7 @@ func (f fastpathT) DecMapUintptrUintptrX(vp *map[uintptr]uintptr, checkNil bool, func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24464,7 +31110,13 @@ func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, c var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -24472,13 +31124,21 @@ func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, c } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24504,6 +31164,7 @@ func (f fastpathT) DecMapUintptrIntX(vp *map[uintptr]int, checkNil bool, d *Deco func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24523,7 +31184,13 @@ func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, checkNil bool, canChange var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -24531,13 +31198,21 @@ func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24563,6 +31238,7 @@ func (f fastpathT) DecMapUintptrInt8X(vp *map[uintptr]int8, checkNil bool, d *De func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24582,7 +31258,13 @@ func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, checkNil bool, canChan var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -24590,13 +31272,21 @@ func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24622,6 +31312,7 @@ func (f fastpathT) DecMapUintptrInt16X(vp *map[uintptr]int16, checkNil bool, d * func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24641,7 +31332,13 @@ func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, checkNil bool, canCh var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -24649,13 +31346,21 @@ func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24681,6 +31386,7 @@ func (f fastpathT) DecMapUintptrInt32X(vp *map[uintptr]int32, checkNil bool, d * func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24700,7 +31406,13 @@ func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, checkNil bool, canCh var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -24708,13 +31420,21 @@ func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24740,6 +31460,7 @@ func (f fastpathT) DecMapUintptrInt64X(vp *map[uintptr]int64, checkNil bool, d * func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24759,7 +31480,13 @@ func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, checkNil bool, canCh var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -24767,13 +31494,21 @@ func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24799,6 +31534,7 @@ func (f fastpathT) DecMapUintptrFloat32X(vp *map[uintptr]float32, checkNil bool, func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24818,7 +31554,13 @@ func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, c var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -24826,13 +31568,21 @@ func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, c } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24858,6 +31608,7 @@ func (f fastpathT) DecMapUintptrFloat64X(vp *map[uintptr]float64, checkNil bool, func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24877,7 +31628,13 @@ func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, c var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -24885,13 +31642,21 @@ func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, c } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24917,6 +31682,7 @@ func (f fastpathT) DecMapUintptrBoolX(vp *map[uintptr]bool, checkNil bool, d *De func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, checkNil bool, canChange bool, d *Decoder) (_ map[uintptr]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24936,7 +31702,13 @@ func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, checkNil bool, canChan var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -24944,13 +31716,21 @@ func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = uintptr(dd.DecodeUint(uintBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -24976,6 +31756,7 @@ func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, checkNil bool, d *Dec func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[int]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -24995,7 +31776,13 @@ func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, checkNil bool, canChang var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -25008,7 +31795,13 @@ func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, checkNil bool, canChang } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -25019,7 +31812,9 @@ func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, checkNil bool, canChang v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25045,6 +31840,7 @@ func (f fastpathT) DecMapIntStringX(vp *map[int]string, checkNil bool, d *Decode func (_ fastpathT) DecMapIntStringV(v map[int]string, checkNil bool, canChange bool, d *Decoder) (_ map[int]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25064,7 +31860,13 @@ func (_ fastpathT) DecMapIntStringV(v map[int]string, checkNil bool, canChange b var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -25072,13 +31874,21 @@ func (_ fastpathT) DecMapIntStringV(v map[int]string, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25104,6 +31914,7 @@ func (f fastpathT) DecMapIntUintX(vp *map[int]uint, checkNil bool, d *Decoder) { func (_ fastpathT) DecMapIntUintV(v map[int]uint, checkNil bool, canChange bool, d *Decoder) (_ map[int]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25123,7 +31934,13 @@ func (_ fastpathT) DecMapIntUintV(v map[int]uint, checkNil bool, canChange bool, var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -25131,13 +31948,21 @@ func (_ fastpathT) DecMapIntUintV(v map[int]uint, checkNil bool, canChange bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25163,6 +31988,7 @@ func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, checkNil bool, d *Decoder) func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[int]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25182,7 +32008,13 @@ func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, checkNil bool, canChange boo var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -25190,13 +32022,21 @@ func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25222,6 +32062,7 @@ func (f fastpathT) DecMapIntUint16X(vp *map[int]uint16, checkNil bool, d *Decode func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[int]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25241,7 +32082,13 @@ func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, checkNil bool, canChange b var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -25249,13 +32096,21 @@ func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25281,6 +32136,7 @@ func (f fastpathT) DecMapIntUint32X(vp *map[int]uint32, checkNil bool, d *Decode func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[int]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25300,7 +32156,13 @@ func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, checkNil bool, canChange b var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -25308,13 +32170,21 @@ func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25340,6 +32210,7 @@ func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, checkNil bool, d *Decode func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[int]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25359,7 +32230,13 @@ func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, checkNil bool, canChange b var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -25367,13 +32244,21 @@ func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25399,6 +32284,7 @@ func (f fastpathT) DecMapIntUintptrX(vp *map[int]uintptr, checkNil bool, d *Deco func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[int]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25418,7 +32304,13 @@ func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, checkNil bool, canChange var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -25426,13 +32318,21 @@ func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25458,6 +32358,7 @@ func (f fastpathT) DecMapIntIntX(vp *map[int]int, checkNil bool, d *Decoder) { func (_ fastpathT) DecMapIntIntV(v map[int]int, checkNil bool, canChange bool, d *Decoder) (_ map[int]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25477,7 +32378,13 @@ func (_ fastpathT) DecMapIntIntV(v map[int]int, checkNil bool, canChange bool, var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -25485,13 +32392,21 @@ func (_ fastpathT) DecMapIntIntV(v map[int]int, checkNil bool, canChange bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25517,6 +32432,7 @@ func (f fastpathT) DecMapIntInt8X(vp *map[int]int8, checkNil bool, d *Decoder) { func (_ fastpathT) DecMapIntInt8V(v map[int]int8, checkNil bool, canChange bool, d *Decoder) (_ map[int]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25536,7 +32452,13 @@ func (_ fastpathT) DecMapIntInt8V(v map[int]int8, checkNil bool, canChange bool, var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -25544,13 +32466,21 @@ func (_ fastpathT) DecMapIntInt8V(v map[int]int8, checkNil bool, canChange bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25576,6 +32506,7 @@ func (f fastpathT) DecMapIntInt16X(vp *map[int]int16, checkNil bool, d *Decoder) func (_ fastpathT) DecMapIntInt16V(v map[int]int16, checkNil bool, canChange bool, d *Decoder) (_ map[int]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25595,7 +32526,13 @@ func (_ fastpathT) DecMapIntInt16V(v map[int]int16, checkNil bool, canChange boo var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -25603,13 +32540,21 @@ func (_ fastpathT) DecMapIntInt16V(v map[int]int16, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25635,6 +32580,7 @@ func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, checkNil bool, d *Decoder) func (_ fastpathT) DecMapIntInt32V(v map[int]int32, checkNil bool, canChange bool, d *Decoder) (_ map[int]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25654,7 +32600,13 @@ func (_ fastpathT) DecMapIntInt32V(v map[int]int32, checkNil bool, canChange boo var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -25662,13 +32614,21 @@ func (_ fastpathT) DecMapIntInt32V(v map[int]int32, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25694,6 +32654,7 @@ func (f fastpathT) DecMapIntInt64X(vp *map[int]int64, checkNil bool, d *Decoder) func (_ fastpathT) DecMapIntInt64V(v map[int]int64, checkNil bool, canChange bool, d *Decoder) (_ map[int]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25713,7 +32674,13 @@ func (_ fastpathT) DecMapIntInt64V(v map[int]int64, checkNil bool, canChange boo var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -25721,13 +32688,21 @@ func (_ fastpathT) DecMapIntInt64V(v map[int]int64, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25753,6 +32728,7 @@ func (f fastpathT) DecMapIntFloat32X(vp *map[int]float32, checkNil bool, d *Deco func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, checkNil bool, canChange bool, d *Decoder) (_ map[int]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25772,7 +32748,13 @@ func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, checkNil bool, canChange var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -25780,13 +32762,21 @@ func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25812,6 +32802,7 @@ func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, checkNil bool, d *Deco func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, checkNil bool, canChange bool, d *Decoder) (_ map[int]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25831,7 +32822,13 @@ func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, checkNil bool, canChange var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -25839,13 +32836,21 @@ func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25871,6 +32876,7 @@ func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, checkNil bool, d *Decoder) { func (_ fastpathT) DecMapIntBoolV(v map[int]bool, checkNil bool, canChange bool, d *Decoder) (_ map[int]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25890,7 +32896,13 @@ func (_ fastpathT) DecMapIntBoolV(v map[int]bool, checkNil bool, canChange bool, var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -25898,13 +32910,21 @@ func (_ fastpathT) DecMapIntBoolV(v map[int]bool, checkNil bool, canChange bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int(dd.DecodeInt(intBitsize)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25930,6 +32950,7 @@ func (f fastpathT) DecMapInt8IntfX(vp *map[int8]interface{}, checkNil bool, d *D func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[int8]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -25949,7 +32970,13 @@ func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, checkNil bool, canCha var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -25962,7 +32989,13 @@ func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, checkNil bool, canCha } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -25973,7 +33006,9 @@ func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, checkNil bool, canCha v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -25999,6 +33034,7 @@ func (f fastpathT) DecMapInt8StringX(vp *map[int8]string, checkNil bool, d *Deco func (_ fastpathT) DecMapInt8StringV(v map[int8]string, checkNil bool, canChange bool, d *Decoder) (_ map[int8]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26018,7 +33054,13 @@ func (_ fastpathT) DecMapInt8StringV(v map[int8]string, checkNil bool, canChange var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -26026,13 +33068,21 @@ func (_ fastpathT) DecMapInt8StringV(v map[int8]string, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26058,6 +33108,7 @@ func (f fastpathT) DecMapInt8UintX(vp *map[int8]uint, checkNil bool, d *Decoder) func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, checkNil bool, canChange bool, d *Decoder) (_ map[int8]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26077,7 +33128,13 @@ func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, checkNil bool, canChange boo var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -26085,13 +33142,21 @@ func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26117,6 +33182,7 @@ func (f fastpathT) DecMapInt8Uint8X(vp *map[int8]uint8, checkNil bool, d *Decode func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[int8]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26136,7 +33202,13 @@ func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, checkNil bool, canChange b var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -26144,13 +33216,21 @@ func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26176,6 +33256,7 @@ func (f fastpathT) DecMapInt8Uint16X(vp *map[int8]uint16, checkNil bool, d *Deco func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[int8]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26195,7 +33276,13 @@ func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, checkNil bool, canChange var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -26203,13 +33290,21 @@ func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26235,6 +33330,7 @@ func (f fastpathT) DecMapInt8Uint32X(vp *map[int8]uint32, checkNil bool, d *Deco func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[int8]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26254,7 +33350,13 @@ func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, checkNil bool, canChange var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -26262,13 +33364,21 @@ func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26294,6 +33404,7 @@ func (f fastpathT) DecMapInt8Uint64X(vp *map[int8]uint64, checkNil bool, d *Deco func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[int8]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26313,7 +33424,13 @@ func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, checkNil bool, canChange var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -26321,13 +33438,21 @@ func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26353,6 +33478,7 @@ func (f fastpathT) DecMapInt8UintptrX(vp *map[int8]uintptr, checkNil bool, d *De func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[int8]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26372,7 +33498,13 @@ func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, checkNil bool, canChan var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -26380,13 +33512,21 @@ func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26412,6 +33552,7 @@ func (f fastpathT) DecMapInt8IntX(vp *map[int8]int, checkNil bool, d *Decoder) { func (_ fastpathT) DecMapInt8IntV(v map[int8]int, checkNil bool, canChange bool, d *Decoder) (_ map[int8]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26431,7 +33572,13 @@ func (_ fastpathT) DecMapInt8IntV(v map[int8]int, checkNil bool, canChange bool, var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -26439,13 +33586,21 @@ func (_ fastpathT) DecMapInt8IntV(v map[int8]int, checkNil bool, canChange bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26471,6 +33626,7 @@ func (f fastpathT) DecMapInt8Int8X(vp *map[int8]int8, checkNil bool, d *Decoder) func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, checkNil bool, canChange bool, d *Decoder) (_ map[int8]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26490,7 +33646,13 @@ func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, checkNil bool, canChange boo var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -26498,13 +33660,21 @@ func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26530,6 +33700,7 @@ func (f fastpathT) DecMapInt8Int16X(vp *map[int8]int16, checkNil bool, d *Decode func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, checkNil bool, canChange bool, d *Decoder) (_ map[int8]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26549,7 +33720,13 @@ func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, checkNil bool, canChange b var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -26557,13 +33734,21 @@ func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26589,6 +33774,7 @@ func (f fastpathT) DecMapInt8Int32X(vp *map[int8]int32, checkNil bool, d *Decode func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, checkNil bool, canChange bool, d *Decoder) (_ map[int8]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26608,7 +33794,13 @@ func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, checkNil bool, canChange b var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -26616,13 +33808,21 @@ func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26648,6 +33848,7 @@ func (f fastpathT) DecMapInt8Int64X(vp *map[int8]int64, checkNil bool, d *Decode func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, checkNil bool, canChange bool, d *Decoder) (_ map[int8]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26667,7 +33868,13 @@ func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, checkNil bool, canChange b var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -26675,13 +33882,21 @@ func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26707,6 +33922,7 @@ func (f fastpathT) DecMapInt8Float32X(vp *map[int8]float32, checkNil bool, d *De func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, checkNil bool, canChange bool, d *Decoder) (_ map[int8]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26726,7 +33942,13 @@ func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, checkNil bool, canChan var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -26734,13 +33956,21 @@ func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26766,6 +33996,7 @@ func (f fastpathT) DecMapInt8Float64X(vp *map[int8]float64, checkNil bool, d *De func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, checkNil bool, canChange bool, d *Decoder) (_ map[int8]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26785,7 +34016,13 @@ func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, checkNil bool, canChan var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -26793,13 +34030,21 @@ func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26825,6 +34070,7 @@ func (f fastpathT) DecMapInt8BoolX(vp *map[int8]bool, checkNil bool, d *Decoder) func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, checkNil bool, canChange bool, d *Decoder) (_ map[int8]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26844,7 +34090,13 @@ func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, checkNil bool, canChange boo var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -26852,13 +34104,21 @@ func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int8(dd.DecodeInt(8)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26884,6 +34144,7 @@ func (f fastpathT) DecMapInt16IntfX(vp *map[int16]interface{}, checkNil bool, d func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[int16]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26903,7 +34164,13 @@ func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, checkNil bool, canC var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -26916,7 +34183,13 @@ func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, checkNil bool, canC } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -26927,7 +34200,9 @@ func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, checkNil bool, canC v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -26953,6 +34228,7 @@ func (f fastpathT) DecMapInt16StringX(vp *map[int16]string, checkNil bool, d *De func (_ fastpathT) DecMapInt16StringV(v map[int16]string, checkNil bool, canChange bool, d *Decoder) (_ map[int16]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -26972,7 +34248,13 @@ func (_ fastpathT) DecMapInt16StringV(v map[int16]string, checkNil bool, canChan var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -26980,13 +34262,21 @@ func (_ fastpathT) DecMapInt16StringV(v map[int16]string, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27012,6 +34302,7 @@ func (f fastpathT) DecMapInt16UintX(vp *map[int16]uint, checkNil bool, d *Decode func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, checkNil bool, canChange bool, d *Decoder) (_ map[int16]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27031,7 +34322,13 @@ func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, checkNil bool, canChange b var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -27039,13 +34336,21 @@ func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27071,6 +34376,7 @@ func (f fastpathT) DecMapInt16Uint8X(vp *map[int16]uint8, checkNil bool, d *Deco func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[int16]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27090,7 +34396,13 @@ func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, checkNil bool, canChange var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -27098,13 +34410,21 @@ func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27130,6 +34450,7 @@ func (f fastpathT) DecMapInt16Uint16X(vp *map[int16]uint16, checkNil bool, d *De func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[int16]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27149,7 +34470,13 @@ func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, checkNil bool, canChan var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -27157,13 +34484,21 @@ func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27189,6 +34524,7 @@ func (f fastpathT) DecMapInt16Uint32X(vp *map[int16]uint32, checkNil bool, d *De func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[int16]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27208,7 +34544,13 @@ func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, checkNil bool, canChan var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -27216,13 +34558,21 @@ func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27248,6 +34598,7 @@ func (f fastpathT) DecMapInt16Uint64X(vp *map[int16]uint64, checkNil bool, d *De func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[int16]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27267,7 +34618,13 @@ func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, checkNil bool, canChan var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -27275,13 +34632,21 @@ func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27307,6 +34672,7 @@ func (f fastpathT) DecMapInt16UintptrX(vp *map[int16]uintptr, checkNil bool, d * func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[int16]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27326,7 +34692,13 @@ func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, checkNil bool, canCh var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -27334,13 +34706,21 @@ func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27366,6 +34746,7 @@ func (f fastpathT) DecMapInt16IntX(vp *map[int16]int, checkNil bool, d *Decoder) func (_ fastpathT) DecMapInt16IntV(v map[int16]int, checkNil bool, canChange bool, d *Decoder) (_ map[int16]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27385,7 +34766,13 @@ func (_ fastpathT) DecMapInt16IntV(v map[int16]int, checkNil bool, canChange boo var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -27393,13 +34780,21 @@ func (_ fastpathT) DecMapInt16IntV(v map[int16]int, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27425,6 +34820,7 @@ func (f fastpathT) DecMapInt16Int8X(vp *map[int16]int8, checkNil bool, d *Decode func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, checkNil bool, canChange bool, d *Decoder) (_ map[int16]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27444,7 +34840,13 @@ func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, checkNil bool, canChange b var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -27452,13 +34854,21 @@ func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27484,6 +34894,7 @@ func (f fastpathT) DecMapInt16Int16X(vp *map[int16]int16, checkNil bool, d *Deco func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, checkNil bool, canChange bool, d *Decoder) (_ map[int16]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27503,7 +34914,13 @@ func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, checkNil bool, canChange var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -27511,13 +34928,21 @@ func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27543,6 +34968,7 @@ func (f fastpathT) DecMapInt16Int32X(vp *map[int16]int32, checkNil bool, d *Deco func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, checkNil bool, canChange bool, d *Decoder) (_ map[int16]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27562,7 +34988,13 @@ func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, checkNil bool, canChange var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -27570,13 +35002,21 @@ func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27602,6 +35042,7 @@ func (f fastpathT) DecMapInt16Int64X(vp *map[int16]int64, checkNil bool, d *Deco func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, checkNil bool, canChange bool, d *Decoder) (_ map[int16]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27621,7 +35062,13 @@ func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, checkNil bool, canChange var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -27629,13 +35076,21 @@ func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27661,6 +35116,7 @@ func (f fastpathT) DecMapInt16Float32X(vp *map[int16]float32, checkNil bool, d * func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, checkNil bool, canChange bool, d *Decoder) (_ map[int16]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27680,7 +35136,13 @@ func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, checkNil bool, canCh var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -27688,13 +35150,21 @@ func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27720,6 +35190,7 @@ func (f fastpathT) DecMapInt16Float64X(vp *map[int16]float64, checkNil bool, d * func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, checkNil bool, canChange bool, d *Decoder) (_ map[int16]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27739,7 +35210,13 @@ func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, checkNil bool, canCh var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -27747,13 +35224,21 @@ func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27779,6 +35264,7 @@ func (f fastpathT) DecMapInt16BoolX(vp *map[int16]bool, checkNil bool, d *Decode func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, checkNil bool, canChange bool, d *Decoder) (_ map[int16]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27798,7 +35284,13 @@ func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, checkNil bool, canChange b var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -27806,13 +35298,21 @@ func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int16(dd.DecodeInt(16)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27838,6 +35338,7 @@ func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, checkNil bool, d func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[int32]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27857,7 +35358,13 @@ func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, checkNil bool, canC var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -27870,7 +35377,13 @@ func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, checkNil bool, canC } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -27881,7 +35394,9 @@ func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, checkNil bool, canC v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27907,6 +35422,7 @@ func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, checkNil bool, d *De func (_ fastpathT) DecMapInt32StringV(v map[int32]string, checkNil bool, canChange bool, d *Decoder) (_ map[int32]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27926,7 +35442,13 @@ func (_ fastpathT) DecMapInt32StringV(v map[int32]string, checkNil bool, canChan var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -27934,13 +35456,21 @@ func (_ fastpathT) DecMapInt32StringV(v map[int32]string, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -27966,6 +35496,7 @@ func (f fastpathT) DecMapInt32UintX(vp *map[int32]uint, checkNil bool, d *Decode func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, checkNil bool, canChange bool, d *Decoder) (_ map[int32]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -27985,7 +35516,13 @@ func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, checkNil bool, canChange b var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -27993,13 +35530,21 @@ func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28025,6 +35570,7 @@ func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, checkNil bool, d *Deco func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[int32]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28044,7 +35590,13 @@ func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, checkNil bool, canChange var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -28052,13 +35604,21 @@ func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28084,6 +35644,7 @@ func (f fastpathT) DecMapInt32Uint16X(vp *map[int32]uint16, checkNil bool, d *De func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[int32]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28103,7 +35664,13 @@ func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, checkNil bool, canChan var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -28111,13 +35678,21 @@ func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28143,6 +35718,7 @@ func (f fastpathT) DecMapInt32Uint32X(vp *map[int32]uint32, checkNil bool, d *De func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[int32]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28162,7 +35738,13 @@ func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, checkNil bool, canChan var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -28170,13 +35752,21 @@ func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28202,6 +35792,7 @@ func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, checkNil bool, d *De func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[int32]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28221,7 +35812,13 @@ func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, checkNil bool, canChan var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -28229,13 +35826,21 @@ func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28261,6 +35866,7 @@ func (f fastpathT) DecMapInt32UintptrX(vp *map[int32]uintptr, checkNil bool, d * func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[int32]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28280,7 +35886,13 @@ func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, checkNil bool, canCh var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -28288,13 +35900,21 @@ func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28320,6 +35940,7 @@ func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, checkNil bool, d *Decoder) func (_ fastpathT) DecMapInt32IntV(v map[int32]int, checkNil bool, canChange bool, d *Decoder) (_ map[int32]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28339,7 +35960,13 @@ func (_ fastpathT) DecMapInt32IntV(v map[int32]int, checkNil bool, canChange boo var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -28347,13 +35974,21 @@ func (_ fastpathT) DecMapInt32IntV(v map[int32]int, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28379,6 +36014,7 @@ func (f fastpathT) DecMapInt32Int8X(vp *map[int32]int8, checkNil bool, d *Decode func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, checkNil bool, canChange bool, d *Decoder) (_ map[int32]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28398,7 +36034,13 @@ func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, checkNil bool, canChange b var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -28406,13 +36048,21 @@ func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28438,6 +36088,7 @@ func (f fastpathT) DecMapInt32Int16X(vp *map[int32]int16, checkNil bool, d *Deco func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, checkNil bool, canChange bool, d *Decoder) (_ map[int32]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28457,7 +36108,13 @@ func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, checkNil bool, canChange var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -28465,13 +36122,21 @@ func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28497,6 +36162,7 @@ func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, checkNil bool, d *Deco func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, checkNil bool, canChange bool, d *Decoder) (_ map[int32]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28516,7 +36182,13 @@ func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, checkNil bool, canChange var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -28524,13 +36196,21 @@ func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28556,6 +36236,7 @@ func (f fastpathT) DecMapInt32Int64X(vp *map[int32]int64, checkNil bool, d *Deco func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, checkNil bool, canChange bool, d *Decoder) (_ map[int32]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28575,7 +36256,13 @@ func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, checkNil bool, canChange var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -28583,13 +36270,21 @@ func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28615,6 +36310,7 @@ func (f fastpathT) DecMapInt32Float32X(vp *map[int32]float32, checkNil bool, d * func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, checkNil bool, canChange bool, d *Decoder) (_ map[int32]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28634,7 +36330,13 @@ func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, checkNil bool, canCh var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -28642,13 +36344,21 @@ func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28674,6 +36384,7 @@ func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, checkNil bool, d * func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, checkNil bool, canChange bool, d *Decoder) (_ map[int32]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28693,7 +36404,13 @@ func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, checkNil bool, canCh var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -28701,13 +36418,21 @@ func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28733,6 +36458,7 @@ func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, checkNil bool, d *Decode func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, checkNil bool, canChange bool, d *Decoder) (_ map[int32]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28752,7 +36478,13 @@ func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, checkNil bool, canChange b var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -28760,13 +36492,21 @@ func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = int32(dd.DecodeInt(32)) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28792,6 +36532,7 @@ func (f fastpathT) DecMapInt64IntfX(vp *map[int64]interface{}, checkNil bool, d func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[int64]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28811,7 +36552,13 @@ func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, checkNil bool, canC var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -28824,7 +36571,13 @@ func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, checkNil bool, canC } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -28835,7 +36588,9 @@ func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, checkNil bool, canC v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28861,6 +36616,7 @@ func (f fastpathT) DecMapInt64StringX(vp *map[int64]string, checkNil bool, d *De func (_ fastpathT) DecMapInt64StringV(v map[int64]string, checkNil bool, canChange bool, d *Decoder) (_ map[int64]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28880,7 +36636,13 @@ func (_ fastpathT) DecMapInt64StringV(v map[int64]string, checkNil bool, canChan var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -28888,13 +36650,21 @@ func (_ fastpathT) DecMapInt64StringV(v map[int64]string, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28920,6 +36690,7 @@ func (f fastpathT) DecMapInt64UintX(vp *map[int64]uint, checkNil bool, d *Decode func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, checkNil bool, canChange bool, d *Decoder) (_ map[int64]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28939,7 +36710,13 @@ func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, checkNil bool, canChange b var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -28947,13 +36724,21 @@ func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -28979,6 +36764,7 @@ func (f fastpathT) DecMapInt64Uint8X(vp *map[int64]uint8, checkNil bool, d *Deco func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[int64]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -28998,7 +36784,13 @@ func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, checkNil bool, canChange var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -29006,13 +36798,21 @@ func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29038,6 +36838,7 @@ func (f fastpathT) DecMapInt64Uint16X(vp *map[int64]uint16, checkNil bool, d *De func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[int64]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29057,7 +36858,13 @@ func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, checkNil bool, canChan var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -29065,13 +36872,21 @@ func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29097,6 +36912,7 @@ func (f fastpathT) DecMapInt64Uint32X(vp *map[int64]uint32, checkNil bool, d *De func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[int64]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29116,7 +36932,13 @@ func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, checkNil bool, canChan var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -29124,13 +36946,21 @@ func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29156,6 +36986,7 @@ func (f fastpathT) DecMapInt64Uint64X(vp *map[int64]uint64, checkNil bool, d *De func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[int64]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29175,7 +37006,13 @@ func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, checkNil bool, canChan var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -29183,13 +37020,21 @@ func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29215,6 +37060,7 @@ func (f fastpathT) DecMapInt64UintptrX(vp *map[int64]uintptr, checkNil bool, d * func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[int64]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29234,7 +37080,13 @@ func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, checkNil bool, canCh var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -29242,13 +37094,21 @@ func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29274,6 +37134,7 @@ func (f fastpathT) DecMapInt64IntX(vp *map[int64]int, checkNil bool, d *Decoder) func (_ fastpathT) DecMapInt64IntV(v map[int64]int, checkNil bool, canChange bool, d *Decoder) (_ map[int64]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29293,7 +37154,13 @@ func (_ fastpathT) DecMapInt64IntV(v map[int64]int, checkNil bool, canChange boo var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -29301,13 +37168,21 @@ func (_ fastpathT) DecMapInt64IntV(v map[int64]int, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29333,6 +37208,7 @@ func (f fastpathT) DecMapInt64Int8X(vp *map[int64]int8, checkNil bool, d *Decode func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, checkNil bool, canChange bool, d *Decoder) (_ map[int64]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29352,7 +37228,13 @@ func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, checkNil bool, canChange b var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -29360,13 +37242,21 @@ func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29392,6 +37282,7 @@ func (f fastpathT) DecMapInt64Int16X(vp *map[int64]int16, checkNil bool, d *Deco func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, checkNil bool, canChange bool, d *Decoder) (_ map[int64]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29411,7 +37302,13 @@ func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, checkNil bool, canChange var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -29419,13 +37316,21 @@ func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29451,6 +37356,7 @@ func (f fastpathT) DecMapInt64Int32X(vp *map[int64]int32, checkNil bool, d *Deco func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, checkNil bool, canChange bool, d *Decoder) (_ map[int64]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29470,7 +37376,13 @@ func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, checkNil bool, canChange var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -29478,13 +37390,21 @@ func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29510,6 +37430,7 @@ func (f fastpathT) DecMapInt64Int64X(vp *map[int64]int64, checkNil bool, d *Deco func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, checkNil bool, canChange bool, d *Decoder) (_ map[int64]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29529,7 +37450,13 @@ func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, checkNil bool, canChange var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -29537,13 +37464,21 @@ func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29569,6 +37504,7 @@ func (f fastpathT) DecMapInt64Float32X(vp *map[int64]float32, checkNil bool, d * func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, checkNil bool, canChange bool, d *Decoder) (_ map[int64]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29588,7 +37524,13 @@ func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, checkNil bool, canCh var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -29596,13 +37538,21 @@ func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29628,6 +37578,7 @@ func (f fastpathT) DecMapInt64Float64X(vp *map[int64]float64, checkNil bool, d * func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, checkNil bool, canChange bool, d *Decoder) (_ map[int64]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29647,7 +37598,13 @@ func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, checkNil bool, canCh var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -29655,13 +37612,21 @@ func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, checkNil bool, canCh } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29687,6 +37652,7 @@ func (f fastpathT) DecMapInt64BoolX(vp *map[int64]bool, checkNil bool, d *Decode func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, checkNil bool, canChange bool, d *Decoder) (_ map[int64]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29706,7 +37672,13 @@ func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, checkNil bool, canChange b var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -29714,13 +37686,21 @@ func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeInt(64) + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29746,6 +37726,7 @@ func (f fastpathT) DecMapBoolIntfX(vp *map[bool]interface{}, checkNil bool, d *D func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, checkNil bool, canChange bool, d *Decoder) (_ map[bool]interface{}, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29765,7 +37746,13 @@ func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, checkNil bool, canCha var mv interface{} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -29778,7 +37765,13 @@ func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, checkNil bool, canCha } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } if mapGet { mv = v[mk] } else { @@ -29789,7 +37782,9 @@ func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, checkNil bool, canCha v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29815,6 +37810,7 @@ func (f fastpathT) DecMapBoolStringX(vp *map[bool]string, checkNil bool, d *Deco func (_ fastpathT) DecMapBoolStringV(v map[bool]string, checkNil bool, canChange bool, d *Decoder) (_ map[bool]string, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29834,7 +37830,13 @@ func (_ fastpathT) DecMapBoolStringV(v map[bool]string, checkNil bool, canChange var mv string if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv @@ -29842,13 +37844,21 @@ func (_ fastpathT) DecMapBoolStringV(v map[bool]string, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeString() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29874,6 +37884,7 @@ func (f fastpathT) DecMapBoolUintX(vp *map[bool]uint, checkNil bool, d *Decoder) func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, checkNil bool, canChange bool, d *Decoder) (_ map[bool]uint, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29893,7 +37904,13 @@ func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, checkNil bool, canChange boo var mv uint if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -29901,13 +37918,21 @@ func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29933,6 +37958,7 @@ func (f fastpathT) DecMapBoolUint8X(vp *map[bool]uint8, checkNil bool, d *Decode func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, checkNil bool, canChange bool, d *Decoder) (_ map[bool]uint8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -29952,7 +37978,13 @@ func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, checkNil bool, canChange b var mv uint8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv @@ -29960,13 +37992,21 @@ func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint8(dd.DecodeUint(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -29992,6 +38032,7 @@ func (f fastpathT) DecMapBoolUint16X(vp *map[bool]uint16, checkNil bool, d *Deco func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, checkNil bool, canChange bool, d *Decoder) (_ map[bool]uint16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30011,7 +38052,13 @@ func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, checkNil bool, canChange var mv uint16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv @@ -30019,13 +38066,21 @@ func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint16(dd.DecodeUint(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30051,6 +38106,7 @@ func (f fastpathT) DecMapBoolUint32X(vp *map[bool]uint32, checkNil bool, d *Deco func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, checkNil bool, canChange bool, d *Decoder) (_ map[bool]uint32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30070,7 +38126,13 @@ func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, checkNil bool, canChange var mv uint32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv @@ -30078,13 +38140,21 @@ func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uint32(dd.DecodeUint(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30110,6 +38180,7 @@ func (f fastpathT) DecMapBoolUint64X(vp *map[bool]uint64, checkNil bool, d *Deco func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, checkNil bool, canChange bool, d *Decoder) (_ map[bool]uint64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30129,7 +38200,13 @@ func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, checkNil bool, canChange var mv uint64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv @@ -30137,13 +38214,21 @@ func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, checkNil bool, canChange } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeUint(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30169,6 +38254,7 @@ func (f fastpathT) DecMapBoolUintptrX(vp *map[bool]uintptr, checkNil bool, d *De func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, checkNil bool, canChange bool, d *Decoder) (_ map[bool]uintptr, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30188,7 +38274,13 @@ func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, checkNil bool, canChan var mv uintptr if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv @@ -30196,13 +38288,21 @@ func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = uintptr(dd.DecodeUint(uintBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30228,6 +38328,7 @@ func (f fastpathT) DecMapBoolIntX(vp *map[bool]int, checkNil bool, d *Decoder) { func (_ fastpathT) DecMapBoolIntV(v map[bool]int, checkNil bool, canChange bool, d *Decoder) (_ map[bool]int, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30247,7 +38348,13 @@ func (_ fastpathT) DecMapBoolIntV(v map[bool]int, checkNil bool, canChange bool, var mv int if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv @@ -30255,13 +38362,21 @@ func (_ fastpathT) DecMapBoolIntV(v map[bool]int, checkNil bool, canChange bool, } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int(dd.DecodeInt(intBitsize)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30287,6 +38402,7 @@ func (f fastpathT) DecMapBoolInt8X(vp *map[bool]int8, checkNil bool, d *Decoder) func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, checkNil bool, canChange bool, d *Decoder) (_ map[bool]int8, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30306,7 +38422,13 @@ func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, checkNil bool, canChange boo var mv int8 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv @@ -30314,13 +38436,21 @@ func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int8(dd.DecodeInt(8)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30346,6 +38476,7 @@ func (f fastpathT) DecMapBoolInt16X(vp *map[bool]int16, checkNil bool, d *Decode func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, checkNil bool, canChange bool, d *Decoder) (_ map[bool]int16, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30365,7 +38496,13 @@ func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, checkNil bool, canChange b var mv int16 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv @@ -30373,13 +38510,21 @@ func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int16(dd.DecodeInt(16)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30405,6 +38550,7 @@ func (f fastpathT) DecMapBoolInt32X(vp *map[bool]int32, checkNil bool, d *Decode func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, checkNil bool, canChange bool, d *Decoder) (_ map[bool]int32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30424,7 +38570,13 @@ func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, checkNil bool, canChange b var mv int32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv @@ -30432,13 +38584,21 @@ func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = int32(dd.DecodeInt(32)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30464,6 +38624,7 @@ func (f fastpathT) DecMapBoolInt64X(vp *map[bool]int64, checkNil bool, d *Decode func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, checkNil bool, canChange bool, d *Decoder) (_ map[bool]int64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30483,7 +38644,13 @@ func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, checkNil bool, canChange b var mv int64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv @@ -30491,13 +38658,21 @@ func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, checkNil bool, canChange b } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeInt(64) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30523,6 +38698,7 @@ func (f fastpathT) DecMapBoolFloat32X(vp *map[bool]float32, checkNil bool, d *De func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, checkNil bool, canChange bool, d *Decoder) (_ map[bool]float32, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30542,7 +38718,13 @@ func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, checkNil bool, canChan var mv float32 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv @@ -30550,13 +38732,21 @@ func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = float32(dd.DecodeFloat(true)) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30582,6 +38772,7 @@ func (f fastpathT) DecMapBoolFloat64X(vp *map[bool]float64, checkNil bool, d *De func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, checkNil bool, canChange bool, d *Decoder) (_ map[bool]float64, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30601,7 +38792,13 @@ func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, checkNil bool, canChan var mv float64 if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv @@ -30609,13 +38806,21 @@ func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, checkNil bool, canChan } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeFloat(false) if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } @@ -30641,6 +38846,7 @@ func (f fastpathT) DecMapBoolBoolX(vp *map[bool]bool, checkNil bool, d *Decoder) func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, checkNil bool, canChange bool, d *Decoder) (_ map[bool]bool, changed bool) { dd := d.d + cr := d.cr if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -30660,7 +38866,13 @@ func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, checkNil bool, canChange boo var mv bool if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv @@ -30668,13 +38880,21 @@ func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, checkNil bool, canChange boo } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { + cr.sendContainerState(containerMapKey) + } mk = dd.DecodeBool() + if cr != nil { + cr.sendContainerState(containerMapValue) + } mv = dd.DecodeBool() if v != nil { v[mk] = mv } } - dd.ReadEnd() + } + if cr != nil { + cr.sendContainerState(containerMapEnd) } return v, changed } diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.go.tmpl b/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.go.tmpl index 7bcbaf83107..58cc6df4c54 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.go.tmpl +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.go.tmpl @@ -1,4 +1,4 @@ -// //+build ignore +// +build !notfastpath // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved. // Use of this source code is governed by a MIT license found in the LICENSE file. @@ -106,6 +106,9 @@ func init() { // -- -- fast path type switch func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool { + if !fastpathEnabled { + return false + } switch v := iv.(type) { {{range .Values}}{{if not .Primitive}}{{if not .MapKey }} case []{{ .Elem }}:{{else}} @@ -116,13 +119,16 @@ func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool { fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e) {{end}}{{end}} default: - _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) return false } return true } func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { + if !fastpathEnabled { + return false + } switch v := iv.(type) { {{range .Values}}{{if not .Primitive}}{{if not .MapKey }} case []{{ .Elem }}: @@ -131,12 +137,16 @@ func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e) {{end}}{{end}}{{end}} default: + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) return false } return true } func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool { + if !fastpathEnabled { + return false + } switch v := iv.(type) { {{range .Values}}{{if not .Primitive}}{{if .MapKey }} case map[{{ .MapKey }}]{{ .Elem }}: @@ -145,6 +155,7 @@ func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool { fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e) {{end}}{{end}}{{end}} default: + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) return false } return true @@ -157,16 +168,18 @@ func (f *encFnInfo) {{ .MethodNamePfx "fastpathEnc" false }}R(rv reflect.Value) fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv.Interface().([]{{ .Elem }}), fastpathCheckNilFalse, f.e) } func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v []{{ .Elem }}, checkNil bool, e *Encoder) { - ee := e.e + ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return } ee.EncodeArrayStart(len(v)) for _, v2 := range v { + if cr != nil { cr.sendContainerState(containerArrayElem) } {{ encmd .Elem "v2"}} } - ee.EncodeEnd() + if cr != nil { cr.sendContainerState(containerArrayEnd) }{{/* ee.EncodeEnd() */}} } {{end}}{{end}}{{end}} @@ -178,6 +191,7 @@ func (f *encFnInfo) {{ .MethodNamePfx "fastpathEnc" false }}R(rv reflect.Value) } func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, e *Encoder) { ee := e.e + cr := e.cr if checkNil && v == nil { ee.EncodeNil() return @@ -201,7 +215,9 @@ func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Ele } sort.Sort(bytesISlice(v2)) for j := range v2 { + if cr != nil { cr.sendContainerState(containerMapKey) } e.asis(v2[j].v) + if cr != nil { cr.sendContainerState(containerMapValue) } e.encode(v[v2[j].i]) } {{else}}{{ $x := sorttype .MapKey true}}v2 := make([]{{ $x }}, len(v)) var i int @@ -211,24 +227,28 @@ func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Ele } sort.Sort({{ sorttype .MapKey false}}(v2)) for _, k2 := range v2 { + if cr != nil { cr.sendContainerState(containerMapKey) } {{if eq .MapKey "string"}}if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) }{{else}}{{ $y := printf "%s(k2)" .MapKey }}{{ encmd .MapKey $y }}{{end}} + if cr != nil { cr.sendContainerState(containerMapValue) } {{ $y := printf "v[%s(k2)]" .MapKey }}{{ encmd .Elem $y }} } {{end}} } else { for k2, v2 := range v { + if cr != nil { cr.sendContainerState(containerMapKey) } {{if eq .MapKey "string"}}if asSymbols { ee.EncodeSymbol(k2) } else { ee.EncodeString(c_UTF8, k2) }{{else}}{{ encmd .MapKey "k2"}}{{end}} + if cr != nil { cr.sendContainerState(containerMapValue) } {{ encmd .Elem "v2"}} } } - ee.EncodeEnd() + if cr != nil { cr.sendContainerState(containerMapEnd) }{{/* ee.EncodeEnd() */}} } {{end}}{{end}}{{end}} @@ -237,6 +257,9 @@ func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Ele // -- -- fast path type switch func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool { + if !fastpathEnabled { + return false + } switch v := iv.(type) { {{range .Values}}{{if not .Primitive}}{{if not .MapKey }} case []{{ .Elem }}:{{else}} @@ -250,6 +273,7 @@ func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool { } {{end}}{{end}} default: + _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release) return false } return true @@ -283,8 +307,7 @@ func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *[]{{ .Elem }}, checkNil *vp = v } } -func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, checkNil bool, canChange bool, - d *Decoder) (_ []{{ .Elem }}, changed bool) { +func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, checkNil bool, canChange bool, d *Decoder) (_ []{{ .Elem }}, changed bool) { dd := d.d {{/* // if dd.isContainerType(valueTypeNil) { dd.TryDecodeAsNil() */}} if checkNil && dd.TryDecodeAsNil() { @@ -295,28 +318,22 @@ func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, checkNil b } slh, containerLenS := d.decSliceHelperStart() - x2read := containerLenS - var xtrunc bool - if canChange && v == nil { - var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }}); xtrunc { - x2read = xlen - } - v = make([]{{ .Elem }}, xlen) - changed = true - } if containerLenS == 0 { - if canChange && len(v) != 0 { - v = v[:0] - changed = true - }{{/* - // slh.End() // dd.ReadArrayEnd() - */}} - return v, changed + if canChange { + if v == nil { + v = []{{ .Elem }}{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return } - {{/* // for j := 0; j < containerLenS; j++ { */}} if containerLenS > 0 { + x2read := containerLenS + var xtrunc bool if containerLenS > cap(v) { if canChange { {{/* // fast-path is for "basic" immutable types, so no need to copy them over @@ -324,37 +341,64 @@ func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, checkNil b // copy(s, v[:cap(v)]) // v = s */}} var xlen int - if xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }}); xtrunc { - x2read = xlen + xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }}) + if xtrunc { + if xlen <= cap(v) { + v = v[:xlen] + } else { + v = make([]{{ .Elem }}, xlen) + } + } else { + v = make([]{{ .Elem }}, xlen) } - v = make([]{{ .Elem }}, xlen) changed = true } else { d.arrayCannotExpand(len(v), containerLenS) - x2read = len(v) } + x2read = len(v) } else if containerLenS != len(v) { - v = v[:containerLenS] - changed = true - } - {{/* // all checks done. cannot go past len. */}} + if canChange { + v = v[:containerLenS] + changed = true + } + } {{/* // all checks done. cannot go past len. */}} j := 0 - for ; j < x2read; j++ { + for ; j < x2read; j++ { + slh.ElemContainerState(j) {{ if eq .Elem "interface{}" }}d.decode(&v[j]){{ else }}v[j] = {{ decmd .Elem }}{{ end }} } if xtrunc { {{/* // means canChange=true, changed=true already. */}} for ; j < containerLenS; j++ { v = append(v, {{ zerocmd .Elem }}) + slh.ElemContainerState(j) {{ if eq .Elem "interface{}" }}d.decode(&v[j]){{ else }}v[j] = {{ decmd .Elem }}{{ end }} } } else if !canChange { - for ; j < containerLenS; j++ { + for ; j < containerLenS; j++ { + slh.ElemContainerState(j) d.swallow() } } } else { - j := 0 - for ; !dd.CheckBreak(); j++ { + breakFound := dd.CheckBreak() {{/* check break first, so we can initialize v with a capacity of 4 if necessary */}} + if breakFound { + if canChange { + if v == nil { + v = []{{ .Elem }}{} + } else if len(v) != 0 { + v = v[:0] + } + changed = true + } + slh.End() + return + } + if cap(v) == 0 { + v = make([]{{ .Elem }}, 1, 4) + changed = true + } + j := 0 + for ; !breakFound; j++ { if j >= len(v) { if canChange { v = append(v, {{ zerocmd .Elem }}) @@ -362,16 +406,22 @@ func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, checkNil b } else { d.arrayCannotExpand(len(v), j+1) } - } + } + slh.ElemContainerState(j) if j < len(v) { {{/* // all checks done. cannot go past len. */}} {{ if eq .Elem "interface{}" }}d.decode(&v[j]) {{ else }}v[j] = {{ decmd .Elem }}{{ end }} } else { d.swallow() } + breakFound = dd.CheckBreak() + } + if canChange && j < len(v) { + v = v[:j] + changed = true } - slh.End() } + slh.End() return v, changed } @@ -405,6 +455,7 @@ func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *map[{{ .MapKey }}]{{ .E func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, canChange bool, d *Decoder) (_ map[{{ .MapKey }}]{{ .Elem }}, changed bool) { dd := d.d + cr := d.cr {{/* // if dd.isContainerType(valueTypeNil) {dd.TryDecodeAsNil() */}} if checkNil && dd.TryDecodeAsNil() { if v != nil { @@ -424,11 +475,13 @@ func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v map[{{ .MapKey }}]{{ .Ele var mv {{ .Elem }} if containerLen > 0 { for j := 0; j < containerLen; j++ { + if cr != nil { cr.sendContainerState(containerMapKey) } {{ if eq .MapKey "interface{}" }}mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) {{/* // maps cannot have []byte as key. switch to string. */}} }{{ else }}mk = {{ decmd .MapKey }}{{ end }} + if cr != nil { cr.sendContainerState(containerMapValue) } {{ if eq .Elem "interface{}" }}if mapGet { mv = v[mk] } else { mv = nil } d.decode(&mv){{ else }}mv = {{ decmd .Elem }}{{ end }} if v != nil { @@ -437,19 +490,21 @@ func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v map[{{ .MapKey }}]{{ .Ele } } else if containerLen < 0 { for j := 0; !dd.CheckBreak(); j++ { + if cr != nil { cr.sendContainerState(containerMapKey) } {{ if eq .MapKey "interface{}" }}mk = nil d.decode(&mk) if bv, bok := mk.([]byte); bok { mk = d.string(bv) {{/* // maps cannot have []byte as key. switch to string. */}} }{{ else }}mk = {{ decmd .MapKey }}{{ end }} + if cr != nil { cr.sendContainerState(containerMapValue) } {{ if eq .Elem "interface{}" }}if mapGet { mv = v[mk] } else { mv = nil } d.decode(&mv){{ else }}mv = {{ decmd .Elem }}{{ end }} if v != nil { v[mk] = mv } } - dd.ReadEnd() } + if cr != nil { cr.sendContainerState(containerMapEnd) } return v, changed } diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.not.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.not.go new file mode 100644 index 00000000000..d6f5f0c911b --- /dev/null +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.not.go @@ -0,0 +1,32 @@ +// +build notfastpath + +package codec + +import "reflect" + +// The generated fast-path code is very large, and adds a few seconds to the build time. +// This causes test execution, execution of small tools which use codec, etc +// to take a long time. +// +// To mitigate, we now support the notfastpath tag. +// This tag disables fastpath during build, allowing for faster build, test execution, +// short-program runs, etc. + +func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool { return false } +func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool { return false } +func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { return false } +func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool { return false } + +type fastpathT struct{} +type fastpathE struct { + rtid uintptr + rt reflect.Type + encfn func(*encFnInfo, reflect.Value) + decfn func(*decFnInfo, reflect.Value) +} +type fastpathA [0]fastpathE + +func (x fastpathA) index(rtid uintptr) int { return -1 } + +var fastpathAV fastpathA +var fastpathTV fastpathT diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-array.go.tmpl b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-array.go.tmpl index eb31a9a963a..2caae5bfdaf 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-array.go.tmpl +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-array.go.tmpl @@ -1,86 +1,101 @@ -{{var "v"}} := {{ if not isArray}}*{{ end }}{{ .Varname }} +{{var "v"}} := {{if not isArray}}*{{end}}{{ .Varname }} {{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}} - -var {{var "rr"}}, {{var "rl"}} int {{/* // num2read, length of slice/array/chan */}} -var {{var "c"}}, {{var "rt"}} bool {{/* // changed, truncated */}} -_, _, _ = {{var "c"}}, {{var "rt"}}, {{var "rl"}} -{{var "rr"}} = {{var "l"}} -{{/* rl is NOT used. Only used for getting DecInferLen. len(r) used directly in code */}} - -{{ if not isArray }}if {{var "v"}} == nil { - if {{var "rl"}}, {{var "rt"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }}); {{var "rt"}} { - {{var "rr"}} = {{var "rl"}} - } - {{var "v"}} = make({{ .CTyp }}, {{var "rl"}}) - {{var "c"}} = true -} -{{ end }} -if {{var "l"}} == 0 { {{ if isSlice }} - if len({{var "v"}}) != 0 { - {{var "v"}} = {{var "v"}}[:0] - {{var "c"}} = true - } {{ end }} +var {{var "c"}} bool {{/* // changed */}} +if {{var "l"}} == 0 { + {{if isSlice }}if {{var "v"}} == nil { + {{var "v"}} = []{{ .Typ }}{} + {{var "c"}} = true + } else if len({{var "v"}}) != 0 { + {{var "v"}} = {{var "v"}}[:0] + {{var "c"}} = true + } {{end}} {{if isChan }}if {{var "v"}} == nil { + {{var "v"}} = make({{ .CTyp }}, 0) + {{var "c"}} = true + } {{end}} } else if {{var "l"}} > 0 { - {{ if isChan }} + {{if isChan }}if {{var "v"}} == nil { + {{var "rl"}}, _ = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }}) + {{var "v"}} = make({{ .CTyp }}, {{var "rl"}}) + {{var "c"}} = true + } for {{var "r"}} := 0; {{var "r"}} < {{var "l"}}; {{var "r"}}++ { + {{var "h"}}.ElemContainerState({{var "r"}}) var {{var "t"}} {{ .Typ }} {{ $x := printf "%st%s" .TempVar .Rand }}{{ decLineVar $x }} - {{var "v"}} <- {{var "t"}} - {{ else }} - if {{var "l"}} > cap({{var "v"}}) { - {{ if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "l"}}) - {{ else }}{{var "rl"}}, {{var "rt"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }}) - {{ if .Immutable }} - {{var "v2"}} := {{var "v"}} - {{var "v"}} = make([]{{ .Typ }}, {{var "rl"}}) - if len({{var "v"}}) > 0 { - copy({{var "v"}}, {{var "v2"}}[:cap({{var "v2"}})]) - } - {{ else }}{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}}) - {{ end }}{{var "c"}} = true - {{ end }} - {{var "rr"}} = len({{var "v"}}) - } else if {{var "l"}} != len({{var "v"}}) { - {{ if isSlice }}{{var "v"}} = {{var "v"}}[:{{var "l"}}] - {{var "c"}} = true {{ end }} + {{var "v"}} <- {{var "t"}} } + {{ else }} var {{var "rr"}}, {{var "rl"}} int {{/* // num2read, length of slice/array/chan */}} + var {{var "rt"}} bool {{/* truncated */}} + if {{var "l"}} > cap({{var "v"}}) { + {{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "l"}}) + {{ else }}{{if not .Immutable }} + {{var "rg"}} := len({{var "v"}}) > 0 + {{var "v2"}} := {{var "v"}} {{end}} + {{var "rl"}}, {{var "rt"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }}) + if {{var "rt"}} { + if {{var "rl"}} <= cap({{var "v"}}) { + {{var "v"}} = {{var "v"}}[:{{var "rl"}}] + } else { + {{var "v"}} = make([]{{ .Typ }}, {{var "rl"}}) + } + } else { + {{var "v"}} = make([]{{ .Typ }}, {{var "rl"}}) + } + {{var "c"}} = true + {{var "rr"}} = len({{var "v"}}) {{if not .Immutable }} + if {{var "rg"}} { copy({{var "v"}}, {{var "v2"}}) } {{end}} {{end}}{{/* end not Immutable, isArray */}} + } {{if isSlice }} else if {{var "l"}} != len({{var "v"}}) { + {{var "v"}} = {{var "v"}}[:{{var "l"}}] + {{var "c"}} = true + } {{end}} {{/* end isSlice:47 */}} {{var "j"}} := 0 for ; {{var "j"}} < {{var "rr"}} ; {{var "j"}}++ { + {{var "h"}}.ElemContainerState({{var "j"}}) {{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }} } - {{ if isArray }}for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ { + {{if isArray }}for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ { + {{var "h"}}.ElemContainerState({{var "j"}}) z.DecSwallow() } - {{ else }}if {{var "rt"}} { {{/* means that it is mutable and slice */}} + {{ else }}if {{var "rt"}} { for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ { {{var "v"}} = append({{var "v"}}, {{ zero}}) + {{var "h"}}.ElemContainerState({{var "j"}}) {{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }} } - } - {{ end }} - {{ end }}{{/* closing 'if not chan' */}} -} else { - for {{var "j"}} := 0; !r.CheckBreak(); {{var "j"}}++ { - if {{var "j"}} >= len({{var "v"}}) { - {{ if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "j"}}+1) - {{ else if isSlice}}{{var "v"}} = append({{var "v"}}, {{zero}})// var {{var "z"}} {{ .Typ }} - {{var "c"}} = true {{ end }} - } - {{ if isChan}} + } {{end}} {{/* end isArray:56 */}} + {{end}} {{/* end isChan:16 */}} +} else { {{/* len < 0 */}} + {{var "j"}} := 0 + for ; !r.CheckBreak(); {{var "j"}}++ { + {{if isChan }} + {{var "h"}}.ElemContainerState({{var "j"}}) var {{var "t"}} {{ .Typ }} {{ $x := printf "%st%s" .TempVar .Rand }}{{ decLineVar $x }} {{var "v"}} <- {{var "t"}} {{ else }} + if {{var "j"}} >= len({{var "v"}}) { + {{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "j"}}+1) + {{ else }}{{var "v"}} = append({{var "v"}}, {{zero}})// var {{var "z"}} {{ .Typ }} + {{var "c"}} = true {{end}} + } + {{var "h"}}.ElemContainerState({{var "j"}}) if {{var "j"}} < len({{var "v"}}) { {{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }} } else { z.DecSwallow() } - {{ end }} + {{end}} } - {{var "h"}}.End() + {{if isSlice }}if {{var "j"}} < len({{var "v"}}) { + {{var "v"}} = {{var "v"}}[:{{var "j"}}] + {{var "c"}} = true + } else if {{var "j"}} == 0 && {{var "v"}} == nil { + {{var "v"}} = []{{ .Typ }}{} + {{var "c"}} = true + }{{end}} } -{{ if not isArray }}if {{var "c"}} { +{{var "h"}}.End() +{{if not isArray }}if {{var "c"}} { *{{ .Varname }} = {{var "v"}} -}{{ end }} - +}{{end}} diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-map.go.tmpl b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-map.go.tmpl index 836eb3b5d7b..77400e0a112 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-map.go.tmpl +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-map.go.tmpl @@ -8,7 +8,7 @@ if {{var "v"}} == nil { } var {{var "mk"}} {{ .KTyp }} var {{var "mv"}} {{ .Typ }} -var {{var "mg"}} bool +var {{var "mg"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool if {{var "bh"}}.MapValueReset { {{if decElemKindPtr}}{{var "mg"}} = true {{else if decElemKindIntf}}if !{{var "bh"}}.InterfaceReset { {{var "mg"}} = true } @@ -16,31 +16,43 @@ if {{var "bh"}}.MapValueReset { {{end}} } if {{var "l"}} > 0 { for {{var "j"}} := 0; {{var "j"}} < {{var "l"}}; {{var "j"}}++ { + z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) {{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }} {{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} { {{var "mk"}} = string({{var "bv"}}) - }{{ end }} + }{{ end }}{{if decElemKindPtr}} + {{var "ms"}} = true{{end}} if {{var "mg"}} { - {{var "mv"}} = {{var "v"}}[{{var "mk"}}] + {{if decElemKindPtr}}{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{var "mk"}}] + if {{var "mok"}} { + {{var "ms"}} = false + } {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}} } {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}} + z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }}) {{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }} - if {{var "v"}} != nil { + if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil { {{var "v"}}[{{var "mk"}}] = {{var "mv"}} } } } else if {{var "l"}} < 0 { for {{var "j"}} := 0; !r.CheckBreak(); {{var "j"}}++ { + z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) {{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }} {{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} { {{var "mk"}} = string({{var "bv"}}) - }{{ end }} + }{{ end }}{{if decElemKindPtr}} + {{var "ms"}} = true {{ end }} if {{var "mg"}} { - {{var "mv"}} = {{var "v"}}[{{var "mk"}}] + {{if decElemKindPtr}}{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{var "mk"}}] + if {{var "mok"}} { + {{var "ms"}} = false + } {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}} } {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}} + z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }}) {{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }} - if {{var "v"}} != nil { + if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil { {{var "v"}}[{{var "mk"}}] = {{var "mv"}} } } -r.ReadEnd() } // else len==0: TODO: Should we clear map entries? +z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }}) diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.generated.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.generated.go index 9710eca501a..22bce776bb2 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.generated.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.generated.go @@ -115,6 +115,15 @@ func (f genHelperEncoder) EncExt(v interface{}) (r bool) { return false } +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) EncSendContainerState(c containerState) { + if f.e.cr != nil { + f.e.cr.sendContainerState(c) + } +} + +// ---------------- DECODER FOLLOWS ----------------- + // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* func (f genHelperDecoder) DecBasicHandle() *BasicHandle { return f.d.h @@ -167,11 +176,8 @@ func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) { // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) { // bs := f.dd.DecodeBytes(f.d.b[:], true, true) - f.d.r.track() - f.d.swallow() - bs := f.d.r.stopTrack() - // fmt.Printf(">>>>>> CODECGEN JSON: %s\n", bs) - fnerr := tm.UnmarshalJSON(bs) + // grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself. + fnerr := tm.UnmarshalJSON(f.d.nextValueBytes()) if fnerr != nil { panic(fnerr) } @@ -218,3 +224,10 @@ func (f genHelperDecoder) DecExt(v interface{}) (r bool) { func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int, truncated bool) { return decInferLen(clen, maxlen, unit) } + +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecSendContainerState(c containerState) { + if f.d.cr != nil { + f.d.cr.sendContainerState(c) + } +} diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.go.tmpl b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.go.tmpl index 8bc5061126f..31958574ffc 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.go.tmpl +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen-helper.go.tmpl @@ -106,6 +106,14 @@ func (f genHelperEncoder) EncExt(v interface{}) (r bool) { } return false } +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperEncoder) EncSendContainerState(c containerState) { + if f.e.cr != nil { + f.e.cr.sendContainerState(c) + } +} + +// ---------------- DECODER FOLLOWS ----------------- // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* func (f genHelperDecoder) DecBasicHandle() *BasicHandle { @@ -150,11 +158,8 @@ func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) { // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) { // bs := f.dd.DecodeBytes(f.d.b[:], true, true) - f.d.r.track() - f.d.swallow() - bs := f.d.r.stopTrack() - // fmt.Printf(">>>>>> CODECGEN JSON: %s\n", bs) - fnerr := tm.UnmarshalJSON(bs) + // grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself. + fnerr := tm.UnmarshalJSON(f.d.nextValueBytes()) if fnerr != nil { panic(fnerr) } @@ -195,6 +200,12 @@ func (f genHelperDecoder) DecExt(v interface{}) (r bool) { func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int, truncated bool) { return decInferLen(clen, maxlen, unit) } +// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE* +func (f genHelperDecoder) DecSendContainerState(c containerState) { + if f.d.cr != nil { + f.d.cr.sendContainerState(c) + } +} {{/* diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.generated.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.generated.go index dab6d94bd20..fb6f4b80974 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.generated.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.generated.go @@ -16,7 +16,7 @@ if {{var "v"}} == nil { } var {{var "mk"}} {{ .KTyp }} var {{var "mv"}} {{ .Typ }} -var {{var "mg"}} bool +var {{var "mg"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool if {{var "bh"}}.MapValueReset { {{if decElemKindPtr}}{{var "mg"}} = true {{else if decElemKindIntf}}if !{{var "bh"}}.InterfaceReset { {{var "mg"}} = true } @@ -24,122 +24,149 @@ if {{var "bh"}}.MapValueReset { {{end}} } if {{var "l"}} > 0 { for {{var "j"}} := 0; {{var "j"}} < {{var "l"}}; {{var "j"}}++ { + z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) {{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }} {{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} { {{var "mk"}} = string({{var "bv"}}) - }{{ end }} + }{{ end }}{{if decElemKindPtr}} + {{var "ms"}} = true{{end}} if {{var "mg"}} { - {{var "mv"}} = {{var "v"}}[{{var "mk"}}] + {{if decElemKindPtr}}{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{var "mk"}}] + if {{var "mok"}} { + {{var "ms"}} = false + } {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}} } {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}} + z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }}) {{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }} - if {{var "v"}} != nil { + if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil { {{var "v"}}[{{var "mk"}}] = {{var "mv"}} } } } else if {{var "l"}} < 0 { for {{var "j"}} := 0; !r.CheckBreak(); {{var "j"}}++ { + z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) {{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }} {{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} { {{var "mk"}} = string({{var "bv"}}) - }{{ end }} + }{{ end }}{{if decElemKindPtr}} + {{var "ms"}} = true {{ end }} if {{var "mg"}} { - {{var "mv"}} = {{var "v"}}[{{var "mk"}}] + {{if decElemKindPtr}}{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{var "mk"}}] + if {{var "mok"}} { + {{var "ms"}} = false + } {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}} } {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}} + z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }}) {{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }} - if {{var "v"}} != nil { + if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil { {{var "v"}}[{{var "mk"}}] = {{var "mv"}} } } -r.ReadEnd() } // else len==0: TODO: Should we clear map entries? +z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }}) ` const genDecListTmpl = ` -{{var "v"}} := {{ if not isArray}}*{{ end }}{{ .Varname }} +{{var "v"}} := {{if not isArray}}*{{end}}{{ .Varname }} {{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}} - -var {{var "rr"}}, {{var "rl"}} int {{/* // num2read, length of slice/array/chan */}} -var {{var "c"}}, {{var "rt"}} bool {{/* // changed, truncated */}} -_, _, _ = {{var "c"}}, {{var "rt"}}, {{var "rl"}} -{{var "rr"}} = {{var "l"}} -{{/* rl is NOT used. Only used for getting DecInferLen. len(r) used directly in code */}} - -{{ if not isArray }}if {{var "v"}} == nil { - if {{var "rl"}}, {{var "rt"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }}); {{var "rt"}} { - {{var "rr"}} = {{var "rl"}} - } - {{var "v"}} = make({{ .CTyp }}, {{var "rl"}}) - {{var "c"}} = true -} -{{ end }} -if {{var "l"}} == 0 { {{ if isSlice }} - if len({{var "v"}}) != 0 { - {{var "v"}} = {{var "v"}}[:0] - {{var "c"}} = true - } {{ end }} +var {{var "c"}} bool {{/* // changed */}} +if {{var "l"}} == 0 { + {{if isSlice }}if {{var "v"}} == nil { + {{var "v"}} = []{{ .Typ }}{} + {{var "c"}} = true + } else if len({{var "v"}}) != 0 { + {{var "v"}} = {{var "v"}}[:0] + {{var "c"}} = true + } {{end}} {{if isChan }}if {{var "v"}} == nil { + {{var "v"}} = make({{ .CTyp }}, 0) + {{var "c"}} = true + } {{end}} } else if {{var "l"}} > 0 { - {{ if isChan }} + {{if isChan }}if {{var "v"}} == nil { + {{var "rl"}}, _ = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }}) + {{var "v"}} = make({{ .CTyp }}, {{var "rl"}}) + {{var "c"}} = true + } for {{var "r"}} := 0; {{var "r"}} < {{var "l"}}; {{var "r"}}++ { + {{var "h"}}.ElemContainerState({{var "r"}}) var {{var "t"}} {{ .Typ }} {{ $x := printf "%st%s" .TempVar .Rand }}{{ decLineVar $x }} - {{var "v"}} <- {{var "t"}} - {{ else }} - if {{var "l"}} > cap({{var "v"}}) { - {{ if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "l"}}) - {{ else }}{{var "rl"}}, {{var "rt"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }}) - {{ if .Immutable }} - {{var "v2"}} := {{var "v"}} - {{var "v"}} = make([]{{ .Typ }}, {{var "rl"}}) - if len({{var "v"}}) > 0 { - copy({{var "v"}}, {{var "v2"}}[:cap({{var "v2"}})]) - } - {{ else }}{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}}) - {{ end }}{{var "c"}} = true - {{ end }} - {{var "rr"}} = len({{var "v"}}) - } else if {{var "l"}} != len({{var "v"}}) { - {{ if isSlice }}{{var "v"}} = {{var "v"}}[:{{var "l"}}] - {{var "c"}} = true {{ end }} + {{var "v"}} <- {{var "t"}} } + {{ else }} var {{var "rr"}}, {{var "rl"}} int {{/* // num2read, length of slice/array/chan */}} + var {{var "rt"}} bool {{/* truncated */}} + if {{var "l"}} > cap({{var "v"}}) { + {{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "l"}}) + {{ else }}{{if not .Immutable }} + {{var "rg"}} := len({{var "v"}}) > 0 + {{var "v2"}} := {{var "v"}} {{end}} + {{var "rl"}}, {{var "rt"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }}) + if {{var "rt"}} { + if {{var "rl"}} <= cap({{var "v"}}) { + {{var "v"}} = {{var "v"}}[:{{var "rl"}}] + } else { + {{var "v"}} = make([]{{ .Typ }}, {{var "rl"}}) + } + } else { + {{var "v"}} = make([]{{ .Typ }}, {{var "rl"}}) + } + {{var "c"}} = true + {{var "rr"}} = len({{var "v"}}) {{if not .Immutable }} + if {{var "rg"}} { copy({{var "v"}}, {{var "v2"}}) } {{end}} {{end}}{{/* end not Immutable, isArray */}} + } {{if isSlice }} else if {{var "l"}} != len({{var "v"}}) { + {{var "v"}} = {{var "v"}}[:{{var "l"}}] + {{var "c"}} = true + } {{end}} {{/* end isSlice:47 */}} {{var "j"}} := 0 for ; {{var "j"}} < {{var "rr"}} ; {{var "j"}}++ { + {{var "h"}}.ElemContainerState({{var "j"}}) {{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }} } - {{ if isArray }}for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ { + {{if isArray }}for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ { + {{var "h"}}.ElemContainerState({{var "j"}}) z.DecSwallow() } - {{ else }}if {{var "rt"}} { {{/* means that it is mutable and slice */}} + {{ else }}if {{var "rt"}} { for ; {{var "j"}} < {{var "l"}} ; {{var "j"}}++ { {{var "v"}} = append({{var "v"}}, {{ zero}}) + {{var "h"}}.ElemContainerState({{var "j"}}) {{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }} } - } - {{ end }} - {{ end }}{{/* closing 'if not chan' */}} -} else { - for {{var "j"}} := 0; !r.CheckBreak(); {{var "j"}}++ { - if {{var "j"}} >= len({{var "v"}}) { - {{ if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "j"}}+1) - {{ else if isSlice}}{{var "v"}} = append({{var "v"}}, {{zero}})// var {{var "z"}} {{ .Typ }} - {{var "c"}} = true {{ end }} - } - {{ if isChan}} + } {{end}} {{/* end isArray:56 */}} + {{end}} {{/* end isChan:16 */}} +} else { {{/* len < 0 */}} + {{var "j"}} := 0 + for ; !r.CheckBreak(); {{var "j"}}++ { + {{if isChan }} + {{var "h"}}.ElemContainerState({{var "j"}}) var {{var "t"}} {{ .Typ }} {{ $x := printf "%st%s" .TempVar .Rand }}{{ decLineVar $x }} {{var "v"}} <- {{var "t"}} {{ else }} + if {{var "j"}} >= len({{var "v"}}) { + {{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "j"}}+1) + {{ else }}{{var "v"}} = append({{var "v"}}, {{zero}})// var {{var "z"}} {{ .Typ }} + {{var "c"}} = true {{end}} + } + {{var "h"}}.ElemContainerState({{var "j"}}) if {{var "j"}} < len({{var "v"}}) { {{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }} } else { z.DecSwallow() } - {{ end }} + {{end}} } - {{var "h"}}.End() + {{if isSlice }}if {{var "j"}} < len({{var "v"}}) { + {{var "v"}} = {{var "v"}}[:{{var "j"}}] + {{var "c"}} = true + } else if {{var "j"}} == 0 && {{var "v"}} == nil { + {{var "v"}} = []{{ .Typ }}{} + {{var "c"}} = true + }{{end}} } -{{ if not isArray }}if {{var "c"}} { +{{var "h"}}.End() +{{if not isArray }}if {{var "c"}} { *{{ .Varname }} = {{var "v"}} -}{{ end }} - +}{{end}} ` diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.go index b158564ba16..a075e7c0d62 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/gen.go @@ -91,7 +91,8 @@ import ( // v3: Changes for Kubernetes: // changes in signature of some unpublished helper methods and codecgen cmdline arguments. // v4: Removed separator support from (en|de)cDriver, and refactored codec(gen) -const GenVersion = 4 +// v5: changes to support faster json decoding. Let encoder/decoder maintain state of collections. +const GenVersion = 5 const ( genCodecPkg = "codec1978" @@ -110,6 +111,14 @@ const ( genUseOneFunctionForDecStructMap = true ) +type genStructMapStyle uint8 + +const ( + genStructMapStyleConsolidated genStructMapStyle = iota + genStructMapStyleLenPrefix + genStructMapStyleCheckBreak +) + var ( genAllTypesSamePkgErr = errors.New("All types must be in the same package") genExpectArrayOrMapErr = errors.New("unexpected type. Expecting array/map/slice") @@ -230,10 +239,18 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn x.line("") x.line("const (") + x.linef("// ----- content types ----") x.linef("codecSelferC_UTF8%s = %v", x.xs, int64(c_UTF8)) x.linef("codecSelferC_RAW%s = %v", x.xs, int64(c_RAW)) + x.linef("// ----- value types used ----") x.linef("codecSelferValueTypeArray%s = %v", x.xs, int64(valueTypeArray)) x.linef("codecSelferValueTypeMap%s = %v", x.xs, int64(valueTypeMap)) + x.linef("// ----- containerStateValues ----") + x.linef("codecSelfer_containerMapKey%s = %v", x.xs, int64(containerMapKey)) + x.linef("codecSelfer_containerMapValue%s = %v", x.xs, int64(containerMapValue)) + x.linef("codecSelfer_containerMapEnd%s = %v", x.xs, int64(containerMapEnd)) + x.linef("codecSelfer_containerArrayElem%s = %v", x.xs, int64(containerArrayElem)) + x.linef("codecSelfer_containerArrayEnd%s = %v", x.xs, int64(containerArrayEnd)) x.line(")") x.line("var (") x.line("codecSelferBitsize" + x.xs + " = uint8(reflect.TypeOf(uint(0)).Bits())") @@ -255,8 +272,6 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn x.line(`err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v", `) x.linef(`%v, %sGenVersion, file)`, GenVersion, x.cpfx) x.line("panic(err)") - // x.linef(`panic(fmt.Errorf("Re-run codecgen due to version mismatch: `+ - // `current: %%v, need %%v, file: %%v", %v, %sGenVersion, file))`, GenVersion, x.cpfx) x.linef("}") x.line("if false { // reference the types, but skip this branch at build/run time") var n int @@ -515,21 +530,21 @@ func (x *genRunner) selfer(encode bool) { x.out(fnSigPfx) x.line(") codecDecodeSelfFromMap(l int, d *" + x.cpfx + "Decoder) {") x.genRequiredMethodVars(false) - x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, 0) + x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, genStructMapStyleConsolidated) x.line("}") x.line("") } else { x.out(fnSigPfx) x.line(") codecDecodeSelfFromMapLenPrefix(l int, d *" + x.cpfx + "Decoder) {") x.genRequiredMethodVars(false) - x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, 1) + x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, genStructMapStyleLenPrefix) x.line("}") x.line("") x.out(fnSigPfx) x.line(") codecDecodeSelfFromMapCheckBreak(l int, d *" + x.cpfx + "Decoder) {") x.genRequiredMethodVars(false) - x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, 2) + x.decStructMap(genTopLevelVarName, "l", reflect.ValueOf(t0).Pointer(), t0, genStructMapStyleCheckBreak) x.line("}") x.line("") } @@ -548,10 +563,8 @@ func (x *genRunner) selfer(encode bool) { func (x *genRunner) xtraSM(varname string, encode bool, t reflect.Type) { if encode { x.linef("h.enc%s((%s%s)(%s), e)", x.genMethodNameT(t), x.arr2str(t, "*"), x.genTypeName(t), varname) - // x.line("h.enc" + x.genMethodNameT(t) + "(" + x.genTypeName(t) + "(" + varname + "), e)") } else { x.linef("h.dec%s((*%s)(%s), d)", x.genMethodNameT(t), x.genTypeName(t), varname) - // x.line("h.dec" + x.genMethodNameT(t) + "((*" + x.genTypeName(t) + ")(" + varname + "), d)") } if _, ok := x.tm[t]; !ok { x.tm[t] = struct{}{} @@ -815,12 +828,14 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) { } x.linef("%s[%v] = %s", numfieldsvar, j, omitline) } + x.linef("var %snn%s int", genTempVarPfx, i) x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray { x.line("r.EncodeArrayStart(" + strconv.FormatInt(int64(len(tisfi)), 10) + ")") x.linef("} else {") // if not ti.toArray - x.linef("var %snn%s int = %v", genTempVarPfx, i, nn) + x.linef("%snn%s = %v", genTempVarPfx, i, nn) x.linef("for _, b := range %s { if b { %snn%s++ } }", numfieldsvar, genTempVarPfx, i) x.linef("r.EncodeMapStart(%snn%s)", genTempVarPfx, i) + x.linef("%snn%s = %v", genTempVarPfx, i, 0) // x.line("r.EncodeMapStart(" + strconv.FormatInt(int64(len(tisfi)), 10) + ")") x.line("}") // close if not StructToArray @@ -864,11 +879,9 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) { if labelUsed { x.line("if " + isNilVarName + " { r.EncodeNil() } else { ") } + x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs) if si.omitEmpty { x.linef("if %s[%v] {", numfieldsvar, j) - // omitEmptyVarNameX := genTempVarPfx + "ov" + i - // x.line("var " + omitEmptyVarNameX + " " + x.genTypeName(t2.Type)) - // x.encVar(omitEmptyVarNameX, t2.Type) } x.encVar(varname+"."+t2.Name, t2.Type) if si.omitEmpty { @@ -879,21 +892,15 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) { if labelUsed { x.line("}") } + x.linef("} else {") // if not ti.toArray - // omitEmptyVar := genTempVarPfx + "x" + i + t2.Name - // x.line("const " + omitEmptyVar + " bool = " + strconv.FormatBool(si.omitEmpty)) - // doOmitEmpty := si.omitEmpty && t2.Type.Kind() != reflect.Struct + if si.omitEmpty { x.linef("if %s[%v] {", numfieldsvar, j) - // x.linef(`println("Encoding field: %v")`, j) - // x.out("if ") - // if labelUsed { - // x.out("!" + isNilVarName + " && ") - // } - // x.line(varname + "." + t2.Name + " != " + genZeroValueR(t2.Type, x.tc) + " {") } - // x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + ", string(\"" + t2.Name + "\"))") + x.linef("z.EncSendContainerState(codecSelfer_containerMapKey%s)", x.xs) x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + ", string(\"" + si.encName + "\"))") + x.linef("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs) if labelUsed { x.line("if " + isNilVarName + " { r.EncodeNil() } else { ") x.encVar(varname+"."+t2.Name, t2.Type) @@ -906,9 +913,12 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) { } x.linef("} ") // end if/else ti.toArray } - x.line("if " + sepVarname + " {") - x.line("r.EncodeEnd()") + x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray { + x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs) + x.line("} else {") + x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs) x.line("}") + } func (x *genRunner) encListFallback(varname string, t reflect.Type) { @@ -917,14 +927,16 @@ func (x *genRunner) encListFallback(varname string, t reflect.Type) { x.line("r.EncodeArrayStart(len(" + varname + "))") if t.Kind() == reflect.Chan { x.linef("for %si%s, %si2%s := 0, len(%s); %si%s < %si2%s; %si%s++ {", g, i, g, i, varname, g, i, g, i, g, i) + x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs) x.linef("%sv%s := <-%s", g, i, varname) } else { // x.linef("for %si%s, %sv%s := range %s {", genTempVarPfx, i, genTempVarPfx, i, varname) x.linef("for _, %sv%s := range %s {", genTempVarPfx, i, varname) + x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs) } x.encVar(genTempVarPfx+"v"+i, t.Elem()) x.line("}") - x.line("r.EncodeEnd()") + x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs) } func (x *genRunner) encMapFallback(varname string, t reflect.Type) { @@ -933,10 +945,12 @@ func (x *genRunner) encMapFallback(varname string, t reflect.Type) { x.line("r.EncodeMapStart(len(" + varname + "))") x.linef("for %sk%s, %sv%s := range %s {", genTempVarPfx, i, genTempVarPfx, i, varname) // x.line("for " + genTempVarPfx + "k" + i + ", " + genTempVarPfx + "v" + i + " := range " + varname + " {") + x.linef("z.EncSendContainerState(codecSelfer_containerMapKey%s)", x.xs) x.encVar(genTempVarPfx+"k"+i, t.Key()) + x.linef("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs) x.encVar(genTempVarPfx+"v"+i, t.Elem()) x.line("}") - x.line("r.EncodeEnd()") + x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs) } func (x *genRunner) decVar(varname string, t reflect.Type, canBeNil bool) { @@ -954,8 +968,6 @@ func (x *genRunner) decVar(varname string, t reflect.Type, canBeNil bool) { x.line("if r.TryDecodeAsNil() {") if t.Kind() == reflect.Ptr { x.line("if " + varname + " != nil { ") - // x.line("var " + genTempVarPfx + i + " " + x.genTypeName(t.Elem())) - // x.line("*" + varname + " = " + genTempVarPfx + i) // if varname is a field of a struct (has a dot in it), // then just set it to nil @@ -964,12 +976,8 @@ func (x *genRunner) decVar(varname string, t reflect.Type, canBeNil bool) { } else { x.line("*" + varname + " = " + x.genZeroValueR(t.Elem())) } - // x.line("*" + varname + " = nil") x.line("}") - } else { - // x.line("var " + genTempVarPfx + i + " " + x.genTypeName(t)) - // x.line(varname + " = " + genTempVarPfx + i) x.line(varname + " = " + x.genZeroValueR(t)) } x.line("} else {") @@ -1149,8 +1157,6 @@ func (x *genRunner) dec(varname string, t reflect.Type) { } else if fastpathAV.index(rtid) != -1 { g := x.newGenV(t) x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", false, d)") - // x.line("z." + g.MethodNamePfx("Dec", false) + "(" + varname + ")") - // x.line(g.FastpathName(false) + "(" + varname + ", d)") } else { x.xtraSM(varname, false, t) // x.decListFallback(varname, rtid, false, t) @@ -1163,8 +1169,6 @@ func (x *genRunner) dec(varname string, t reflect.Type) { if fastpathAV.index(rtid) != -1 { g := x.newGenV(t) x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", false, d)") - // x.line("z." + g.MethodNamePfx("Dec", false) + "(" + varname + ")") - // x.line(g.FastpathName(false) + "(" + varname + ", d)") } else { x.xtraSM(varname, false, t) // x.decMapFallback(varname, rtid, t) @@ -1294,6 +1298,7 @@ func (x *genRunner) decListFallback(varname string, rtid uintptr, t reflect.Type func (x *genRunner) decMapFallback(varname string, rtid uintptr, t reflect.Type) { type tstruc struct { TempVar string + Sfx string Rand string Varname string KTyp string @@ -1303,7 +1308,7 @@ func (x *genRunner) decMapFallback(varname string, rtid uintptr, t reflect.Type) telem := t.Elem() tkey := t.Key() ts := tstruc{ - genTempVarPfx, x.varsfx(), varname, x.genTypeName(tkey), + genTempVarPfx, x.xs, x.varsfx(), varname, x.genTypeName(tkey), x.genTypeName(telem), int(telem.Size() + tkey.Size()), } @@ -1359,6 +1364,7 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt if si.i != -1 { t2 = t.Field(int(si.i)) } else { + //we must accomodate anonymous fields, where the embedded field is a nil pointer in the value. // t2 = t.FieldByIndex(si.is) t2typ := t varname3 := varname @@ -1370,8 +1376,7 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt t2typ = t2.Type varname3 = varname3 + "." + t2.Name if t2typ.Kind() == reflect.Ptr { - x.line("if " + varname3 + " == nil {" + - varname3 + " = new(" + x.genTypeName(t2typ.Elem()) + ") }") + x.linef("if %s == nil { %s = new(%s) }", varname3, varname3, x.genTypeName(t2typ.Elem())) } } } @@ -1380,11 +1385,10 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt x.line("default:") // pass the slice here, so that the string will not escape, and maybe save allocation x.line("z.DecStructFieldNotFound(-1, " + kName + ")") - // x.line("z.DecStructFieldNotFoundB(" + kName + "Slc)") x.line("} // end switch " + kName) } -func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t reflect.Type, style uint8) { +func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t reflect.Type, style genStructMapStyle) { tpfx := genTempVarPfx i := x.varsfx() kName := tpfx + "s" + i @@ -1406,14 +1410,11 @@ func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t ref x.line("var " + kName + "Slc = z.DecScratchBuffer() // default slice to decode into") - // x.line("var " + kName + " string // default string to decode into") - // x.line("_ = " + kName) x.line("_ = " + kName + "Slc") - // x.linef("var %sb%s bool", tpfx, i) // break switch style { - case 1: + case genStructMapStyleLenPrefix: x.linef("for %sj%s := 0; %sj%s < %s; %sj%s++ {", tpfx, i, tpfx, i, lenvarname, tpfx, i) - case 2: + case genStructMapStyleCheckBreak: x.linef("for %sj%s := 0; !r.CheckBreak(); %sj%s++ {", tpfx, i, tpfx, i) default: // 0, otherwise. x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length @@ -1421,11 +1422,9 @@ func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t ref x.linef("if %shl%s { if %sj%s >= %s { break }", tpfx, i, tpfx, i, lenvarname) x.line("} else { if r.CheckBreak() { break }; }") } - // x.line(kName + " = z.ReadStringAsBytes(" + kName + ")") - // x.line(kName + " = z.ReadString()") + x.linef("z.DecSendContainerState(codecSelfer_containerMapKey%s)", x.xs) x.line(kName + "Slc = r.DecodeBytes(" + kName + "Slc, true, true)") // let string be scoped to this loop alone, so it doesn't escape. - // x.line(kName + " := " + x.cpfx + "GenBytesToStringRO(" + kName + "Slc)") if x.unsafe { x.line(kName + "SlcHdr := codecSelferUnsafeString" + x.xs + "{uintptr(unsafe.Pointer(&" + kName + "Slc[0])), len(" + kName + "Slc)}") @@ -1433,16 +1432,11 @@ func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t ref } else { x.line(kName + " := string(" + kName + "Slc)") } + x.linef("z.DecSendContainerState(codecSelfer_containerMapValue%s)", x.xs) x.decStructMapSwitch(kName, varname, rtid, t) x.line("} // end for " + tpfx + "j" + i) - switch style { - case 1: - case 2: - x.line("r.ReadEnd()") - default: - x.linef("if !%shl%s { r.ReadEnd() }", tpfx, i) - } + x.linef("z.DecSendContainerState(codecSelfer_containerMapEnd%s)", x.xs) } func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid uintptr, t reflect.Type) { @@ -1451,25 +1445,37 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid ti := x.ti.get(rtid, t) tisfi := ti.sfip // always use sequence from file. decStruct expects same thing. x.linef("var %sj%s int", tpfx, i) - x.linef("var %sb%s bool", tpfx, i) // break - // x.linef("var %sl%s := r.ReadArrayStart()", tpfx, i) + x.linef("var %sb%s bool", tpfx, i) // break x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length for _, si := range tisfi { var t2 reflect.StructField if si.i != -1 { t2 = t.Field(int(si.i)) } else { - t2 = t.FieldByIndex(si.is) + //we must accomodate anonymous fields, where the embedded field is a nil pointer in the value. + // t2 = t.FieldByIndex(si.is) + t2typ := t + varname3 := varname + for _, ix := range si.is { + for t2typ.Kind() == reflect.Ptr { + t2typ = t2typ.Elem() + } + t2 = t2typ.Field(ix) + t2typ = t2.Type + varname3 = varname3 + "." + t2.Name + if t2typ.Kind() == reflect.Ptr { + x.linef("if %s == nil { %s = new(%s) }", varname3, varname3, x.genTypeName(t2typ.Elem())) + } + } } x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = r.CheckBreak() }", tpfx, i, tpfx, i, tpfx, i, tpfx, i, lenvarname, tpfx, i) - // x.line("if " + tpfx + "j" + i + "++; " + tpfx + "j" + - // i + " <= " + tpfx + "l" + i + " {") - x.linef("if %sb%s { r.ReadEnd(); %s }", tpfx, i, breakString) + x.linef("if %sb%s { z.DecSendContainerState(codecSelfer_containerArrayEnd%s); %s }", + tpfx, i, x.xs, breakString) + x.linef("z.DecSendContainerState(codecSelfer_containerArrayElem%s)", x.xs) x.decVar(varname+"."+t2.Name, t2.Type, true) - // x.line("} // end if " + tpfx + "j" + i + " <= " + tpfx + "l" + i) } // read remaining values and throw away. x.line("for {") @@ -1477,19 +1483,20 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid tpfx, i, tpfx, i, tpfx, i, tpfx, i, lenvarname, tpfx, i) x.linef("if %sb%s { break }", tpfx, i) + x.linef("z.DecSendContainerState(codecSelfer_containerArrayElem%s)", x.xs) x.linef(`z.DecStructFieldNotFound(%sj%s - 1, "")`, tpfx, i) x.line("}") - x.line("r.ReadEnd()") + x.linef("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs) } func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) { // if container is map - // x.line("if z.DecContainerIsMap() { ") i := x.varsfx() - x.line("if r.IsContainerType(codecSelferValueTypeMap" + x.xs + ") {") + x.linef("%sct%s := r.ContainerType()", genTempVarPfx, i) + x.linef("if %sct%s == codecSelferValueTypeMap%s {", genTempVarPfx, i, x.xs) x.line(genTempVarPfx + "l" + i + " := r.ReadMapStart()") x.linef("if %sl%s == 0 {", genTempVarPfx, i) - x.line("r.ReadEnd()") + x.linef("z.DecSendContainerState(codecSelfer_containerMapEnd%s)", x.xs) if genUseOneFunctionForDecStructMap { x.line("} else { ") x.linef("x.codecDecodeSelfFromMap(%sl%s, d)", genTempVarPfx, i) @@ -1502,18 +1509,16 @@ func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) { x.line("}") // else if container is array - // x.line("} else if z.DecContainerIsArray() { ") - x.line("} else if r.IsContainerType(codecSelferValueTypeArray" + x.xs + ") {") + x.linef("} else if %sct%s == codecSelferValueTypeArray%s {", genTempVarPfx, i, x.xs) x.line(genTempVarPfx + "l" + i + " := r.ReadArrayStart()") x.linef("if %sl%s == 0 {", genTempVarPfx, i) - x.line("r.ReadEnd()") + x.linef("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs) x.line("} else { ") x.linef("x.codecDecodeSelfFromArray(%sl%s, d)", genTempVarPfx, i) x.line("}") // else panic x.line("} else { ") x.line("panic(codecSelferOnlyMapOrArrayEncodeToStructErr" + x.xs + ")") - // x.line("panic(`only encoded map or array can be decoded into a struct`)") x.line("} ") } @@ -1849,10 +1854,6 @@ func genInternalInit() { "float64": 8, "bool": 1, } - // mapvaltypes2 := make(map[string]bool) - // for _, s := range mapvaltypes { - // mapvaltypes2[s] = true - // } var gt genInternal // For each slice or map type, there must be a (symetrical) Encode and Decode fast-path function diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/helper.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/helper.go index 96b5a1f2277..560014ae393 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/helper.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/helper.go @@ -112,8 +112,6 @@ import ( "strings" "sync" "time" - "unicode" - "unicode/utf8" ) const ( @@ -194,14 +192,6 @@ const ( type seqType uint8 -// mirror json.Marshaler and json.Unmarshaler here, so we don't import the encoding/json package -type jsonMarshaler interface { - MarshalJSON() ([]byte, error) -} -type jsonUnmarshaler interface { - UnmarshalJSON([]byte) error -} - const ( _ seqType = iota seqTypeArray @@ -209,13 +199,43 @@ const ( seqTypeChan ) +// note that containerMapStart and containerArraySend are not sent. +// This is because the ReadXXXStart and EncodeXXXStart already does these. +type containerState uint8 + +const ( + _ containerState = iota + + containerMapStart // slot left open, since Driver method already covers it + containerMapKey + containerMapValue + containerMapEnd + containerArrayStart // slot left open, since Driver methods already cover it + containerArrayElem + containerArrayEnd +) + +type containerStateRecv interface { + sendContainerState(containerState) +} + +// mirror json.Marshaler and json.Unmarshaler here, +// so we don't import the encoding/json package +type jsonMarshaler interface { + MarshalJSON() ([]byte, error) +} +type jsonUnmarshaler interface { + UnmarshalJSON([]byte) error +} + var ( bigen = binary.BigEndian structInfoFieldName = "_struct" - // mapStrIntfTyp = reflect.TypeOf(map[string]interface{}(nil)) - intfSliceTyp = reflect.TypeOf([]interface{}(nil)) - intfTyp = intfSliceTyp.Elem() + mapStrIntfTyp = reflect.TypeOf(map[string]interface{}(nil)) + mapIntfIntfTyp = reflect.TypeOf(map[interface{}]interface{}(nil)) + intfSliceTyp = reflect.TypeOf([]interface{}(nil)) + intfTyp = intfSliceTyp.Elem() stringTyp = reflect.TypeOf("") timeTyp = reflect.TypeOf(time.Time{}) @@ -241,6 +261,9 @@ var ( timeTypId = reflect.ValueOf(timeTyp).Pointer() stringTypId = reflect.ValueOf(stringTyp).Pointer() + mapStrIntfTypId = reflect.ValueOf(mapStrIntfTyp).Pointer() + mapIntfIntfTypId = reflect.ValueOf(mapIntfIntfTyp).Pointer() + intfSliceTypId = reflect.ValueOf(intfSliceTyp).Pointer() // mapBySliceTypId = reflect.ValueOf(mapBySliceTyp).Pointer() intBitsize uint8 = uint8(reflect.TypeOf(int(0)).Bits()) @@ -283,7 +306,7 @@ type MapBySlice interface { type BasicHandle struct { // TypeInfos is used to get the type info for any type. // - // If not configure, the default TypeInfos is used, which uses struct tag keys: codec, json + // If not configured, the default TypeInfos is used, which uses struct tag keys: codec, json TypeInfos *TypeInfos extHandle @@ -332,6 +355,8 @@ type RawExt struct { // It is used by codecs (e.g. binc, msgpack, simple) which do custom serialization of the types. type BytesExt interface { // WriteExt converts a value to a []byte. + // + // Note: v *may* be a pointer to the extension type, if the extension type was a struct or array. WriteExt(v interface{}) []byte // ReadExt updates a value from a []byte. @@ -344,6 +369,8 @@ type BytesExt interface { // It is used by codecs (e.g. cbor, json) which use the format to do custom serialization of the types. type InterfaceExt interface { // ConvertExt converts a value into a simpler interface for easy encoding e.g. convert time.Time to int64. + // + // Note: v *may* be a pointer to the extension type, if the extension type was a struct or array. ConvertExt(v interface{}) interface{} // UpdateExt updates a value from a simpler interface for easy decoding e.g. convert int64 to time.Time. @@ -363,7 +390,6 @@ type addExtWrapper struct { } func (x addExtWrapper) WriteExt(v interface{}) []byte { - // fmt.Printf(">>>>>>>>>> WriteExt: %T, %v\n", v, v) bs, err := x.encFn(reflect.ValueOf(v)) if err != nil { panic(err) @@ -372,7 +398,6 @@ func (x addExtWrapper) WriteExt(v interface{}) []byte { } func (x addExtWrapper) ReadExt(v interface{}, bs []byte) { - // fmt.Printf(">>>>>>>>>> ReadExt: %T, %v\n", v, v) if err := x.decFn(reflect.ValueOf(v), bs); err != nil { panic(err) } @@ -474,7 +499,7 @@ type extTypeTagFn struct { ext Ext } -type extHandle []*extTypeTagFn +type extHandle []extTypeTagFn // DEPRECATED: Use SetBytesExt or SetInterfaceExt on the Handle instead. // @@ -513,12 +538,17 @@ func (o *extHandle) SetExt(rt reflect.Type, tag uint64, ext Ext) (err error) { } } - *o = append(*o, &extTypeTagFn{rtid, rt, tag, ext}) + if *o == nil { + *o = make([]extTypeTagFn, 0, 4) + } + *o = append(*o, extTypeTagFn{rtid, rt, tag, ext}) return } func (o extHandle) getExt(rtid uintptr) *extTypeTagFn { - for _, v := range o { + var v *extTypeTagFn + for i := range o { + v = &o[i] if v.rtid == rtid { return v } @@ -527,7 +557,9 @@ func (o extHandle) getExt(rtid uintptr) *extTypeTagFn { } func (o extHandle) getExtForTag(tag uint64) *extTypeTagFn { - for _, v := range o { + var v *extTypeTagFn + for i := range o { + v = &o[i] if v.tag == tag { return v } @@ -650,6 +682,8 @@ type typeInfo struct { rt reflect.Type rtid uintptr + numMeth uint16 // number of methods + // baseId gives pointer to the base reflect.Type, after deferencing // the pointers. E.g. base type of ***time.Time is time.Time. base reflect.Type @@ -746,14 +780,10 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) { return } - x.mu.Lock() - defer x.mu.Unlock() - if pti, ok = x.infos[rtid]; ok { - return - } - + // do not hold lock while computing this. + // it may lead to duplication, but that's ok. ti := typeInfo{rt: rt, rtid: rtid} - pti = &ti + ti.numMeth = uint16(rt.NumMethod()) var indir int8 if ok, indir = implementsIntf(rt, binaryMarshalerTyp); ok { @@ -813,7 +843,13 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) { copy(ti.sfi, sfip) } // sfi = sfip - x.infos[rtid] = pti + + x.mu.Lock() + if pti, ok = x.infos[rtid]; !ok { + pti = &ti + x.infos[rtid] = pti + } + x.mu.Unlock() return } @@ -822,45 +858,49 @@ func (x *TypeInfos) rget(rt reflect.Type, indexstack []int, fnameToHastag map[st ) { for j := 0; j < rt.NumField(); j++ { f := rt.Field(j) - // func types are skipped. - if tk := f.Type.Kind(); tk == reflect.Func { + fkind := f.Type.Kind() + // skip if a func type, or is unexported, or structTag value == "-" + if fkind == reflect.Func { + continue + } + // if r1, _ := utf8.DecodeRuneInString(f.Name); r1 == utf8.RuneError || !unicode.IsUpper(r1) { + if f.PkgPath != "" && !f.Anonymous { // unexported, not embedded continue } stag := x.structTag(f.Tag) if stag == "-" { continue } - if r1, _ := utf8.DecodeRuneInString(f.Name); r1 == utf8.RuneError || !unicode.IsUpper(r1) { - continue - } var si *structFieldInfo - // if anonymous and there is no struct tag (or it's blank) - // and its a struct (or pointer to struct), inline it. - var doInline bool - if f.Anonymous && f.Type.Kind() != reflect.Interface { - doInline = stag == "" + // if anonymous and no struct tag (or it's blank), and a struct (or pointer to struct), inline it. + if f.Anonymous && fkind != reflect.Interface { + doInline := stag == "" if !doInline { si = parseStructFieldInfo("", stag) doInline = si.encName == "" // doInline = si.isZero() - // fmt.Printf(">>>> doInline for si.isZero: %s: %v\n", f.Name, doInline) + } + if doInline { + ft := f.Type + for ft.Kind() == reflect.Ptr { + ft = ft.Elem() + } + if ft.Kind() == reflect.Struct { + indexstack2 := make([]int, len(indexstack)+1, len(indexstack)+4) + copy(indexstack2, indexstack) + indexstack2[len(indexstack)] = j + // indexstack2 := append(append(make([]int, 0, len(indexstack)+4), indexstack...), j) + x.rget(ft, indexstack2, fnameToHastag, sfi, siInfo) + continue + } } } - if doInline { - ft := f.Type - for ft.Kind() == reflect.Ptr { - ft = ft.Elem() - } - if ft.Kind() == reflect.Struct { - indexstack2 := make([]int, len(indexstack)+1, len(indexstack)+4) - copy(indexstack2, indexstack) - indexstack2[len(indexstack)] = j - // indexstack2 := append(append(make([]int, 0, len(indexstack)+4), indexstack...), j) - x.rget(ft, indexstack2, fnameToHastag, sfi, siInfo) - continue - } + // after the anonymous dance: if an unexported field, skip + if f.PkgPath != "" { // unexported + continue } + // do not let fields with same name in embedded structs override field at higher level. // this must be done after anonymous check, to allow anonymous field // still include their child fields diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/json.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/json.go index e70fc658d0d..a18a5f7063e 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/json.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/json.go @@ -30,8 +30,6 @@ package codec // Top-level methods of json(End|Dec)Driver (which are implementations of (en|de)cDriver // MUST not call one-another. -// They all must call sep(), and sep() MUST NOT be called more than once for each read. -// If sep() is called and read is not done, you MUST call retryRead so separator wouldn't be read/written twice. import ( "bytes" @@ -39,7 +37,6 @@ import ( "fmt" "reflect" "strconv" - "sync" "unicode/utf16" "unicode/utf8" ) @@ -60,12 +57,13 @@ var jsonUint64Pow10 = [...]uint64{ } const ( - // if jsonTrackSkipWhitespace, we track Whitespace and reduce the number of redundant checks. - // Make it a const flag, so that it can be elided during linking if false. + // jsonUnreadAfterDecNum controls whether we unread after decoding a number. // - // It is not a clear win, because we continually set a flag behind a pointer - // and then check it each time, as opposed to just 4 conditionals on a stack variable. - jsonTrackSkipWhitespace = true + // instead of unreading, just update d.tok (iff it's not a whitespace char) + // However, doing this means that we may HOLD onto some data which belongs to another stream. + // Thus, it is safest to unread the data when done. + // keep behind a constant flag for now. + jsonUnreadAfterDecNum = true // If !jsonValidateSymbols, decoding will be faster, by skipping some checks: // - If we see first character of null, false or true, @@ -89,100 +87,6 @@ const ( // jsonNumDigitsUint64Largest = 19 ) -// A stack is used to keep track of where we are in the tree. -// This is necessary, as the Handle must know whether to consume or emit a separator. - -type jsonStackElem struct { - st byte // top of stack (either '}' or ']' or 0 for map, array or neither). - sf bool // NOT first time in that container at top of stack - so bool // stack ctr odd - sr bool // value has NOT been read, so do not re-send separator -} - -func (x *jsonStackElem) retryRead() { - if x != nil && !x.sr { - x.sr = true - } -} - -func (x *jsonStackElem) sep() (c byte) { - // do not use switch, so it's a candidate for inlining. - // to inline effectively, this must not be called from within another method. - // v := j.st - if x == nil || x.st == 0 { - return - } - if x.sr { - x.sr = false - return - } - // v == '}' OR ']' - if x.st == '}' { - // put , or : depending on if even or odd respectively - if x.so { - c = ':' - if !x.sf { - x.sf = true - } - } else if x.sf { - c = ',' - } - } else { - if x.sf { - c = ',' - } else { - x.sf = true - } - } - x.so = !x.so - // Note: Anything more, and this function doesn't inline. Keep it tight. - // if x.sr { - // x.sr = false - // } - return -} - -const jsonStackPoolArrayLen = 32 - -// pool used to prevent constant allocation of stacks. -var jsonStackPool = sync.Pool{ - New: func() interface{} { - return new([jsonStackPoolArrayLen]jsonStackElem) - }, -} - -// jsonStack contains the stack for tracking the state of the container (branch). -// The same data structure is used during encode and decode, as it is similar functionality. -type jsonStack struct { - s []jsonStackElem // stack for map or array end tag. map=}, array=] - sc *jsonStackElem // pointer to current (top) element on the stack. - sp *[jsonStackPoolArrayLen]jsonStackElem -} - -func (j *jsonStack) start(c byte) { - if j.s == nil { - // j.s = make([]jsonStackElem, 0, 8) - j.sp = jsonStackPool.Get().(*[jsonStackPoolArrayLen]jsonStackElem) - j.s = j.sp[:0] - } - j.s = append(j.s, jsonStackElem{st: c}) - j.sc = &(j.s[len(j.s)-1]) -} - -func (j *jsonStack) end() { - l := len(j.s) - 1 // length of new stack after pop'ing - if l == 0 { - jsonStackPool.Put(j.sp) - j.s = nil - j.sp = nil - j.sc = nil - } else { - j.s = j.s[:l] - j.sc = &(j.s[l-1]) - } - //j.sc = &(j.s[len(j.s)-1]) -} - type jsonEncDriver struct { e *Encoder w encWriter @@ -190,21 +94,35 @@ type jsonEncDriver struct { b [64]byte // scratch bs []byte // scratch se setExtWrapper - s jsonStack + c containerState noBuiltInTypes } -func (e *jsonEncDriver) EncodeNil() { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) +func (e *jsonEncDriver) sendContainerState(c containerState) { + // determine whether to output separators + if c == containerMapKey { + if e.c != containerMapStart { + e.w.writen1(',') + } + } else if c == containerMapValue { + e.w.writen1(':') + } else if c == containerMapEnd { + e.w.writen1('}') + } else if c == containerArrayElem { + if e.c != containerArrayStart { + e.w.writen1(',') + } + } else if c == containerArrayEnd { + e.w.writen1(']') } + e.c = c +} + +func (e *jsonEncDriver) EncodeNil() { e.w.writeb(jsonLiterals[9:13]) // null } func (e *jsonEncDriver) EncodeBool(b bool) { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } if b { e.w.writeb(jsonLiterals[0:4]) // true } else { @@ -213,94 +131,56 @@ func (e *jsonEncDriver) EncodeBool(b bool) { } func (e *jsonEncDriver) EncodeFloat32(f float32) { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } e.w.writeb(strconv.AppendFloat(e.b[:0], float64(f), 'E', -1, 32)) } func (e *jsonEncDriver) EncodeFloat64(f float64) { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } // e.w.writestr(strconv.FormatFloat(f, 'E', -1, 64)) e.w.writeb(strconv.AppendFloat(e.b[:0], f, 'E', -1, 64)) } func (e *jsonEncDriver) EncodeInt(v int64) { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } e.w.writeb(strconv.AppendInt(e.b[:0], v, 10)) } func (e *jsonEncDriver) EncodeUint(v uint64) { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } e.w.writeb(strconv.AppendUint(e.b[:0], v, 10)) } func (e *jsonEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Encoder) { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } if v := ext.ConvertExt(rv); v == nil { e.w.writeb(jsonLiterals[9:13]) // null // e.EncodeNil() } else { - e.s.sc.retryRead() en.encode(v) } } func (e *jsonEncDriver) EncodeRawExt(re *RawExt, en *Encoder) { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } // only encodes re.Value (never re.Data) if re.Value == nil { e.w.writeb(jsonLiterals[9:13]) // null // e.EncodeNil() } else { - e.s.sc.retryRead() en.encode(re.Value) } } func (e *jsonEncDriver) EncodeArrayStart(length int) { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } - e.s.start(']') e.w.writen1('[') + e.c = containerArrayStart } func (e *jsonEncDriver) EncodeMapStart(length int) { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } - e.s.start('}') e.w.writen1('{') -} - -func (e *jsonEncDriver) EncodeEnd() { - b := e.s.sc.st - e.s.end() - e.w.writen1(b) + e.c = containerMapStart } func (e *jsonEncDriver) EncodeString(c charEncoding, v string) { // e.w.writestr(strconv.Quote(v)) - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } e.quoteStr(v) } func (e *jsonEncDriver) EncodeSymbol(v string) { // e.EncodeString(c_UTF8, v) - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } e.quoteStr(v) } @@ -310,14 +190,8 @@ func (e *jsonEncDriver) EncodeStringBytes(c charEncoding, v []byte) { e.EncodeExt(v, 0, &e.se, e.e) return } - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } if c == c_RAW { slen := base64.StdEncoding.EncodedLen(len(v)) - if e.bs == nil { - e.bs = e.b[:] - } if cap(e.bs) >= slen { e.bs = e.bs[:slen] } else { @@ -334,9 +208,6 @@ func (e *jsonEncDriver) EncodeStringBytes(c charEncoding, v []byte) { } func (e *jsonEncDriver) EncodeAsis(v []byte) { - if c := e.s.sc.sep(); c != 0 { - e.w.writen1(c) - } e.w.writeb(v) } @@ -491,185 +362,219 @@ func (x *jsonNum) floatVal() (f float64, parseUsingStrConv bool) { } type jsonDecDriver struct { - d *Decoder - h *JsonHandle - r decReader // *bytesDecReader decReader - ct valueType // container type. one of unset, array or map. - bstr [8]byte // scratch used for string \UXXX parsing - b [64]byte // scratch, used for parsing strings or numbers - b2 [64]byte // scratch, used only for decodeBytes (after base64) - bs []byte // scratch. Initialized from b. Used for parsing strings or numbers. + noBuiltInTypes + d *Decoder + h *JsonHandle + r decReader - wsSkipped bool // whitespace skipped + c containerState + // tok is used to store the token read right after skipWhiteSpace. + tok uint8 + + bstr [8]byte // scratch used for string \UXXX parsing + b [64]byte // scratch, used for parsing strings or numbers + b2 [64]byte // scratch, used only for decodeBytes (after base64) + bs []byte // scratch. Initialized from b. Used for parsing strings or numbers. se setExtWrapper - s jsonStack - n jsonNum - noBuiltInTypes } -// This will skip whitespace characters and return the next byte to read. -// The next byte determines what the value will be one of. -func (d *jsonDecDriver) skipWhitespace(unread bool) (b byte) { - // as initReadNext is not called all the time, we set ct to unSet whenever - // we skipwhitespace, as this is the signal that something new is about to be read. - d.ct = valueTypeUnset - b = d.r.readn1() - if !jsonTrackSkipWhitespace || !d.wsSkipped { - for ; b == ' ' || b == '\t' || b == '\r' || b == '\n'; b = d.r.readn1() { - } - if jsonTrackSkipWhitespace { - d.wsSkipped = true - } - } - if unread { +func jsonIsWS(b byte) bool { + return b == ' ' || b == '\t' || b == '\r' || b == '\n' +} + +// // This will skip whitespace characters and return the next byte to read. +// // The next byte determines what the value will be one of. +// func (d *jsonDecDriver) skipWhitespace() { +// // fast-path: do not enter loop. Just check first (in case no whitespace). +// b := d.r.readn1() +// if jsonIsWS(b) { +// r := d.r +// for b = r.readn1(); jsonIsWS(b); b = r.readn1() { +// } +// } +// d.tok = b +// } + +func (d *jsonDecDriver) uncacheRead() { + if d.tok != 0 { d.r.unreadn1() + d.tok = 0 } - return b +} + +func (d *jsonDecDriver) sendContainerState(c containerState) { + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + var xc uint8 // char expected + if c == containerMapKey { + if d.c != containerMapStart { + xc = ',' + } + } else if c == containerMapValue { + xc = ':' + } else if c == containerMapEnd { + xc = '}' + } else if c == containerArrayElem { + if d.c != containerArrayStart { + xc = ',' + } + } else if c == containerArrayEnd { + xc = ']' + } + if xc != 0 { + if d.tok != xc { + d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok) + } + d.tok = 0 + } + d.c = c } func (d *jsonDecDriver) CheckBreak() bool { - b := d.skipWhitespace(true) - return b == '}' || b == ']' + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + if d.tok == '}' || d.tok == ']' { + // d.tok = 0 // only checking, not consuming + return true + } + return false } func (d *jsonDecDriver) readStrIdx(fromIdx, toIdx uint8) { bs := d.r.readx(int(toIdx - fromIdx)) + d.tok = 0 if jsonValidateSymbols { if !bytes.Equal(bs, jsonLiterals[fromIdx:toIdx]) { d.d.errorf("json: expecting %s: got %s", jsonLiterals[fromIdx:toIdx], bs) return } } - if jsonTrackSkipWhitespace { - d.wsSkipped = false - } } func (d *jsonDecDriver) TryDecodeAsNil() bool { - // we mustn't consume the state here, and end up trying to read separator twice. - // Instead, we keep track of the state and restore it if we couldn't decode as nil. - - if c := d.s.sc.sep(); c != 0 { - d.expectChar(c) + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b } - b := d.skipWhitespace(false) - if b == 'n' { + if d.tok == 'n' { d.readStrIdx(10, 13) // ull - d.ct = valueTypeNil return true } - d.r.unreadn1() - d.s.sc.retryRead() return false } func (d *jsonDecDriver) DecodeBool() bool { - if c := d.s.sc.sep(); c != 0 { - d.expectChar(c) + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b } - b := d.skipWhitespace(false) - if b == 'f' { + if d.tok == 'f' { d.readStrIdx(5, 9) // alse return false } - if b == 't' { + if d.tok == 't' { d.readStrIdx(1, 4) // rue return true } - d.d.errorf("json: decode bool: got first char %c", b) + d.d.errorf("json: decode bool: got first char %c", d.tok) return false // "unreachable" } func (d *jsonDecDriver) ReadMapStart() int { - if c := d.s.sc.sep(); c != 0 { - d.expectChar(c) + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b } - d.s.start('}') - d.expectChar('{') - d.ct = valueTypeMap + if d.tok != '{' { + d.d.errorf("json: expect char '%c' but got char '%c'", '{', d.tok) + } + d.tok = 0 + d.c = containerMapStart return -1 } func (d *jsonDecDriver) ReadArrayStart() int { - if c := d.s.sc.sep(); c != 0 { - d.expectChar(c) + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b } - d.s.start(']') - d.expectChar('[') - d.ct = valueTypeArray + if d.tok != '[' { + d.d.errorf("json: expect char '%c' but got char '%c'", '[', d.tok) + } + d.tok = 0 + d.c = containerArrayStart return -1 } -func (d *jsonDecDriver) ReadEnd() { - b := d.s.sc.st - d.s.end() - d.expectChar(b) -} - -func (d *jsonDecDriver) expectChar(c uint8) { - b := d.skipWhitespace(false) - if b != c { - d.d.errorf("json: expect char '%c' but got char '%c'", c, b) - return - } - if jsonTrackSkipWhitespace { - d.wsSkipped = false - } -} - -// func (d *jsonDecDriver) maybeChar(c uint8) { -// b := d.skipWhitespace(false) -// if b != c { -// d.r.unreadn1() -// return -// } -// if jsonTrackSkipWhitespace { -// d.wsSkipped = false -// } -// } - -func (d *jsonDecDriver) IsContainerType(vt valueType) bool { +func (d *jsonDecDriver) ContainerType() (vt valueType) { // check container type by checking the first char - if d.ct == valueTypeUnset { - b := d.skipWhitespace(true) - if b == '{' { - d.ct = valueTypeMap - } else if b == '[' { - d.ct = valueTypeArray - } else if b == 'n' { - d.ct = valueTypeNil - } else if b == '"' { - d.ct = valueTypeString + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { } + d.tok = b } - if vt == valueTypeNil || vt == valueTypeBytes || vt == valueTypeString || - vt == valueTypeArray || vt == valueTypeMap { - return d.ct == vt + if b := d.tok; b == '{' { + return valueTypeMap + } else if b == '[' { + return valueTypeArray + } else if b == 'n' { + return valueTypeNil + } else if b == '"' { + return valueTypeString } - // ugorji: made switch into conditionals, so that IsContainerType can be inlined. - // switch vt { - // case valueTypeNil, valueTypeBytes, valueTypeString, valueTypeArray, valueTypeMap: - // return d.ct == vt - // } - d.d.errorf("isContainerType: unsupported parameter: %v", vt) - return false // "unreachable" + return valueTypeUnset + // d.d.errorf("isContainerType: unsupported parameter: %v", vt) + // return false // "unreachable" } func (d *jsonDecDriver) decNum(storeBytes bool) { // If it is has a . or an e|E, decode as a float; else decode as an int. - b := d.skipWhitespace(false) + if d.tok == 0 { + var b byte + r := d.r + for b = r.readn1(); jsonIsWS(b); b = r.readn1() { + } + d.tok = b + } + b := d.tok if !(b == '+' || b == '-' || b == '.' || (b >= '0' && b <= '9')) { d.d.errorf("json: decNum: got first char '%c'", b) return } + d.tok = 0 const cutoff = (1<<64-1)/uint64(10) + 1 // cutoff64(base) const jsonNumUintMaxVal = 1<= mpPosFixNumMin && bd <= mpPosFixNumMax: // positive fixnum (always signed) - vt = valueTypeInt - v = int64(int8(bd)) + n.v = valueTypeInt + n.i = int64(int8(bd)) case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax: // negative fixnum - vt = valueTypeInt - v = int64(int8(bd)) + n.v = valueTypeInt + n.i = int64(int8(bd)) case bd == mpStr8, bd == mpStr16, bd == mpStr32, bd >= mpFixStrMin && bd <= mpFixStrMax: if d.h.RawToString { - var rvm string - vt = valueTypeString - v = &rvm + n.v = valueTypeString + n.s = d.DecodeString() } else { - var rvm = zeroByteSlice - vt = valueTypeBytes - v = &rvm + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) } - decodeFurther = true case bd == mpBin8, bd == mpBin16, bd == mpBin32: - var rvm = zeroByteSlice - vt = valueTypeBytes - v = &rvm - decodeFurther = true + n.v = valueTypeBytes + n.l = d.DecodeBytes(nil, false, false) case bd == mpArray16, bd == mpArray32, bd >= mpFixArrayMin && bd <= mpFixArrayMax: - vt = valueTypeArray + n.v = valueTypeArray decodeFurther = true case bd == mpMap16, bd == mpMap32, bd >= mpFixMapMin && bd <= mpFixMapMax: - vt = valueTypeMap + n.v = valueTypeMap decodeFurther = true case bd >= mpFixExt1 && bd <= mpFixExt16, bd >= mpExt8 && bd <= mpExt32: + n.v = valueTypeExt clen := d.readExtLen() - var re RawExt - re.Tag = uint64(d.r.readn1()) - re.Data = d.r.readx(clen) - v = &re - vt = valueTypeExt + n.u = uint64(d.r.readn1()) + n.l = d.r.readx(clen) default: d.d.errorf("Nil-Deciphered DecodeValue: %s: hex: %x, dec: %d", msgBadDesc, bd, bd) - return } } if !decodeFurther { d.bdRead = false } - if vt == valueTypeUint && d.h.SignedInteger { - d.bdType = valueTypeInt - v = int64(v.(uint64)) + if n.v == valueTypeUint && d.h.SignedInteger { + n.v = valueTypeInt + n.i = int64(n.v) } return } @@ -566,28 +559,27 @@ func (d *msgpackDecDriver) DecodeString() (s string) { func (d *msgpackDecDriver) readNextBd() { d.bd = d.r.readn1() d.bdRead = true - d.bdType = valueTypeUnset } -func (d *msgpackDecDriver) IsContainerType(vt valueType) bool { +func (d *msgpackDecDriver) ContainerType() (vt valueType) { bd := d.bd - switch vt { - case valueTypeNil: - return bd == mpNil - case valueTypeBytes: - return bd == mpBin8 || bd == mpBin16 || bd == mpBin32 || - (!d.h.RawToString && - (bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || (bd >= mpFixStrMin && bd <= mpFixStrMax))) - case valueTypeString: - return d.h.RawToString && - (bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || (bd >= mpFixStrMin && bd <= mpFixStrMax)) - case valueTypeArray: - return bd == mpArray16 || bd == mpArray32 || (bd >= mpFixArrayMin && bd <= mpFixArrayMax) - case valueTypeMap: - return bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) + if bd == mpNil { + return valueTypeNil + } else if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 || + (!d.h.RawToString && + (bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || (bd >= mpFixStrMin && bd <= mpFixStrMax))) { + return valueTypeBytes + } else if d.h.RawToString && + (bd == mpStr8 || bd == mpStr16 || bd == mpStr32 || (bd >= mpFixStrMin && bd <= mpFixStrMax)) { + return valueTypeString + } else if bd == mpArray16 || bd == mpArray32 || (bd >= mpFixArrayMin && bd <= mpFixArrayMax) { + return valueTypeArray + } else if bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) { + return valueTypeMap + } else { + // d.d.errorf("isContainerType: unsupported parameter: %v", vt) } - d.d.errorf("isContainerType: unsupported parameter: %v", vt) - return false // "unreachable" + return valueTypeUnset } func (d *msgpackDecDriver) TryDecodeAsNil() (v bool) { @@ -701,7 +693,6 @@ func (d *msgpackDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs //MsgpackHandle is a Handle for the Msgpack Schema-Free Encoding Format. type MsgpackHandle struct { BasicHandle - binaryEncodingType // RawToString controls how raw bytes are decoded into a nil interface{}. RawToString bool @@ -717,6 +708,11 @@ type MsgpackHandle struct { // type is provided (e.g. decoding into a nil interface{}), you get back // a []byte or string based on the setting of RawToString. WriteExt bool + binaryEncodingType +} + +func (h *MsgpackHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) { + return h.SetExt(rt, tag, &setExtWrapper{b: ext}) } func (h *MsgpackHandle) newEncDriver(e *Encoder) encDriver { @@ -727,8 +723,12 @@ func (h *MsgpackHandle) newDecDriver(d *Decoder) decDriver { return &msgpackDecDriver{d: d, r: d.r, h: h, br: d.bytes} } -func (h *MsgpackHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) { - return h.SetExt(rt, tag, &setExtWrapper{b: ext}) +func (e *msgpackEncDriver) reset() { + e.w = e.e.w +} + +func (d *msgpackDecDriver) reset() { + d.r = d.d.r } //-------------------------------------------------- diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/noop.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/noop.go index ca02c6a7e8f..cfee3d084dc 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/noop.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/noop.go @@ -38,21 +38,26 @@ type noopHandle struct { } type noopDrv struct { + d *Decoder + e *Encoder i int S []string B [][]byte mks []bool // stack. if map (true), else if array (false) mk bool // top of stack. what container are we on? map or array? - ct valueType // last request for IsContainerType. - cb bool // last response for IsContainerType. + ct valueType // last response for IsContainerType. + cb int // counter for ContainerType rand *rand.Rand } func (h *noopDrv) r(v int) int { return h.rand.Intn(v) } func (h *noopDrv) m(v int) int { h.i++; return h.i % v } -func (h *noopDrv) newEncDriver(_ *Encoder) encDriver { return h } -func (h *noopDrv) newDecDriver(_ *Decoder) decDriver { return h } +func (h *noopDrv) newEncDriver(e *Encoder) encDriver { h.e = e; return h } +func (h *noopDrv) newDecDriver(d *Decoder) decDriver { h.d = d; return h } + +func (h *noopDrv) reset() {} +func (h *noopDrv) uncacheRead() {} // --- encDriver @@ -111,18 +116,48 @@ func (h *noopDrv) ReadEnd() { h.end() } func (h *noopDrv) ReadMapStart() int { h.start(true); return h.m(10) } func (h *noopDrv) ReadArrayStart() int { h.start(false); return h.m(10) } -func (h *noopDrv) IsContainerType(vt valueType) bool { +func (h *noopDrv) ContainerType() (vt valueType) { // return h.m(2) == 0 - // handle kStruct - if h.ct == valueTypeMap && vt == valueTypeArray || h.ct == valueTypeArray && vt == valueTypeMap { - h.cb = !h.cb - h.ct = vt - return h.cb - } - // go in a loop and check it. - h.ct = vt - h.cb = h.m(7) == 0 - return h.cb + // handle kStruct, which will bomb is it calls this and doesn't get back a map or array. + // consequently, if the return value is not map or array, reset it to one of them based on h.m(7) % 2 + // for kstruct: at least one out of every 2 times, return one of valueTypeMap or Array (else kstruct bombs) + // however, every 10th time it is called, we just return something else. + var vals = [...]valueType{valueTypeArray, valueTypeMap} + // ------------ TAKE ------------ + // if h.cb%2 == 0 { + // if h.ct == valueTypeMap || h.ct == valueTypeArray { + // } else { + // h.ct = vals[h.m(2)] + // } + // } else if h.cb%5 == 0 { + // h.ct = valueType(h.m(8)) + // } else { + // h.ct = vals[h.m(2)] + // } + // ------------ TAKE ------------ + // if h.cb%16 == 0 { + // h.ct = valueType(h.cb % 8) + // } else { + // h.ct = vals[h.cb%2] + // } + h.ct = vals[h.cb%2] + h.cb++ + return h.ct + + // if h.ct == valueTypeNil || h.ct == valueTypeString || h.ct == valueTypeBytes { + // return h.ct + // } + // return valueTypeUnset + // TODO: may need to tweak this so it works. + // if h.ct == valueTypeMap && vt == valueTypeArray || h.ct == valueTypeArray && vt == valueTypeMap { + // h.cb = !h.cb + // h.ct = vt + // return h.cb + // } + // // go in a loop and check it. + // h.ct = vt + // h.cb = h.m(7) == 0 + // return h.cb } func (h *noopDrv) TryDecodeAsNil() bool { if h.mk { @@ -135,7 +170,7 @@ func (h *noopDrv) DecodeExt(rv interface{}, xtag uint64, ext Ext) uint64 { return 0 } -func (h *noopDrv) DecodeNaked() (v interface{}, vt valueType, decodeFurther bool) { +func (h *noopDrv) DecodeNaked() { // use h.r (random) not h.m() because h.m() could cause the same value to be given. var sk int if h.mk { @@ -144,32 +179,35 @@ func (h *noopDrv) DecodeNaked() (v interface{}, vt valueType, decodeFurther bool } else { sk = h.r(12) } + n := &h.d.n switch sk { case 0: - vt = valueTypeNil + n.v = valueTypeNil case 1: - vt, v = valueTypeBool, false + n.v, n.b = valueTypeBool, false case 2: - vt, v = valueTypeBool, true + n.v, n.b = valueTypeBool, true case 3: - vt, v = valueTypeInt, h.DecodeInt(64) + n.v, n.i = valueTypeInt, h.DecodeInt(64) case 4: - vt, v = valueTypeUint, h.DecodeUint(64) + n.v, n.u = valueTypeUint, h.DecodeUint(64) case 5: - vt, v = valueTypeFloat, h.DecodeFloat(true) + n.v, n.f = valueTypeFloat, h.DecodeFloat(true) case 6: - vt, v = valueTypeFloat, h.DecodeFloat(false) + n.v, n.f = valueTypeFloat, h.DecodeFloat(false) case 7: - vt, v = valueTypeString, h.DecodeString() + n.v, n.s = valueTypeString, h.DecodeString() case 8: - vt, v = valueTypeBytes, h.B[h.m(len(h.B))] + n.v, n.l = valueTypeBytes, h.B[h.m(len(h.B))] case 9: - vt, decodeFurther = valueTypeArray, true + n.v = valueTypeArray case 10: - vt, decodeFurther = valueTypeMap, true + n.v = valueTypeMap default: - vt, v = valueTypeExt, &RawExt{Tag: h.DecodeUint(64), Data: h.B[h.m(len(h.B))]} + n.v = valueTypeExt + n.u = h.DecodeUint(64) + n.l = h.B[h.m(len(h.B))] } - h.ct = vt + h.ct = n.v return } diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/prebuild.sh b/Godeps/_workspace/src/github.com/ugorji/go/codec/prebuild.sh index 9c8119f3650..98f442487a7 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/prebuild.sh +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/prebuild.sh @@ -49,7 +49,8 @@ _build() { # [ -e "safe${_gg}" ] && mv safe${_gg} safe${_gg}__${_zts}.bak # [ -e "unsafe${_gg}" ] && mv unsafe${_gg} unsafe${_gg}__${_zts}.bak else - rm -f fast-path.generated.go gen.generated.go gen-helper.generated.go *safe.generated.go *_generated_test.go *.generated_ffjson_expose.go + rm -f fast-path.generated.go gen.generated.go gen-helper.generated.go \ + *safe.generated.go *_generated_test.go *.generated_ffjson_expose.go fi cat > gen.generated.go <> gen.generated.go < fast-path.generated.go < gen-from-tmpl.codec.generated.go <>>>>>> TAGS: $ztags" OPTIND=1 - while getopts "xurtcinsvg" flag + while getopts "xurtcinsvgzmef" flag do case "x$flag" in - 'xt') printf ">>>>>>> REGULAR : "; go test "-tags=$ztags" "$zverbose" ; sleep 2 ;; - 'xc') printf ">>>>>>> CANONICAL : "; go test "-tags=$ztags" "$zverbose" -tc; sleep 2 ;; - 'xi') printf ">>>>>>> I/O : "; go test "-tags=$ztags" "$zverbose" -ti; sleep 2 ;; - 'xn') printf ">>>>>>> NO_SYMBOLS : "; go test "-tags=$ztags" "$zverbose" -tn; sleep 2 ;; - 'xs') printf ">>>>>>> TO_ARRAY : "; go test "-tags=$ztags" "$zverbose" -ts; sleep 2 ;; + 'xt') printf ">>>>>>> REGULAR : "; go test "-tags=$ztags" $zargs ; sleep 2 ;; + 'xc') printf ">>>>>>> CANONICAL : "; go test "-tags=$ztags" $zargs -tc; sleep 2 ;; + 'xi') printf ">>>>>>> I/O : "; go test "-tags=$ztags" $zargs -ti; sleep 2 ;; + 'xn') printf ">>>>>>> NO_SYMBOLS : "; go test "-tags=$ztags" $zargs -tn; sleep 2 ;; + 'xs') printf ">>>>>>> TO_ARRAY : "; go test "-tags=$ztags" $zargs -ts; sleep 2 ;; + 'xe') printf ">>>>>>> INTERN : "; go test "-tags=$ztags" $zargs -te; sleep 2 ;; *) ;; esac done @@ -46,11 +54,21 @@ _run() { # echo ">>>>>>> RUNNING VARIATIONS OF TESTS" if [[ "x$@" = "x" ]]; then - # r, x, g, gu - _run "-rtcins" - _run "-xtcins" - _run "-gtcins" - _run "-gutcins" + # All: r, x, g, gu + _run "-rtcinsm" # regular + _run "-rtcinsmz" # regular with reset + _run "-rtcinsmf" # regular with no fastpath (notfastpath) + _run "-xtcinsm" # external + _run "-gxtcinsm" # codecgen: requires external + _run "-gxutcinsm" # codecgen + unsafe +elif [[ "x$@" = "x-Z" ]]; then + # Regular + _run "-rtcinsm" # regular + _run "-rtcinsmz" # regular with reset +elif [[ "x$@" = "x-F" ]]; then + # regular with notfastpath + _run "-rtcinsmf" # regular + _run "-rtcinsmzf" # regular with reset else _run "$@" fi diff --git a/Godeps/_workspace/src/github.com/ugorji/go/codec/time.go b/Godeps/_workspace/src/github.com/ugorji/go/codec/time.go index 733fc3fb75a..fc4c63e1def 100644 --- a/Godeps/_workspace/src/github.com/ugorji/go/codec/time.go +++ b/Godeps/_workspace/src/github.com/ugorji/go/codec/time.go @@ -4,6 +4,7 @@ package codec import ( + "fmt" "time" ) @@ -11,6 +12,34 @@ var ( timeDigits = [...]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'} ) +type timeExt struct{} + +func (x timeExt) WriteExt(v interface{}) (bs []byte) { + switch v2 := v.(type) { + case time.Time: + bs = encodeTime(v2) + case *time.Time: + bs = encodeTime(*v2) + default: + panic(fmt.Errorf("unsupported format for time conversion: expecting time.Time; got %T", v2)) + } + return +} +func (x timeExt) ReadExt(v interface{}, bs []byte) { + tt, err := decodeTime(bs) + if err != nil { + panic(err) + } + *(v.(*time.Time)) = tt +} + +func (x timeExt) ConvertExt(v interface{}) interface{} { + return x.WriteExt(v) +} +func (x timeExt) UpdateExt(v interface{}, src interface{}) { + x.ReadExt(v, src.([]byte)) +} + // EncodeTime encodes a time.Time as a []byte, including // information on the instant in time and UTC offset. //