// 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. package codec import ( "encoding" "errors" "fmt" "io" "reflect" "time" ) // Some tagging information for error messages. const ( msgBadDesc = "Unrecognized descriptor byte" msgDecCannotExpandArr = "cannot expand go array from %v to stream length: %v" ) var ( onlyMapOrArrayCanDecodeIntoStructErr = errors.New("only encoded map or array can be decoded into a struct") cannotDecodeIntoNilErr = errors.New("cannot decode into nil") ) // decReader abstracts the reading source, allowing implementations that can // read from an io.Reader or directly off a byte slice with zero-copying. type decReader interface { unreadn1() // readx will use the implementation scratch buffer if possible i.e. n < len(scratchbuf), OR // just return a view of the []byte being decoded from. // Ensure you call detachZeroCopyBytes later if this needs to be sent outside codec control. readx(n int) []byte readb([]byte) readn1() uint8 readn1eof() (v uint8, eof bool) numread() int // number of bytes read track() stopTrack() []byte } type decReaderByteScanner interface { io.Reader io.ByteScanner } type decDriver interface { // this will check if the next token is a break. CheckBreak() bool TryDecodeAsNil() 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 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) DecodeBool() (b bool) // DecodeString can also decode symbols. // It looks redundant as DecodeBytes is available. // However, some codecs (e.g. binc) support symbols and can // return a pre-stored string value, meaning that it can bypass // the cost of []byte->string conversion. DecodeString() (s string) // DecodeBytes may be called directly, without going through reflection. // Consequently, it must be designed to handle possible nil. DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) // decodeExt will decode into a *RawExt or into an extension. DecodeExt(v interface{}, xtag uint64, ext Ext) (realxtag uint64) // decodeExt(verifyTag bool, tag byte) (xtag byte, xbs []byte) ReadMapStart() int ReadArrayStart() int reset() uncacheRead() } type decNoSeparator struct { } func (_ decNoSeparator) ReadEnd() {} // func (_ decNoSeparator) uncacheRead() {} type DecodeOptions struct { // MapType specifies type to use during schema-less decoding of a map in the stream. // If nil, we use map[interface{}]interface{} MapType reflect.Type // SliceType specifies type to use during schema-less decoding of an array in the stream. // If nil, we use []interface{} SliceType reflect.Type // MaxInitLen defines the maxinum initial length that we "make" a collection (string, slice, map, chan). // If 0 or negative, we default to a sensible value based on the size of an element in the collection. // // For example, when decoding, a stream may say that it has 2^64 elements. // We should not auto-matically provision a slice of that length, to prevent Out-Of-Memory crash. // Instead, we provision up to MaxInitLen, fill that up, and start appending after that. MaxInitLen int // If ErrorIfNoField, return an error when decoding a map // from a codec stream into a struct, and no matching struct field is found. ErrorIfNoField bool // If ErrorIfNoArrayExpand, return an error when decoding a slice/array that cannot be expanded. // For example, the stream contains an array of 8 items, but you are decoding into a [4]T array, // or you are decoding into a slice of length 4 which is non-addressable (and so cannot be set). ErrorIfNoArrayExpand bool // If SignedInteger, use the int64 during schema-less decoding of unsigned values (not uint64). SignedInteger bool // MapValueReset controls how we decode into a map value. // // By default, we MAY retrieve the mapping for a key, and then decode into that. // However, especially with big maps, that retrieval may be expensive and unnecessary // if the stream already contains all that is necessary to recreate the value. // // If true, we will never retrieve the previous mapping, // but rather decode into a new value and set that in the map. // // If false, we will retrieve the previous mapping if necessary e.g. // the previous mapping is a pointer, or is a struct or array with pre-set state, // or is an interface. MapValueReset bool // InterfaceReset controls how we decode into an interface. // // By default, when we see a field that is an interface{...}, // or a map with interface{...} value, we will attempt decoding into the // "contained" value. // // However, this prevents us from reading a string into an interface{} // that formerly contained a number. // // If true, we will decode into a new "blank" value, and set that in the interface. // If false, we will decode into whatever is contained in the interface. InterfaceReset bool // InternString controls interning of strings during decoding. // // Some handles, e.g. json, typically will read map keys as strings. // If the set of keys are finite, it may help reduce allocation to // look them up from a map (than to allocate them afresh). // // Note: Handles will be smart when using the intern functionality. // So everything will not be interned. InternString bool // PreferArrayOverSlice controls whether to decode to an array or a slice. // // This only impacts decoding into a nil interface{}. // Consequently, it has no effect on codecgen. // // *Note*: This only applies if using go1.5 and above, // as it requires reflect.ArrayOf support which was absent before go1.5. PreferArrayOverSlice bool } // ------------------------------------ // ioDecByteScanner implements Read(), ReadByte(...), UnreadByte(...) methods // of io.Reader, io.ByteScanner. type ioDecByteScanner struct { r io.Reader l byte // last byte ls byte // last byte status. 0: init-canDoNothing, 1: canRead, 2: canUnread b [1]byte // tiny buffer for reading single bytes } func (z *ioDecByteScanner) Read(p []byte) (n int, err error) { var firstByte bool if z.ls == 1 { z.ls = 2 p[0] = z.l if len(p) == 1 { n = 1 return } firstByte = true p = p[1:] } n, err = z.r.Read(p) if n > 0 { if err == io.EOF && n == len(p) { err = nil // read was successful, so postpone EOF (till next time) } z.l = p[n-1] z.ls = 2 } if firstByte { n++ } return } func (z *ioDecByteScanner) ReadByte() (c byte, err error) { n, err := z.Read(z.b[:]) if n == 1 { c = z.b[0] if err == io.EOF { err = nil // read was successful, so postpone EOF (till next time) } } return } func (z *ioDecByteScanner) UnreadByte() (err error) { x := z.ls if x == 0 { err = errors.New("cannot unread - nothing has been read") } else if x == 1 { err = errors.New("cannot unread - last byte has not been read") } else if x == 2 { z.ls = 1 } return } // ioDecReader is a decReader that reads off an io.Reader type ioDecReader struct { br decReaderByteScanner // temp byte array re-used internally for efficiency during read. // shares buffer with Decoder, so we keep size of struct within 8 words. x *[scratchByteArrayLen]byte bs ioDecByteScanner n int // num read tr []byte // tracking bytes read trb bool } func (z *ioDecReader) numread() int { return z.n } func (z *ioDecReader) readx(n int) (bs []byte) { if n <= 0 { return } if n < len(z.x) { bs = z.x[:n] } else { bs = make([]byte, n) } if _, err := io.ReadAtLeast(z.br, bs, n); err != nil { panic(err) } z.n += len(bs) if z.trb { z.tr = append(z.tr, bs...) } return } func (z *ioDecReader) readb(bs []byte) { if len(bs) == 0 { return } n, err := io.ReadAtLeast(z.br, bs, len(bs)) z.n += n if err != nil { panic(err) } if z.trb { z.tr = append(z.tr, bs...) } } func (z *ioDecReader) readn1() (b uint8) { b, err := z.br.ReadByte() if err != nil { panic(err) } z.n++ if z.trb { z.tr = append(z.tr, b) } return b } func (z *ioDecReader) readn1eof() (b uint8, eof bool) { b, err := z.br.ReadByte() if err == nil { z.n++ if z.trb { z.tr = append(z.tr, b) } } else if err == io.EOF { eof = true } else { panic(err) } return } func (z *ioDecReader) unreadn1() { err := z.br.UnreadByte() if err != nil { panic(err) } z.n-- if z.trb { if l := len(z.tr) - 1; l >= 0 { z.tr = z.tr[:l] } } } func (z *ioDecReader) track() { if z.tr != nil { z.tr = z.tr[:0] } z.trb = true } func (z *ioDecReader) stopTrack() (bs []byte) { z.trb = false return z.tr } // ------------------------------------ var bytesDecReaderCannotUnreadErr = errors.New("cannot unread last byte read") // bytesDecReader is a decReader that reads off a byte slice with zero copying type bytesDecReader struct { b []byte // data c int // cursor a int // available 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 } func (z *bytesDecReader) unreadn1() { if z.c == 0 || len(z.b) == 0 { panic(bytesDecReaderCannotUnreadErr) } z.c-- z.a++ return } func (z *bytesDecReader) readx(n int) (bs []byte) { // slicing from a non-constant start position is more expensive, // as more computation is required to decipher the pointer start position. // However, we do it only once, and it's better than reslicing both z.b and return value. if n <= 0 { } else if z.a == 0 { panic(io.EOF) } else if n > z.a { panic(io.ErrUnexpectedEOF) } else { c0 := z.c z.c = c0 + n z.a = z.a - n bs = z.b[c0:z.c] } return } func (z *bytesDecReader) readn1() (v uint8) { if z.a == 0 { panic(io.EOF) } v = z.b[z.c] z.c++ z.a-- return } func (z *bytesDecReader) readn1eof() (v uint8, eof bool) { if z.a == 0 { eof = true return } v = z.b[z.c] z.c++ z.a-- return } func (z *bytesDecReader) readb(bs []byte) { copy(bs, z.readx(len(bs))) } func (z *bytesDecReader) track() { z.t = z.c } func (z *bytesDecReader) stopTrack() (bs []byte) { return z.b[z.t:z.c] } // ------------------------------------ type decFnInfo struct { d *Decoder ti *typeInfo xfFn Ext xfTag uint64 seq seqType } // ---------------------------------------- type decFn struct { i decFnInfo f func(*decFnInfo, reflect.Value) } func (f *decFnInfo) builtin(rv reflect.Value) { f.d.d.DecodeBuiltin(f.ti.rtid, rv.Addr().Interface()) } func (f *decFnInfo) rawExt(rv reflect.Value) { f.d.d.DecodeExt(rv.Addr().Interface(), 0, nil) } func (f *decFnInfo) raw(rv reflect.Value) { rv.SetBytes(f.d.raw()) } func (f *decFnInfo) ext(rv reflect.Value) { f.d.d.DecodeExt(rv.Addr().Interface(), f.xfTag, f.xfFn) } func (f *decFnInfo) getValueForUnmarshalInterface(rv reflect.Value, indir int8) (v interface{}) { if indir == -1 { v = rv.Addr().Interface() } else if indir == 0 { v = rv.Interface() } else { for j := int8(0); j < indir; j++ { if rv.IsNil() { rv.Set(reflect.New(rv.Type().Elem())) } rv = rv.Elem() } v = rv.Interface() } return } func (f *decFnInfo) selferUnmarshal(rv reflect.Value) { f.getValueForUnmarshalInterface(rv, f.ti.csIndir).(Selfer).CodecDecodeSelf(f.d) } func (f *decFnInfo) binaryUnmarshal(rv reflect.Value) { bm := f.getValueForUnmarshalInterface(rv, f.ti.bunmIndir).(encoding.BinaryUnmarshaler) xbs := f.d.d.DecodeBytes(nil, false, true) if fnerr := bm.UnmarshalBinary(xbs); fnerr != nil { panic(fnerr) } } func (f *decFnInfo) textUnmarshal(rv reflect.Value) { tm := f.getValueForUnmarshalInterface(rv, f.ti.tunmIndir).(encoding.TextUnmarshaler) fnerr := tm.UnmarshalText(f.d.d.DecodeBytes(f.d.b[:], true, true)) if fnerr != nil { panic(fnerr) } } 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 needs the full JSON so as to unmarshal it itself. fnerr := tm.UnmarshalJSON(f.d.nextValueBytes()) if fnerr != nil { panic(fnerr) } } func (f *decFnInfo) kErr(rv reflect.Value) { f.d.errorf("no decoding function defined for kind %v", rv.Kind()) } func (f *decFnInfo) kString(rv reflect.Value) { rv.SetString(f.d.d.DecodeString()) } func (f *decFnInfo) kBool(rv reflect.Value) { rv.SetBool(f.d.d.DecodeBool()) } func (f *decFnInfo) kInt(rv reflect.Value) { rv.SetInt(f.d.d.DecodeInt(intBitsize)) } func (f *decFnInfo) kInt64(rv reflect.Value) { rv.SetInt(f.d.d.DecodeInt(64)) } func (f *decFnInfo) kInt32(rv reflect.Value) { rv.SetInt(f.d.d.DecodeInt(32)) } func (f *decFnInfo) kInt8(rv reflect.Value) { rv.SetInt(f.d.d.DecodeInt(8)) } func (f *decFnInfo) kInt16(rv reflect.Value) { rv.SetInt(f.d.d.DecodeInt(16)) } func (f *decFnInfo) kFloat32(rv reflect.Value) { rv.SetFloat(f.d.d.DecodeFloat(true)) } func (f *decFnInfo) kFloat64(rv reflect.Value) { rv.SetFloat(f.d.d.DecodeFloat(false)) } func (f *decFnInfo) kUint8(rv reflect.Value) { rv.SetUint(f.d.d.DecodeUint(8)) } func (f *decFnInfo) kUint64(rv reflect.Value) { rv.SetUint(f.d.d.DecodeUint(64)) } func (f *decFnInfo) kUint(rv reflect.Value) { rv.SetUint(f.d.d.DecodeUint(uintBitsize)) } func (f *decFnInfo) kUintptr(rv reflect.Value) { rv.SetUint(f.d.d.DecodeUint(uintBitsize)) } func (f *decFnInfo) kUint32(rv reflect.Value) { rv.SetUint(f.d.d.DecodeUint(32)) } func (f *decFnInfo) kUint16(rv reflect.Value) { rv.SetUint(f.d.d.DecodeUint(16)) } // func (f *decFnInfo) kPtr(rv reflect.Value) { // debugf(">>>>>>> ??? decode kPtr called - shouldn't get called") // if rv.IsNil() { // rv.Set(reflect.New(rv.Type().Elem())) // } // f.d.decodeValue(rv.Elem()) // } // var kIntfCtr uint64 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. 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 { 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 n.v { case valueTypeMap: // 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) var v2 interface{} = &n.ms[l] d.decode(v2) rvn = reflect.ValueOf(v2).Elem() n.ms = n.ms[:l] } else if d.mtid == mapStrIntfTypId { // for json performance l := len(n.ns) n.ns = append(n.ns, nil) var v2 interface{} = &n.ns[l] d.decode(v2) rvn = reflect.ValueOf(v2).Elem() n.ns = n.ns[:l] } else { rvn = reflect.New(d.h.MapType).Elem() d.decodeValue(rvn, nil) } case valueTypeArray: // 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) var v2 interface{} = &n.ss[l] d.decode(v2) n.ss = n.ss[:l] rvn = reflect.ValueOf(v2).Elem() if reflectArrayOfSupported && d.stid == 0 && d.h.PreferArrayOverSlice { rvn = reflectArrayOf(rvn) } } else { rvn = reflect.New(d.h.SliceType).Elem() d.decodeValue(rvn, nil) } case valueTypeExt: 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] d.decode(v2) v = *v2 n.is = n.is[:l] } bfn := d.h.getExtForTag(tag) if bfn == nil { 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 bytes != nil { bfn.ext.ReadExt(rvnA.Interface(), bytes) } else { bfn.ext.UpdateExt(rvnA.Interface(), 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 } func (f *decFnInfo) kInterface(rv reflect.Value) { // debugf("\t===> kInterface") // Note: // A consequence of how kInterface works, is that // if an interface already contains something, we try // to decode into what was there before. // We do not replace with a generic value (as got from decodeNaked). var rvn reflect.Value if rv.IsNil() { rvn = f.kInterfaceNaked() if rvn.IsValid() { rv.Set(rvn) } } else if f.d.h.InterfaceReset { rvn = f.kInterfaceNaked() if rvn.IsValid() { rv.Set(rvn) } else { // reset to zero value based on current type in there. rv.Set(reflect.Zero(rv.Elem().Type())) } } else { rvn = rv.Elem() // Note: interface{} is settable, but underlying type may not be. // Consequently, we have to set the reflect.Value directly. // if underlying type is settable (e.g. ptr or interface), // we just decode into it. // Else we create a settable value, decode into it, and set on the interface. if rvn.CanSet() { f.d.decodeValue(rvn, nil) } else { rvn2 := reflect.New(rvn.Type()).Elem() rvn2.Set(rvn) f.d.decodeValue(rvn2, nil) rv.Set(rvn2) } } } func (f *decFnInfo) kStruct(rv reflect.Value) { fti := f.ti d := f.d dd := d.d cr := d.cr ctyp := dd.ContainerType() if ctyp == valueTypeMap { containerLen := dd.ReadMapStart() if containerLen == 0 { if cr != nil { cr.sendContainerState(containerMapEnd) } return } tisfi := fti.sfi hasLen := containerLen >= 0 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() { si.setToZeroValue(rv) } else { d.decodeValue(si.field(rv, true), nil) } } else { d.structFieldNotFound(-1, rvkencname) } } } 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() { si.setToZeroValue(rv) } else { d.decodeValue(si.field(rv, true), nil) } } else { d.structFieldNotFound(-1, rvkencname) } } } if cr != nil { cr.sendContainerState(containerMapEnd) } } else if ctyp == valueTypeArray { containerLen := dd.ReadArrayStart() if containerLen == 0 { if cr != nil { cr.sendContainerState(containerArrayEnd) } return } // Not much gain from doing it two ways for array. // Arrays are not used as much for structs. hasLen := containerLen >= 0 for j, si := range fti.sfip { if hasLen { if j == containerLen { break } } else if dd.CheckBreak() { break } if cr != nil { cr.sendContainerState(containerArrayElem) } if dd.TryDecodeAsNil() { si.setToZeroValue(rv) } else { d.decodeValue(si.field(rv, true), nil) } } 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, "") } } if cr != nil { cr.sendContainerState(containerArrayEnd) } } else { f.d.error(onlyMapOrArrayCanDecodeIntoStructErr) return } } func (f *decFnInfo) kSlice(rv reflect.Value) { // A slice can be set from a map or array in stream. // This way, the order can be kept (as order is lost with map). ti := f.ti d := f.d dd := d.d rtelem0 := ti.rt.Elem() 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 } // array := f.seq == seqTypeChan 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 { 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)) } } slh.End() return } rtelem := rtelem0 for rtelem.Kind() == reflect.Ptr { rtelem = rtelem.Elem() } fn := d.getDecFn(rtelem, true, true) var rv0, rv9 reflect.Value rv0 = rv rvChanged := false // for j := 0; j < containerLenS; j++ { 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())) 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) } rvcap = rvlen } numToRead = rvlen } else if containerLenS != rvlen { if f.seq == seqTypeSlice { rv.SetLen(containerLenS) rvlen = containerLenS } } j := 0 // we read up to the numToRead for ; j < numToRead; j++ { slh.ElemContainerState(j) d.decodeValue(rv.Index(j), fn) } // if slice, expand and read up to containerLenS (or EOF) iff truncated // if array, swallow all the rest. 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 for ; j < containerLenS; j++ { rv = expandSliceValue(rv, 1) rv9 = rv.Index(j) if resetSliceElemToZeroValue { rv9.Set(reflect.Zero(rtelem0)) } slh.ElemContainerState(j) d.decodeValue(rv9, fn) } } } } else { 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 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() if rvChanged { rv0.Set(rv) } } func (f *decFnInfo) kArray(rv reflect.Value) { // f.d.decodeValue(rv.Slice(0, rv.Len())) f.kSlice(rv.Slice(0, rv.Len())) } 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 { 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() { } keyFn = d.getDecFn(xtyp, true, true) for xtyp = vtype; xtyp.Kind() == reflect.Ptr; xtyp = xtyp.Elem() { } valFn = d.getDecFn(xtyp, true, true) 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 if vtypeKind == reflect.Ptr { mapGet = true } else if vtypeKind == reflect.Interface { if !f.d.h.InterfaceReset { mapGet = true } } else if !isImmutableKind(vtypeKind) { mapGet = true } } 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. if ktypeId == intfTypId { rvk = rvk.Elem() if rvk.Type() == uint8SliceTyp { 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() { if vtypeKind == reflect.Ptr { mapSet = false } } else { if rvz.IsValid() { rvz.Set(reflect.Zero(vtype)) } else { rvz = reflect.New(vtype).Elem() } rvv = rvz } } else { 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) 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. if ktypeId == intfTypId { rvk = rvk.Elem() if rvk.Type() == uint8SliceTyp { 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() { if vtypeKind == reflect.Ptr { mapSet = false } } else { if rvz.IsValid() { rvz.Set(reflect.Zero(vtype)) } else { rvz = reflect.New(vtype).Elem() } rvv = rvz } } else { 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) if mapSet { rv.SetMapIndex(rvk, rvv) } } } if cr != nil { cr.sendContainerState(containerMapEnd) } } type decRtidFn struct { rtid uintptr 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 accommodate 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. // Try to put things that go together to fit within a cache line (8 words). d decDriver // NOTE: Decoder shouldn't call it's read methods, // as the handler MAY need to do some coordination. r decReader // sa [initCollectionCap]decRtidFn h *BasicHandle hh Handle be bool // is binary encoding bytes bool // is bytes reader js bool // is json handle rb bytesDecReader ri ioDecReader cr containerStateRecv s []decRtidFn f map[uintptr]*decFn // _ uintptr // for alignment purposes, so next one starts from a cache line // 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) *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) if !ok { d.ri.br = &d.ri.bs } d.r = &d.ri d.resetCommon() } func (d *Decoder) ResetBytes(in []byte) { // d.s = d.sa[:0] d.bytes = true d.rb.reset(in) d.r = &d.rb 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. // // Note that a pointer to a nil interface is not a nil pointer. // If you do not know what type of stream it is, pass in a pointer to a nil interface. // We will decode and store a value in that nil interface. // // Sample usages: // // Decoding into a non-nil typed value // var f float32 // err = codec.NewDecoder(r, handle).Decode(&f) // // // Decoding into nil interface // var v interface{} // dec := codec.NewDecoder(r, handle) // err = dec.Decode(&v) // // When decoding into a nil interface{}, we will decode into an appropriate value based // on the contents of the stream: // - Numbers are decoded as float64, int64 or uint64. // - Other values are decoded appropriately depending on the type: // bool, string, []byte, time.Time, etc // - Extensions are decoded as RawExt (if no ext function registered for the tag) // Configurations exist on the Handle to override defaults // (e.g. for MapType, SliceType and how to decode raw bytes). // // When decoding into a non-nil interface{} value, the mode of encoding is based on the // type of the value. When a value is seen: // - If an extension is registered for it, call that extension function // - If it implements BinaryUnmarshaler, call its UnmarshalBinary(data []byte) error // - Else decode it based on its reflect.Kind // // There are some special rules when decoding into containers (slice/array/map/struct). // Decode will typically use the stream contents to UPDATE the container. // - A map can be decoded from a stream map, by updating matching keys. // - A slice can be decoded from a stream array, // by updating the first n elements, where n is length of the stream. // - A slice can be decoded from a stream map, by decoding as if // it contains a sequence of key-value pairs. // - A struct can be decoded from a stream map, by updating matching fields. // - A struct can be decoded from a stream array, // by updating fields as they occur in the struct (by index). // // When decoding a stream map or array with length of 0 into a nil map or slice, // we reset the destination map or slice to a zero-length value. // // However, when decoding a stream nil, we reset the destination container // to its "zero" value (e.g. nil for slice/map, etc). // func (d *Decoder) Decode(v interface{}) (err error) { defer panicToErr(&err) d.decode(v) return } // this is not a smart swallow, as it allocates objects and does unnecessary work. func (d *Decoder) swallowViaHammer() { var blank interface{} d.decodeValue(reflect.ValueOf(&blank).Elem(), nil) } func (d *Decoder) swallow() { // smarter decode that just swallows the content dd := d.d if dd.TryDecodeAsNil() { return } cr := d.cr switch dd.ContainerType() { case valueTypeMap: containerLen := dd.ReadMapStart() clenGtEqualZero := containerLen >= 0 for j := 0; ; j++ { if clenGtEqualZero { if j >= containerLen { break } } else if dd.CheckBreak() { break } if cr != nil { cr.sendContainerState(containerMapKey) } d.swallow() if cr != nil { cr.sendContainerState(containerMapValue) } d.swallow() } if cr != nil { cr.sendContainerState(containerMapEnd) } case valueTypeArray: containerLenS := dd.ReadArrayStart() clenGtEqualZero := containerLenS >= 0 for j := 0; ; j++ { if clenGtEqualZero { if j >= containerLenS { break } } else if dd.CheckBreak() { break } if cr != nil { cr.sendContainerState(containerArrayElem) } d.swallow() } if cr != nil { cr.sendContainerState(containerArrayEnd) } case valueTypeBytes: dd.DecodeBytes(d.b[:], false, true) 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] d.decode(v2) n.is = n.is[:l] } } } // MustDecode is like Decode, but panics if unable to Decode. // This provides insight to the code location that triggered the error. func (d *Decoder) MustDecode(v interface{}) { d.decode(v) } func (d *Decoder) decode(iv interface{}) { // if ics, ok := iv.(Selfer); ok { // ics.CodecDecodeSelf(d) // return // } if d.d.TryDecodeAsNil() { switch v := iv.(type) { case nil: case *string: *v = "" case *bool: *v = false case *int: *v = 0 case *int8: *v = 0 case *int16: *v = 0 case *int32: *v = 0 case *int64: *v = 0 case *uint: *v = 0 case *uint8: *v = 0 case *uint16: *v = 0 case *uint32: *v = 0 case *uint64: *v = 0 case *float32: *v = 0 case *float64: *v = 0 case *[]uint8: *v = nil case *Raw: *v = nil case reflect.Value: 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) 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())) } } return } switch v := iv.(type) { case nil: d.error(cannotDecodeIntoNilErr) return case Selfer: v.CodecDecodeSelf(d) case reflect.Value: if v.Kind() != reflect.Ptr || v.IsNil() { d.errNotValidPtrValue(v) } // d.chkPtrValue(v) d.decodeValueNotNil(v.Elem(), nil) case *string: *v = d.d.DecodeString() case *bool: *v = d.d.DecodeBool() case *int: *v = int(d.d.DecodeInt(intBitsize)) case *int8: *v = int8(d.d.DecodeInt(8)) case *int16: *v = int16(d.d.DecodeInt(16)) case *int32: *v = int32(d.d.DecodeInt(32)) case *int64: *v = d.d.DecodeInt(64) case *uint: *v = uint(d.d.DecodeUint(uintBitsize)) case *uint8: *v = uint8(d.d.DecodeUint(8)) case *uint16: *v = uint16(d.d.DecodeUint(16)) case *uint32: *v = uint32(d.d.DecodeUint(32)) case *uint64: *v = d.d.DecodeUint(64) case *float32: *v = float32(d.d.DecodeFloat(true)) case *float64: *v = d.d.DecodeFloat(false) case *[]uint8: *v = d.d.DecodeBytes(*v, false, false) case *Raw: *v = d.raw() case *interface{}: d.decodeValueNotNil(reflect.ValueOf(iv).Elem(), nil) default: if !fastpathDecodeTypeSwitch(iv, d) { d.decodeI(iv, true, false, false, false) } } } func (d *Decoder) preDecodeValue(rv reflect.Value, tryNil bool) (rv2 reflect.Value, proceed bool) { if tryNil && d.d.TryDecodeAsNil() { // No need to check if a ptr, recursively, to determine // whether to set value to nil. // Just always set value to its zero type. if rv.IsValid() { // rv.CanSet() // always settable, except it's invalid rv.Set(reflect.Zero(rv.Type())) } return } // If stream is not containing a nil value, then we can deref to the base // non-pointer value, and decode into that. for rv.Kind() == reflect.Ptr { if rv.IsNil() { rv.Set(reflect.New(rv.Type().Elem())) } rv = rv.Elem() } return rv, true } func (d *Decoder) decodeI(iv interface{}, checkPtr, tryNil, checkFastpath, checkCodecSelfer bool) { rv := reflect.ValueOf(iv) if checkPtr { if rv.Kind() != reflect.Ptr || rv.IsNil() { d.errNotValidPtrValue(rv) } // d.chkPtrValue(rv) } rv, proceed := d.preDecodeValue(rv, tryNil) if proceed { fn := d.getDecFn(rv.Type(), checkFastpath, checkCodecSelfer) fn.f(&fn.i, rv) } } func (d *Decoder) decodeValue(rv reflect.Value, fn *decFn) { if rv, proceed := d.preDecodeValue(rv, true); proceed { if fn == nil { fn = d.getDecFn(rv.Type(), true, true) } fn.f(&fn.i, rv) } } func (d *Decoder) decodeValueNotNil(rv reflect.Value, fn *decFn) { if rv, proceed := d.preDecodeValue(rv, false); proceed { if fn == nil { fn = d.getDecFn(rv.Type(), true, true) } fn.f(&fn.i, rv) } } func (d *Decoder) getDecFn(rt reflect.Type, checkFastpath, checkCodecSelfer bool) (fn *decFn) { rtid := reflect.ValueOf(rt).Pointer() // retrieve or register a focus'ed function for this type // to eliminate need to do the retrieval multiple times // if d.f == nil && d.s == nil { debugf("---->Creating new dec f map for type: %v\n", rt) } var ok bool if useMapForCodecCache { fn, ok = d.f[rtid] } else { for i := range d.s { v := &(d.s[i]) if v.rtid == rtid { fn, ok = &(v.fn), true break } } } if ok { return } if useMapForCodecCache { if d.f == nil { d.f = make(map[uintptr]*decFn, initCollectionCap) } fn = new(decFn) d.f[rtid] = fn } else { if d.s == nil { d.s = make([]decRtidFn, 0, initCollectionCap) } d.s = append(d.s, decRtidFn{rtid: rtid}) fn = &(d.s[len(d.s)-1]).fn } // debugf("\tCreating new dec fn for type: %v\n", rt) ti := d.h.getTypeInfo(rtid, rt) fi := &(fn.i) fi.d = d fi.ti = ti // An extension can be registered for any type, regardless of the Kind // (e.g. type BitSet int64, type MyStruct { / * unexported fields * / }, type X []int, etc. // // We can't check if it's an extension byte here first, because the user may have // registered a pointer or non-pointer type, meaning we may have to recurse first // before matching a mapped type, even though the extension byte is already detected. // // NOTE: if decoding into a nil interface{}, we return a non-nil // value except even if the container registers a length of 0. if checkCodecSelfer && ti.cs { fn.f = (*decFnInfo).selferUnmarshal } else if rtid == rawExtTypId { fn.f = (*decFnInfo).rawExt } else if rtid == rawTypId { fn.f = (*decFnInfo).raw } else if d.d.IsBuiltinType(rtid) { fn.f = (*decFnInfo).builtin } else if xfFn := d.h.getExt(rtid); xfFn != nil { fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext fn.f = (*decFnInfo).ext } else if supportMarshalInterfaces && d.be && ti.bunm { fn.f = (*decFnInfo).binaryUnmarshal } else if supportMarshalInterfaces && !d.be && d.js && ti.junm { //If JSON, we should check JSONUnmarshal before textUnmarshal fn.f = (*decFnInfo).jsonUnmarshal } else if supportMarshalInterfaces && !d.be && ti.tunm { fn.f = (*decFnInfo).textUnmarshal } else { rk := rt.Kind() if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) { if rt.PkgPath() == "" { if idx := fastpathAV.index(rtid); idx != -1 { fn.f = fastpathAV[idx].decfn } } else { // use mapping for underlying type if there ok = false var rtu reflect.Type if rk == reflect.Map { rtu = reflect.MapOf(rt.Key(), rt.Elem()) } else { rtu = reflect.SliceOf(rt.Elem()) } rtuid := reflect.ValueOf(rtu).Pointer() if idx := fastpathAV.index(rtuid); idx != -1 { xfnf := fastpathAV[idx].decfn xrt := fastpathAV[idx].rt fn.f = func(xf *decFnInfo, xrv reflect.Value) { // xfnf(xf, xrv.Convert(xrt)) xfnf(xf, xrv.Addr().Convert(reflect.PtrTo(xrt)).Elem()) } } } } if fn.f == nil { switch rk { case reflect.String: fn.f = (*decFnInfo).kString case reflect.Bool: fn.f = (*decFnInfo).kBool case reflect.Int: fn.f = (*decFnInfo).kInt case reflect.Int64: fn.f = (*decFnInfo).kInt64 case reflect.Int32: fn.f = (*decFnInfo).kInt32 case reflect.Int8: fn.f = (*decFnInfo).kInt8 case reflect.Int16: fn.f = (*decFnInfo).kInt16 case reflect.Float32: fn.f = (*decFnInfo).kFloat32 case reflect.Float64: fn.f = (*decFnInfo).kFloat64 case reflect.Uint8: fn.f = (*decFnInfo).kUint8 case reflect.Uint64: fn.f = (*decFnInfo).kUint64 case reflect.Uint: fn.f = (*decFnInfo).kUint case reflect.Uint32: fn.f = (*decFnInfo).kUint32 case reflect.Uint16: fn.f = (*decFnInfo).kUint16 // case reflect.Ptr: // fn.f = (*decFnInfo).kPtr case reflect.Uintptr: fn.f = (*decFnInfo).kUintptr case reflect.Interface: fn.f = (*decFnInfo).kInterface case reflect.Struct: fn.f = (*decFnInfo).kStruct case reflect.Chan: fi.seq = seqTypeChan fn.f = (*decFnInfo).kSlice case reflect.Slice: fi.seq = seqTypeSlice fn.f = (*decFnInfo).kSlice case reflect.Array: fi.seq = seqTypeArray fn.f = (*decFnInfo).kArray case reflect.Map: fn.f = (*decFnInfo).kMap default: fn.f = (*decFnInfo).kErr } } } return } func (d *Decoder) structFieldNotFound(index int, rvkencname string) { // NOTE: rvkencname may be a stringView, so don't pass it to another function. if d.h.ErrorIfNoField { if index >= 0 { d.errorf("no matching struct field found when decoding stream array at index %v", index) return } else if rvkencname != "" { d.errorf("no matching struct field found when decoding stream map with key " + rvkencname) return } } d.swallow() } func (d *Decoder) arrayCannotExpand(sliceLen, streamLen int) { if d.h.ErrorIfNoArrayExpand { d.errorf("cannot expand array len during decode from %v to %v", sliceLen, streamLen) } } func (d *Decoder) chkPtrValue(rv reflect.Value) { // We can only decode into a non-nil pointer 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 } if !rv.CanInterface() { d.errorf("cannot decode into a value without an interface: %v", rv) return } rvi := rv.Interface() d.errorf("cannot decode into non-pointer or nil pointer. Got: %v, %T, %v", rv.Kind(), rvi, rvi) } func (d *Decoder) error(err error) { panic(err) } func (d *Decoder) errorf(format string, params ...interface{}) { params2 := make([]interface{}, len(params)+1) params2[0] = d.r.numread() copy(params2[1:], params) err := fmt.Errorf("[pos %d]: "+format, params2...) panic(err) } func (d *Decoder) string(v []byte) (s string) { if d.is != nil { s, ok := d.is[string(v)] // no allocation here. if !ok { s = string(v) d.is[s] = s } return s } return string(v) // don't return stringView, as we need a real string here. } func (d *Decoder) intern(s string) { if d.is != nil { d.is[s] = s } } // nextValueBytes returns the next value in the stream as a set of bytes. func (d *Decoder) nextValueBytes() []byte { d.d.uncacheRead() d.r.track() d.swallow() return d.r.stopTrack() } func (d *Decoder) raw() []byte { // ensure that this is not a view into the bytes // i.e. make new copy always. bs := d.nextValueBytes() bs2 := make([]byte, len(bs)) copy(bs2, bs) return bs2 } // -------------------------------------------------- // 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 { d *Decoder // ct valueType array bool } func (d *Decoder) decSliceHelperStart() (x decSliceHelper, clen int) { 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)", ctyp) } // x.ct = ctyp x.d = d return } func (x decSliceHelper) End() { 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, maxInitLen int, bs []byte) (bsOut []byte) { if clen == 0 { return zeroByteSlice } if len(bs) == clen { bsOut = bs r.readb(bsOut) } else if cap(bs) >= clen { bsOut = bs[:clen] r.readb(bsOut) } else { // bsOut = make([]byte, clen) len2, _ := decInferLen(clen, maxInitLen, 1) bsOut = make([]byte, len2) r.readb(bsOut) for len2 < clen { len3, _ := decInferLen(clen-len2, maxInitLen, 1) // fmt.Printf(">>>>> TESTING: in loop: clen: %v, maxInitLen: %v, len2: %v, len3: %v\n", clen, maxInitLen, len2, len3) bs3 := bsOut bsOut = make([]byte, len2+len3) copy(bsOut, bs3) r.readb(bsOut[len2:]) len2 += len3 } } return } func detachZeroCopyBytes(isBytesReader bool, dest []byte, in []byte) (out []byte) { if xlen := len(in); xlen > 0 { if isBytesReader || xlen <= scratchByteArrayLen { if cap(dest) >= xlen { out = dest[:xlen] } else { out = make([]byte, xlen) } copy(out, in) return } } return in } // decInferLen will infer a sensible length, given the following: // - clen: length wanted. // - maxlen: max length to be returned. // if <= 0, it is unset, and we infer it based on the unit size // - unit: number of bytes for each element of the collection func decInferLen(clen, maxlen, unit int) (rvlen int, truncated bool) { // handle when maxlen is not set i.e. <= 0 if clen <= 0 { return } if maxlen <= 0 { // no maxlen defined. Use maximum of 256K memory, with a floor of 4K items. // maxlen = 256 * 1024 / unit // if maxlen < (4 * 1024) { // maxlen = 4 * 1024 // } if unit < (256 / 4) { maxlen = 256 * 1024 / unit } else { maxlen = 4 * 1024 } } if clen > maxlen { rvlen = maxlen truncated = true } else { rvlen = clen } return // if clen <= 0 { // rvlen = 0 // } else if maxlen > 0 && clen > maxlen { // rvlen = maxlen // truncated = true // } else { // rvlen = clen // } // return } // // implement overall decReader wrapping both, for possible use inline: // type decReaderT struct { // bytes bool // rb *bytesDecReader // ri *ioDecReader // } // // // implement *Decoder as a decReader. // // Using decReaderT (defined just above) caused performance degradation // // possibly because of constant copying the value, // // and some value->interface conversion causing allocation. // func (d *Decoder) unreadn1() { // if d.bytes { // d.rb.unreadn1() // } else { // d.ri.unreadn1() // } // } // ... for other methods of decReader. // Testing showed that performance improvement was negligible.