You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by cc...@apache.org on 2017/04/06 02:27:48 UTC
[43/54] [partial] incubator-mynewt-newtmgr git commit: revendor
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newtmgr/blob/9975ef7a/newtmgr/vendor/github.com/ugorji/go/codec/decode.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/ugorji/go/codec/decode.go b/newtmgr/vendor/github.com/ugorji/go/codec/decode.go
deleted file mode 100644
index e30e8e8..0000000
--- a/newtmgr/vendor/github.com/ugorji/go/codec/decode.go
+++ /dev/null
@@ -1,2066 +0,0 @@
-// 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.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.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newtmgr/blob/9975ef7a/newtmgr/vendor/github.com/ugorji/go/codec/decode_go.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/ugorji/go/codec/decode_go.go b/newtmgr/vendor/github.com/ugorji/go/codec/decode_go.go
deleted file mode 100644
index ba289ce..0000000
--- a/newtmgr/vendor/github.com/ugorji/go/codec/decode_go.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// 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.
-
-// +build go1.5
-
-package codec
-
-import "reflect"
-
-const reflectArrayOfSupported = true
-
-func reflectArrayOf(rvn reflect.Value) (rvn2 reflect.Value) {
- rvn2 = reflect.New(reflect.ArrayOf(rvn.Len(), intfTyp)).Elem()
- reflect.Copy(rvn2, rvn)
- return
-}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newtmgr/blob/9975ef7a/newtmgr/vendor/github.com/ugorji/go/codec/decode_go14.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/ugorji/go/codec/decode_go14.go b/newtmgr/vendor/github.com/ugorji/go/codec/decode_go14.go
deleted file mode 100644
index 50063bc..0000000
--- a/newtmgr/vendor/github.com/ugorji/go/codec/decode_go14.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// 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.
-
-// +build !go1.5
-
-package codec
-
-import "reflect"
-
-const reflectArrayOfSupported = false
-
-func reflectArrayOf(rvn reflect.Value) (rvn2 reflect.Value) {
- panic("reflect.ArrayOf unsupported")
-}