decode.go 27 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048
  1. // Copyright (c) 2012, 2013 Ugorji Nwoke. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license found in the LICENSE file.
  3. package codec
  4. import (
  5. "io"
  6. "reflect"
  7. // "runtime/debug"
  8. )
  9. // Some tagging information for error messages.
  10. const (
  11. msgTagDec = "codec.decoder"
  12. msgBadDesc = "Unrecognized descriptor byte"
  13. msgDecCannotExpandArr = "cannot expand go array from %v to stream length: %v"
  14. )
  15. // decReader abstracts the reading source, allowing implementations that can
  16. // read from an io.Reader or directly off a byte slice with zero-copying.
  17. type decReader interface {
  18. readn(n int) []byte
  19. readb([]byte)
  20. readn1() uint8
  21. readUint16() uint16
  22. readUint32() uint32
  23. readUint64() uint64
  24. }
  25. type decDriver interface {
  26. initReadNext()
  27. tryDecodeAsNil() bool
  28. currentEncodedType() valueType
  29. isBuiltinType(rt uintptr) bool
  30. decodeBuiltin(rt uintptr, v interface{})
  31. //decodeNaked: Numbers are decoded as int64, uint64, float64 only (no smaller sized number types).
  32. decodeNaked() (v interface{}, vt valueType, decodeFurther bool)
  33. decodeInt(bitsize uint8) (i int64)
  34. decodeUint(bitsize uint8) (ui uint64)
  35. decodeFloat(chkOverflow32 bool) (f float64)
  36. decodeBool() (b bool)
  37. // decodeString can also decode symbols
  38. decodeString() (s string)
  39. decodeBytes(bs []byte) (bsOut []byte, changed bool)
  40. decodeExt(verifyTag bool, tag byte) (xtag byte, xbs []byte)
  41. readMapLen() int
  42. readArrayLen() int
  43. }
  44. type DecodeOptions struct {
  45. // An instance of MapType is used during schema-less decoding of a map in the stream.
  46. // If nil, we use map[interface{}]interface{}
  47. MapType reflect.Type
  48. // An instance of SliceType is used during schema-less decoding of an array in the stream.
  49. // If nil, we use []interface{}
  50. SliceType reflect.Type
  51. // ErrorIfNoField controls whether an error is returned when decoding a map
  52. // from a codec stream into a struct, and no matching struct field is found.
  53. ErrorIfNoField bool
  54. }
  55. // ------------------------------------
  56. // ioDecReader is a decReader that reads off an io.Reader
  57. type ioDecReader struct {
  58. r io.Reader
  59. br io.ByteReader
  60. x [8]byte //temp byte array re-used internally for efficiency
  61. }
  62. func (z *ioDecReader) readn(n int) (bs []byte) {
  63. if n <= 0 {
  64. return
  65. }
  66. bs = make([]byte, n)
  67. if _, err := io.ReadAtLeast(z.r, bs, n); err != nil {
  68. panic(err)
  69. }
  70. return
  71. }
  72. func (z *ioDecReader) readb(bs []byte) {
  73. if _, err := io.ReadAtLeast(z.r, bs, len(bs)); err != nil {
  74. panic(err)
  75. }
  76. }
  77. func (z *ioDecReader) readn1() uint8 {
  78. if z.br != nil {
  79. b, err := z.br.ReadByte()
  80. if err != nil {
  81. panic(err)
  82. }
  83. return b
  84. }
  85. z.readb(z.x[:1])
  86. return z.x[0]
  87. }
  88. func (z *ioDecReader) readUint16() uint16 {
  89. z.readb(z.x[:2])
  90. return bigen.Uint16(z.x[:2])
  91. }
  92. func (z *ioDecReader) readUint32() uint32 {
  93. z.readb(z.x[:4])
  94. return bigen.Uint32(z.x[:4])
  95. }
  96. func (z *ioDecReader) readUint64() uint64 {
  97. z.readb(z.x[:8])
  98. return bigen.Uint64(z.x[:8])
  99. }
  100. // ------------------------------------
  101. // bytesDecReader is a decReader that reads off a byte slice with zero copying
  102. type bytesDecReader struct {
  103. b []byte // data
  104. c int // cursor
  105. a int // available
  106. }
  107. func (z *bytesDecReader) consume(n int) (oldcursor int) {
  108. if z.a == 0 {
  109. panic(io.EOF)
  110. }
  111. if n > z.a {
  112. decErr("Trying to read %v bytes. Only %v available", n, z.a)
  113. }
  114. // z.checkAvailable(n)
  115. oldcursor = z.c
  116. z.c = oldcursor + n
  117. z.a = z.a - n
  118. return
  119. }
  120. func (z *bytesDecReader) readn(n int) (bs []byte) {
  121. if n <= 0 {
  122. return
  123. }
  124. c0 := z.consume(n)
  125. bs = z.b[c0:z.c]
  126. return
  127. }
  128. func (z *bytesDecReader) readb(bs []byte) {
  129. copy(bs, z.readn(len(bs)))
  130. }
  131. func (z *bytesDecReader) readn1() uint8 {
  132. c0 := z.consume(1)
  133. return z.b[c0]
  134. }
  135. // Use binaryEncoding helper for 4 and 8 bits, but inline it for 2 bits
  136. // creating temp slice variable and copying it to helper function is expensive
  137. // for just 2 bits.
  138. func (z *bytesDecReader) readUint16() uint16 {
  139. c0 := z.consume(2)
  140. return uint16(z.b[c0+1]) | uint16(z.b[c0])<<8
  141. }
  142. func (z *bytesDecReader) readUint32() uint32 {
  143. c0 := z.consume(4)
  144. return bigen.Uint32(z.b[c0:z.c])
  145. }
  146. func (z *bytesDecReader) readUint64() uint64 {
  147. c0 := z.consume(8)
  148. return bigen.Uint64(z.b[c0:z.c])
  149. }
  150. // ------------------------------------
  151. // decFnInfo has methods for registering handling decoding of a specific type
  152. // based on some characteristics (builtin, extension, reflect Kind, etc)
  153. type decFnInfo struct {
  154. ti *typeInfo
  155. d *Decoder
  156. dd decDriver
  157. xfFn func(reflect.Value, []byte) error
  158. xfTag byte
  159. array bool
  160. }
  161. func (f *decFnInfo) builtin(rv reflect.Value) {
  162. f.dd.decodeBuiltin(f.ti.rtid, rv.Addr().Interface())
  163. }
  164. func (f *decFnInfo) rawExt(rv reflect.Value) {
  165. xtag, xbs := f.dd.decodeExt(false, 0)
  166. rv.Field(0).SetUint(uint64(xtag))
  167. rv.Field(1).SetBytes(xbs)
  168. }
  169. func (f *decFnInfo) ext(rv reflect.Value) {
  170. _, xbs := f.dd.decodeExt(true, f.xfTag)
  171. if fnerr := f.xfFn(rv, xbs); fnerr != nil {
  172. panic(fnerr)
  173. }
  174. }
  175. func (f *decFnInfo) binaryMarshal(rv reflect.Value) {
  176. var bm binaryUnmarshaler
  177. if f.ti.unmIndir == -1 {
  178. bm = rv.Addr().Interface().(binaryUnmarshaler)
  179. } else if f.ti.unmIndir == 0 {
  180. bm = rv.Interface().(binaryUnmarshaler)
  181. } else {
  182. for j, k := int8(0), f.ti.unmIndir; j < k; j++ {
  183. if rv.IsNil() {
  184. rv.Set(reflect.New(rv.Type().Elem()))
  185. }
  186. rv = rv.Elem()
  187. }
  188. bm = rv.Interface().(binaryUnmarshaler)
  189. }
  190. xbs, _ := f.dd.decodeBytes(nil)
  191. if fnerr := bm.UnmarshalBinary(xbs); fnerr != nil {
  192. panic(fnerr)
  193. }
  194. }
  195. func (f *decFnInfo) kErr(rv reflect.Value) {
  196. decErr("Unhandled value for kind: %v: %s", rv.Kind(), msgBadDesc)
  197. }
  198. func (f *decFnInfo) kString(rv reflect.Value) {
  199. rv.SetString(f.dd.decodeString())
  200. }
  201. func (f *decFnInfo) kBool(rv reflect.Value) {
  202. rv.SetBool(f.dd.decodeBool())
  203. }
  204. func (f *decFnInfo) kInt(rv reflect.Value) {
  205. rv.SetInt(f.dd.decodeInt(intBitsize))
  206. }
  207. func (f *decFnInfo) kInt64(rv reflect.Value) {
  208. rv.SetInt(f.dd.decodeInt(64))
  209. }
  210. func (f *decFnInfo) kInt32(rv reflect.Value) {
  211. rv.SetInt(f.dd.decodeInt(32))
  212. }
  213. func (f *decFnInfo) kInt8(rv reflect.Value) {
  214. rv.SetInt(f.dd.decodeInt(8))
  215. }
  216. func (f *decFnInfo) kInt16(rv reflect.Value) {
  217. rv.SetInt(f.dd.decodeInt(16))
  218. }
  219. func (f *decFnInfo) kFloat32(rv reflect.Value) {
  220. rv.SetFloat(f.dd.decodeFloat(true))
  221. }
  222. func (f *decFnInfo) kFloat64(rv reflect.Value) {
  223. rv.SetFloat(f.dd.decodeFloat(false))
  224. }
  225. func (f *decFnInfo) kUint8(rv reflect.Value) {
  226. rv.SetUint(f.dd.decodeUint(8))
  227. }
  228. func (f *decFnInfo) kUint64(rv reflect.Value) {
  229. rv.SetUint(f.dd.decodeUint(64))
  230. }
  231. func (f *decFnInfo) kUint(rv reflect.Value) {
  232. rv.SetUint(f.dd.decodeUint(uintBitsize))
  233. }
  234. func (f *decFnInfo) kUint32(rv reflect.Value) {
  235. rv.SetUint(f.dd.decodeUint(32))
  236. }
  237. func (f *decFnInfo) kUint16(rv reflect.Value) {
  238. rv.SetUint(f.dd.decodeUint(16))
  239. }
  240. // func (f *decFnInfo) kPtr(rv reflect.Value) {
  241. // debugf(">>>>>>> ??? decode kPtr called - shouldn't get called")
  242. // if rv.IsNil() {
  243. // rv.Set(reflect.New(rv.Type().Elem()))
  244. // }
  245. // f.d.decodeValue(rv.Elem())
  246. // }
  247. func (f *decFnInfo) kInterface(rv reflect.Value) {
  248. // debugf("\t===> kInterface")
  249. if !rv.IsNil() {
  250. f.d.decodeValue(rv.Elem())
  251. return
  252. }
  253. // nil interface:
  254. // use some hieristics to set the nil interface to an
  255. // appropriate value based on the first byte read (byte descriptor bd)
  256. v, vt, decodeFurther := f.dd.decodeNaked()
  257. if vt == valueTypeNil {
  258. return
  259. }
  260. // Cannot decode into nil interface with methods (e.g. error, io.Reader, etc)
  261. // if non-nil value in stream.
  262. if num := f.ti.rt.NumMethod(); num > 0 {
  263. decErr("decodeValue: Cannot decode non-nil codec value into nil %v (%v methods)",
  264. f.ti.rt, num)
  265. }
  266. var rvn reflect.Value
  267. var useRvn bool
  268. switch vt {
  269. case valueTypeMap:
  270. if f.d.h.MapType == nil {
  271. var m2 map[interface{}]interface{}
  272. v = &m2
  273. } else {
  274. rvn = reflect.New(f.d.h.MapType).Elem()
  275. useRvn = true
  276. }
  277. case valueTypeArray:
  278. if f.d.h.SliceType == nil {
  279. var m2 []interface{}
  280. v = &m2
  281. } else {
  282. rvn = reflect.New(f.d.h.SliceType).Elem()
  283. useRvn = true
  284. }
  285. case valueTypeExt:
  286. re := v.(*RawExt)
  287. var bfn func(reflect.Value, []byte) error
  288. rvn, bfn = f.d.h.getDecodeExtForTag(re.Tag)
  289. if bfn == nil {
  290. rvn = reflect.ValueOf(*re)
  291. } else if fnerr := bfn(rvn, re.Data); fnerr != nil {
  292. panic(fnerr)
  293. }
  294. rv.Set(rvn)
  295. return
  296. }
  297. if decodeFurther {
  298. if useRvn {
  299. f.d.decodeValue(rvn)
  300. } else if v != nil {
  301. // this v is a pointer, so we need to dereference it when done
  302. f.d.decode(v)
  303. rvn = reflect.ValueOf(v).Elem()
  304. useRvn = true
  305. }
  306. }
  307. if useRvn {
  308. rv.Set(rvn)
  309. } else if v != nil {
  310. rv.Set(reflect.ValueOf(v))
  311. }
  312. }
  313. func (f *decFnInfo) kStruct(rv reflect.Value) {
  314. fti := f.ti
  315. if currEncodedType := f.dd.currentEncodedType(); currEncodedType == valueTypeMap {
  316. containerLen := f.dd.readMapLen()
  317. if containerLen == 0 {
  318. return
  319. }
  320. tisfi := fti.sfi
  321. for j := 0; j < containerLen; j++ {
  322. // var rvkencname string
  323. // ddecode(&rvkencname)
  324. f.dd.initReadNext()
  325. rvkencname := f.dd.decodeString()
  326. // rvksi := ti.getForEncName(rvkencname)
  327. if k := fti.indexForEncName(rvkencname); k > -1 {
  328. sfik := tisfi[k]
  329. if sfik.i != -1 {
  330. f.d.decodeValue(rv.Field(int(sfik.i)))
  331. } else {
  332. f.d.decEmbeddedField(rv, sfik.is)
  333. }
  334. // f.d.decodeValue(ti.field(k, rv))
  335. } else {
  336. if f.d.h.ErrorIfNoField {
  337. decErr("No matching struct field found when decoding stream map with key: %v",
  338. rvkencname)
  339. } else {
  340. var nilintf0 interface{}
  341. f.d.decodeValue(reflect.ValueOf(&nilintf0).Elem())
  342. }
  343. }
  344. }
  345. } else if currEncodedType == valueTypeArray {
  346. containerLen := f.dd.readArrayLen()
  347. if containerLen == 0 {
  348. return
  349. }
  350. for j, si := range fti.sfip {
  351. if j == containerLen {
  352. break
  353. }
  354. if si.i != -1 {
  355. f.d.decodeValue(rv.Field(int(si.i)))
  356. } else {
  357. f.d.decEmbeddedField(rv, si.is)
  358. }
  359. }
  360. if containerLen > len(fti.sfip) {
  361. // read remaining values and throw away
  362. for j := len(fti.sfip); j < containerLen; j++ {
  363. var nilintf0 interface{}
  364. f.d.decodeValue(reflect.ValueOf(&nilintf0).Elem())
  365. }
  366. }
  367. } else {
  368. decErr("Only encoded map or array can be decoded into a struct. (valueType: %x)",
  369. currEncodedType)
  370. }
  371. }
  372. func (f *decFnInfo) kSlice(rv reflect.Value) {
  373. // A slice can be set from a map or array in stream.
  374. currEncodedType := f.dd.currentEncodedType()
  375. switch currEncodedType {
  376. case valueTypeBytes, valueTypeString:
  377. if f.ti.rtid == uint8SliceTypId || f.ti.rt.Elem().Kind() == reflect.Uint8 {
  378. if bs2, changed2 := f.dd.decodeBytes(rv.Bytes()); changed2 {
  379. rv.SetBytes(bs2)
  380. }
  381. return
  382. }
  383. }
  384. if shortCircuitReflectToFastPath && rv.CanAddr() {
  385. switch f.ti.rtid {
  386. case intfSliceTypId:
  387. f.d.decSliceIntf(rv.Addr().Interface().(*[]interface{}), currEncodedType, f.array)
  388. return
  389. case uint64SliceTypId:
  390. f.d.decSliceUint64(rv.Addr().Interface().(*[]uint64), currEncodedType, f.array)
  391. return
  392. case int64SliceTypId:
  393. f.d.decSliceInt64(rv.Addr().Interface().(*[]int64), currEncodedType, f.array)
  394. return
  395. case strSliceTypId:
  396. f.d.decSliceStr(rv.Addr().Interface().(*[]string), currEncodedType, f.array)
  397. return
  398. }
  399. }
  400. containerLen, containerLenS := decContLens(f.dd, currEncodedType)
  401. // an array can never return a nil slice. so no need to check f.array here.
  402. if rv.IsNil() {
  403. rv.Set(reflect.MakeSlice(f.ti.rt, containerLenS, containerLenS))
  404. }
  405. if containerLen == 0 {
  406. return
  407. }
  408. if rvcap, rvlen := rv.Len(), rv.Cap(); containerLenS > rvcap {
  409. if f.array { // !rv.CanSet()
  410. decErr(msgDecCannotExpandArr, rvcap, containerLenS)
  411. }
  412. rvn := reflect.MakeSlice(f.ti.rt, containerLenS, containerLenS)
  413. if rvlen > 0 {
  414. reflect.Copy(rvn, rv)
  415. }
  416. rv.Set(rvn)
  417. } else if containerLenS > rvlen {
  418. rv.SetLen(containerLenS)
  419. }
  420. for j := 0; j < containerLenS; j++ {
  421. f.d.decodeValue(rv.Index(j))
  422. }
  423. }
  424. func (f *decFnInfo) kArray(rv reflect.Value) {
  425. // f.d.decodeValue(rv.Slice(0, rv.Len()))
  426. f.kSlice(rv.Slice(0, rv.Len()))
  427. }
  428. func (f *decFnInfo) kMap(rv reflect.Value) {
  429. if shortCircuitReflectToFastPath && rv.CanAddr() {
  430. switch f.ti.rtid {
  431. case mapStrIntfTypId:
  432. f.d.decMapStrIntf(rv.Addr().Interface().(*map[string]interface{}))
  433. return
  434. case mapIntfIntfTypId:
  435. f.d.decMapIntfIntf(rv.Addr().Interface().(*map[interface{}]interface{}))
  436. return
  437. case mapInt64IntfTypId:
  438. f.d.decMapInt64Intf(rv.Addr().Interface().(*map[int64]interface{}))
  439. return
  440. case mapUint64IntfTypId:
  441. f.d.decMapUint64Intf(rv.Addr().Interface().(*map[uint64]interface{}))
  442. return
  443. }
  444. }
  445. containerLen := f.dd.readMapLen()
  446. if rv.IsNil() {
  447. rv.Set(reflect.MakeMap(f.ti.rt))
  448. }
  449. if containerLen == 0 {
  450. return
  451. }
  452. ktype, vtype := f.ti.rt.Key(), f.ti.rt.Elem()
  453. ktypeId := reflect.ValueOf(ktype).Pointer()
  454. for j := 0; j < containerLen; j++ {
  455. rvk := reflect.New(ktype).Elem()
  456. f.d.decodeValue(rvk)
  457. // special case if a byte array.
  458. // if ktype == intfTyp {
  459. if ktypeId == intfTypId {
  460. rvk = rvk.Elem()
  461. if rvk.Type() == uint8SliceTyp {
  462. rvk = reflect.ValueOf(string(rvk.Bytes()))
  463. }
  464. }
  465. rvv := rv.MapIndex(rvk)
  466. if !rvv.IsValid() {
  467. rvv = reflect.New(vtype).Elem()
  468. }
  469. f.d.decodeValue(rvv)
  470. rv.SetMapIndex(rvk, rvv)
  471. }
  472. }
  473. // ----------------------------------------
  474. type decFn struct {
  475. i *decFnInfo
  476. f func(*decFnInfo, reflect.Value)
  477. }
  478. // A Decoder reads and decodes an object from an input stream in the codec format.
  479. type Decoder struct {
  480. r decReader
  481. d decDriver
  482. h *BasicHandle
  483. f map[uintptr]decFn
  484. x []uintptr
  485. s []decFn
  486. }
  487. // NewDecoder returns a Decoder for decoding a stream of bytes from an io.Reader.
  488. //
  489. // For efficiency, Users are encouraged to pass in a memory buffered writer
  490. // (eg bufio.Reader, bytes.Buffer).
  491. func NewDecoder(r io.Reader, h Handle) *Decoder {
  492. z := ioDecReader{
  493. r: r,
  494. }
  495. z.br, _ = r.(io.ByteReader)
  496. return &Decoder{r: &z, d: h.newDecDriver(&z), h: h.getBasicHandle()}
  497. }
  498. // NewDecoderBytes returns a Decoder which efficiently decodes directly
  499. // from a byte slice with zero copying.
  500. func NewDecoderBytes(in []byte, h Handle) *Decoder {
  501. z := bytesDecReader{
  502. b: in,
  503. a: len(in),
  504. }
  505. return &Decoder{r: &z, d: h.newDecDriver(&z), h: h.getBasicHandle()}
  506. }
  507. // Decode decodes the stream from reader and stores the result in the
  508. // value pointed to by v. v cannot be a nil pointer. v can also be
  509. // a reflect.Value of a pointer.
  510. //
  511. // Note that a pointer to a nil interface is not a nil pointer.
  512. // If you do not know what type of stream it is, pass in a pointer to a nil interface.
  513. // We will decode and store a value in that nil interface.
  514. //
  515. // Sample usages:
  516. // // Decoding into a non-nil typed value
  517. // var f float32
  518. // err = codec.NewDecoder(r, handle).Decode(&f)
  519. //
  520. // // Decoding into nil interface
  521. // var v interface{}
  522. // dec := codec.NewDecoder(r, handle)
  523. // err = dec.Decode(&v)
  524. //
  525. // When decoding into a nil interface{}, we will decode into an appropriate value based
  526. // on the contents of the stream:
  527. // - Numbers are decoded as float64, int64 or uint64.
  528. // - Other values are decoded appropriately depending on the type:
  529. // bool, string, []byte, time.Time, etc
  530. // - Extensions are decoded as RawExt (if no ext function registered for the tag)
  531. // Configurations exist on the Handle to override defaults
  532. // (e.g. for MapType, SliceType and how to decode raw bytes).
  533. //
  534. // When decoding into a non-nil interface{} value, the mode of encoding is based on the
  535. // type of the value. When a value is seen:
  536. // - If an extension is registered for it, call that extension function
  537. // - If it implements BinaryUnmarshaler, call its UnmarshalBinary(data []byte) error
  538. // - Else decode it based on its reflect.Kind
  539. //
  540. // There are some special rules when decoding into containers (slice/array/map/struct).
  541. // Decode will typically use the stream contents to UPDATE the container.
  542. // - A map can be decoded from a stream map, by updating matching keys.
  543. // - A slice can be decoded from a stream array,
  544. // by updating the first n elements, where n is length of the stream.
  545. // - A slice can be decoded from a stream map, by decoding as if
  546. // it contains a sequence of key-value pairs.
  547. // - A struct can be decoded from a stream map, by updating matching fields.
  548. // - A struct can be decoded from a stream array,
  549. // by updating fields as they occur in the struct (by index).
  550. //
  551. // When decoding a stream map or array with length of 0 into a nil map or slice,
  552. // we reset the destination map or slice to a zero-length value.
  553. //
  554. // However, when decoding a stream nil, we reset the destination container
  555. // to its "zero" value (e.g. nil for slice/map, etc).
  556. //
  557. func (d *Decoder) Decode(v interface{}) (err error) {
  558. defer panicToErr(&err)
  559. d.decode(v)
  560. return
  561. }
  562. func (d *Decoder) decode(iv interface{}) {
  563. d.d.initReadNext()
  564. switch v := iv.(type) {
  565. case nil:
  566. decErr("Cannot decode into nil.")
  567. case reflect.Value:
  568. d.chkPtrValue(v)
  569. d.decodeValue(v.Elem())
  570. case *string:
  571. *v = d.d.decodeString()
  572. case *bool:
  573. *v = d.d.decodeBool()
  574. case *int:
  575. *v = int(d.d.decodeInt(intBitsize))
  576. case *int8:
  577. *v = int8(d.d.decodeInt(8))
  578. case *int16:
  579. *v = int16(d.d.decodeInt(16))
  580. case *int32:
  581. *v = int32(d.d.decodeInt(32))
  582. case *int64:
  583. *v = d.d.decodeInt(64)
  584. case *uint:
  585. *v = uint(d.d.decodeUint(uintBitsize))
  586. case *uint8:
  587. *v = uint8(d.d.decodeUint(8))
  588. case *uint16:
  589. *v = uint16(d.d.decodeUint(16))
  590. case *uint32:
  591. *v = uint32(d.d.decodeUint(32))
  592. case *uint64:
  593. *v = d.d.decodeUint(64)
  594. case *float32:
  595. *v = float32(d.d.decodeFloat(true))
  596. case *float64:
  597. *v = d.d.decodeFloat(false)
  598. case *[]byte:
  599. *v, _ = d.d.decodeBytes(*v)
  600. case *[]interface{}:
  601. d.decSliceIntf(v, valueTypeInvalid, false)
  602. case *[]uint64:
  603. d.decSliceUint64(v, valueTypeInvalid, false)
  604. case *[]int64:
  605. d.decSliceInt64(v, valueTypeInvalid, false)
  606. case *[]string:
  607. d.decSliceStr(v, valueTypeInvalid, false)
  608. case *map[string]interface{}:
  609. d.decMapStrIntf(v)
  610. case *map[interface{}]interface{}:
  611. d.decMapIntfIntf(v)
  612. case *map[uint64]interface{}:
  613. d.decMapUint64Intf(v)
  614. case *map[int64]interface{}:
  615. d.decMapInt64Intf(v)
  616. case *interface{}:
  617. d.decodeValue(reflect.ValueOf(iv).Elem())
  618. default:
  619. rv := reflect.ValueOf(iv)
  620. d.chkPtrValue(rv)
  621. d.decodeValue(rv.Elem())
  622. }
  623. }
  624. func (d *Decoder) decodeValue(rv reflect.Value) {
  625. d.d.initReadNext()
  626. if d.d.tryDecodeAsNil() {
  627. // If value in stream is nil, set the dereferenced value to its "zero" value (if settable)
  628. if rv.Kind() == reflect.Ptr {
  629. if !rv.IsNil() {
  630. rv.Set(reflect.Zero(rv.Type()))
  631. }
  632. return
  633. }
  634. // for rv.Kind() == reflect.Ptr {
  635. // rv = rv.Elem()
  636. // }
  637. if rv.IsValid() { // rv.CanSet() // always settable, except it's invalid
  638. rv.Set(reflect.Zero(rv.Type()))
  639. }
  640. return
  641. }
  642. // If stream is not containing a nil value, then we can deref to the base
  643. // non-pointer value, and decode into that.
  644. for rv.Kind() == reflect.Ptr {
  645. if rv.IsNil() {
  646. rv.Set(reflect.New(rv.Type().Elem()))
  647. }
  648. rv = rv.Elem()
  649. }
  650. rt := rv.Type()
  651. rtid := reflect.ValueOf(rt).Pointer()
  652. // retrieve or register a focus'ed function for this type
  653. // to eliminate need to do the retrieval multiple times
  654. // if d.f == nil && d.s == nil { debugf("---->Creating new dec f map for type: %v\n", rt) }
  655. var fn decFn
  656. var ok bool
  657. if useMapForCodecCache {
  658. fn, ok = d.f[rtid]
  659. } else {
  660. for i, v := range d.x {
  661. if v == rtid {
  662. fn, ok = d.s[i], true
  663. break
  664. }
  665. }
  666. }
  667. if !ok {
  668. // debugf("\tCreating new dec fn for type: %v\n", rt)
  669. fi := decFnInfo{ti: getTypeInfo(rtid, rt), d: d, dd: d.d}
  670. fn.i = &fi
  671. // An extension can be registered for any type, regardless of the Kind
  672. // (e.g. type BitSet int64, type MyStruct { / * unexported fields * / }, type X []int, etc.
  673. //
  674. // We can't check if it's an extension byte here first, because the user may have
  675. // registered a pointer or non-pointer type, meaning we may have to recurse first
  676. // before matching a mapped type, even though the extension byte is already detected.
  677. //
  678. // NOTE: if decoding into a nil interface{}, we return a non-nil
  679. // value except even if the container registers a length of 0.
  680. if rtid == rawExtTypId {
  681. fn.f = (*decFnInfo).rawExt
  682. } else if d.d.isBuiltinType(rtid) {
  683. fn.f = (*decFnInfo).builtin
  684. } else if xfTag, xfFn := d.h.getDecodeExt(rtid); xfFn != nil {
  685. fi.xfTag, fi.xfFn = xfTag, xfFn
  686. fn.f = (*decFnInfo).ext
  687. } else if supportBinaryMarshal && fi.ti.unm {
  688. fn.f = (*decFnInfo).binaryMarshal
  689. } else {
  690. switch rk := rt.Kind(); rk {
  691. case reflect.String:
  692. fn.f = (*decFnInfo).kString
  693. case reflect.Bool:
  694. fn.f = (*decFnInfo).kBool
  695. case reflect.Int:
  696. fn.f = (*decFnInfo).kInt
  697. case reflect.Int64:
  698. fn.f = (*decFnInfo).kInt64
  699. case reflect.Int32:
  700. fn.f = (*decFnInfo).kInt32
  701. case reflect.Int8:
  702. fn.f = (*decFnInfo).kInt8
  703. case reflect.Int16:
  704. fn.f = (*decFnInfo).kInt16
  705. case reflect.Float32:
  706. fn.f = (*decFnInfo).kFloat32
  707. case reflect.Float64:
  708. fn.f = (*decFnInfo).kFloat64
  709. case reflect.Uint8:
  710. fn.f = (*decFnInfo).kUint8
  711. case reflect.Uint64:
  712. fn.f = (*decFnInfo).kUint64
  713. case reflect.Uint:
  714. fn.f = (*decFnInfo).kUint
  715. case reflect.Uint32:
  716. fn.f = (*decFnInfo).kUint32
  717. case reflect.Uint16:
  718. fn.f = (*decFnInfo).kUint16
  719. // case reflect.Ptr:
  720. // fn.f = (*decFnInfo).kPtr
  721. case reflect.Interface:
  722. fn.f = (*decFnInfo).kInterface
  723. case reflect.Struct:
  724. fn.f = (*decFnInfo).kStruct
  725. case reflect.Slice:
  726. fn.f = (*decFnInfo).kSlice
  727. case reflect.Array:
  728. fi.array = true
  729. fn.f = (*decFnInfo).kArray
  730. case reflect.Map:
  731. fn.f = (*decFnInfo).kMap
  732. default:
  733. fn.f = (*decFnInfo).kErr
  734. }
  735. }
  736. if useMapForCodecCache {
  737. if d.f == nil {
  738. d.f = make(map[uintptr]decFn, 16)
  739. }
  740. d.f[rtid] = fn
  741. } else {
  742. d.s = append(d.s, fn)
  743. d.x = append(d.x, rtid)
  744. }
  745. }
  746. fn.f(fn.i, rv)
  747. return
  748. }
  749. func (d *Decoder) chkPtrValue(rv reflect.Value) {
  750. // We can only decode into a non-nil pointer
  751. if rv.Kind() == reflect.Ptr && !rv.IsNil() {
  752. return
  753. }
  754. if !rv.IsValid() {
  755. decErr("Cannot decode into a zero (ie invalid) reflect.Value")
  756. }
  757. if !rv.CanInterface() {
  758. decErr("Cannot decode into a value without an interface: %v", rv)
  759. }
  760. rvi := rv.Interface()
  761. decErr("Cannot decode into non-pointer or nil pointer. Got: %v, %T, %v",
  762. rv.Kind(), rvi, rvi)
  763. }
  764. func (d *Decoder) decEmbeddedField(rv reflect.Value, index []int) {
  765. // d.decodeValue(rv.FieldByIndex(index))
  766. // nil pointers may be here; so reproduce FieldByIndex logic + enhancements
  767. for _, j := range index {
  768. if rv.Kind() == reflect.Ptr {
  769. if rv.IsNil() {
  770. rv.Set(reflect.New(rv.Type().Elem()))
  771. }
  772. // If a pointer, it must be a pointer to struct (based on typeInfo contract)
  773. rv = rv.Elem()
  774. }
  775. rv = rv.Field(j)
  776. }
  777. d.decodeValue(rv)
  778. }
  779. // --------------------------------------------------
  780. // short circuit functions for common maps and slices
  781. func (d *Decoder) decSliceIntf(v *[]interface{}, currEncodedType valueType, doNotReset bool) {
  782. _, containerLenS := decContLens(d.d, currEncodedType)
  783. s := *v
  784. if s == nil {
  785. s = make([]interface{}, containerLenS, containerLenS)
  786. } else if containerLenS > cap(s) {
  787. if doNotReset {
  788. decErr(msgDecCannotExpandArr, cap(s), containerLenS)
  789. }
  790. s = make([]interface{}, containerLenS, containerLenS)
  791. copy(s, *v)
  792. } else if containerLenS > len(s) {
  793. s = s[:containerLenS]
  794. }
  795. for j := 0; j < containerLenS; j++ {
  796. d.decode(&s[j])
  797. }
  798. *v = s
  799. }
  800. func (d *Decoder) decSliceInt64(v *[]int64, currEncodedType valueType, doNotReset bool) {
  801. _, containerLenS := decContLens(d.d, currEncodedType)
  802. s := *v
  803. if s == nil {
  804. s = make([]int64, containerLenS, containerLenS)
  805. } else if containerLenS > cap(s) {
  806. if doNotReset {
  807. decErr(msgDecCannotExpandArr, cap(s), containerLenS)
  808. }
  809. s = make([]int64, containerLenS, containerLenS)
  810. copy(s, *v)
  811. } else if containerLenS > len(s) {
  812. s = s[:containerLenS]
  813. }
  814. for j := 0; j < containerLenS; j++ {
  815. // d.decode(&s[j])
  816. d.d.initReadNext()
  817. s[j] = d.d.decodeInt(intBitsize)
  818. }
  819. *v = s
  820. }
  821. func (d *Decoder) decSliceUint64(v *[]uint64, currEncodedType valueType, doNotReset bool) {
  822. _, containerLenS := decContLens(d.d, currEncodedType)
  823. s := *v
  824. if s == nil {
  825. s = make([]uint64, containerLenS, containerLenS)
  826. } else if containerLenS > cap(s) {
  827. if doNotReset {
  828. decErr(msgDecCannotExpandArr, cap(s), containerLenS)
  829. }
  830. s = make([]uint64, containerLenS, containerLenS)
  831. copy(s, *v)
  832. } else if containerLenS > len(s) {
  833. s = s[:containerLenS]
  834. }
  835. for j := 0; j < containerLenS; j++ {
  836. // d.decode(&s[j])
  837. d.d.initReadNext()
  838. s[j] = d.d.decodeUint(intBitsize)
  839. }
  840. *v = s
  841. }
  842. func (d *Decoder) decSliceStr(v *[]string, currEncodedType valueType, doNotReset bool) {
  843. _, containerLenS := decContLens(d.d, currEncodedType)
  844. s := *v
  845. if s == nil {
  846. s = make([]string, containerLenS, containerLenS)
  847. } else if containerLenS > cap(s) {
  848. if doNotReset {
  849. decErr(msgDecCannotExpandArr, cap(s), containerLenS)
  850. }
  851. s = make([]string, containerLenS, containerLenS)
  852. copy(s, *v)
  853. } else if containerLenS > len(s) {
  854. s = s[:containerLenS]
  855. }
  856. for j := 0; j < containerLenS; j++ {
  857. // d.decode(&s[j])
  858. d.d.initReadNext()
  859. s[j] = d.d.decodeString()
  860. }
  861. *v = s
  862. }
  863. func (d *Decoder) decMapIntfIntf(v *map[interface{}]interface{}) {
  864. containerLen := d.d.readMapLen()
  865. m := *v
  866. if m == nil {
  867. m = make(map[interface{}]interface{}, containerLen)
  868. *v = m
  869. }
  870. for j := 0; j < containerLen; j++ {
  871. var mk interface{}
  872. d.decode(&mk)
  873. // special case if a byte array.
  874. if bv, bok := mk.([]byte); bok {
  875. mk = string(bv)
  876. }
  877. mv := m[mk]
  878. d.decode(&mv)
  879. m[mk] = mv
  880. }
  881. }
  882. func (d *Decoder) decMapInt64Intf(v *map[int64]interface{}) {
  883. containerLen := d.d.readMapLen()
  884. m := *v
  885. if m == nil {
  886. m = make(map[int64]interface{}, containerLen)
  887. *v = m
  888. }
  889. for j := 0; j < containerLen; j++ {
  890. d.d.initReadNext()
  891. mk := d.d.decodeInt(intBitsize)
  892. mv := m[mk]
  893. d.decode(&mv)
  894. m[mk] = mv
  895. }
  896. }
  897. func (d *Decoder) decMapUint64Intf(v *map[uint64]interface{}) {
  898. containerLen := d.d.readMapLen()
  899. m := *v
  900. if m == nil {
  901. m = make(map[uint64]interface{}, containerLen)
  902. *v = m
  903. }
  904. for j := 0; j < containerLen; j++ {
  905. d.d.initReadNext()
  906. mk := d.d.decodeUint(intBitsize)
  907. mv := m[mk]
  908. d.decode(&mv)
  909. m[mk] = mv
  910. }
  911. }
  912. func (d *Decoder) decMapStrIntf(v *map[string]interface{}) {
  913. containerLen := d.d.readMapLen()
  914. m := *v
  915. if m == nil {
  916. m = make(map[string]interface{}, containerLen)
  917. *v = m
  918. }
  919. for j := 0; j < containerLen; j++ {
  920. d.d.initReadNext()
  921. mk := d.d.decodeString()
  922. mv := m[mk]
  923. d.decode(&mv)
  924. m[mk] = mv
  925. }
  926. }
  927. // ----------------------------------------
  928. func decContLens(dd decDriver, currEncodedType valueType) (containerLen, containerLenS int) {
  929. if currEncodedType == valueTypeInvalid {
  930. currEncodedType = dd.currentEncodedType()
  931. }
  932. switch currEncodedType {
  933. case valueTypeArray:
  934. containerLen = dd.readArrayLen()
  935. containerLenS = containerLen
  936. case valueTypeMap:
  937. containerLen = dd.readMapLen()
  938. containerLenS = containerLen * 2
  939. default:
  940. decErr("Only encoded map or array can be decoded into a slice. (valueType: %0x)",
  941. currEncodedType)
  942. }
  943. return
  944. }
  945. func decErr(format string, params ...interface{}) {
  946. doPanic(msgTagDec, format, params...)
  947. }