encode.go 24 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001
  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. )
  8. const (
  9. // Some tagging information for error messages.
  10. msgTagEnc = "codec.encoder"
  11. defEncByteBufSize = 1 << 6 // 4:16, 6:64, 8:256, 10:1024
  12. // maxTimeSecs32 = math.MaxInt32 / 60 / 24 / 366
  13. )
  14. // AsSymbolFlag defines what should be encoded as symbols.
  15. type AsSymbolFlag uint8
  16. const (
  17. // AsSymbolDefault is default.
  18. // Currently, this means only encode struct field names as symbols.
  19. // The default is subject to change.
  20. AsSymbolDefault AsSymbolFlag = iota
  21. // AsSymbolAll means encode anything which could be a symbol as a symbol.
  22. AsSymbolAll = 0xfe
  23. // AsSymbolNone means do not encode anything as a symbol.
  24. AsSymbolNone = 1 << iota
  25. // AsSymbolMapStringKeys means encode keys in map[string]XXX as symbols.
  26. AsSymbolMapStringKeysFlag
  27. // AsSymbolStructFieldName means encode struct field names as symbols.
  28. AsSymbolStructFieldNameFlag
  29. )
  30. // encWriter abstracting writing to a byte array or to an io.Writer.
  31. type encWriter interface {
  32. writeUint16(uint16)
  33. writeUint32(uint32)
  34. writeUint64(uint64)
  35. writeb([]byte)
  36. writestr(string)
  37. writen1(byte)
  38. writen2(byte, byte)
  39. atEndOfEncode()
  40. }
  41. // encDriver abstracts the actual codec (binc vs msgpack, etc)
  42. type encDriver interface {
  43. isBuiltinType(rt uintptr) bool
  44. encodeBuiltin(rt uintptr, v interface{})
  45. encodeNil()
  46. encodeInt(i int64)
  47. encodeUint(i uint64)
  48. encodeBool(b bool)
  49. encodeFloat32(f float32)
  50. encodeFloat64(f float64)
  51. encodeExtPreamble(xtag byte, length int)
  52. encodeArrayPreamble(length int)
  53. encodeMapPreamble(length int)
  54. encodeString(c charEncoding, v string)
  55. encodeSymbol(v string)
  56. encodeStringBytes(c charEncoding, v []byte)
  57. //TODO
  58. //encBignum(f *big.Int)
  59. //encStringRunes(c charEncoding, v []rune)
  60. }
  61. type ioEncWriterWriter interface {
  62. WriteByte(c byte) error
  63. WriteString(s string) (n int, err error)
  64. Write(p []byte) (n int, err error)
  65. }
  66. type ioEncStringWriter interface {
  67. WriteString(s string) (n int, err error)
  68. }
  69. type EncodeOptions struct {
  70. // Encode a struct as an array, and not as a map.
  71. StructToArray bool
  72. // AsSymbols defines what should be encoded as symbols.
  73. //
  74. // Encoding as symbols can reduce the encoded size significantly.
  75. //
  76. // However, during decoding, each string to be encoded as a symbol must
  77. // be checked to see if it has been seen before. Consequently, encoding time
  78. // will increase if using symbols, because string comparisons has a clear cost.
  79. //
  80. // Sample values:
  81. // AsSymbolNone
  82. // AsSymbolAll
  83. // AsSymbolMapStringKeys
  84. // AsSymbolMapStringKeysFlag | AsSymbolStructFieldNameFlag
  85. AsSymbols AsSymbolFlag
  86. }
  87. // ---------------------------------------------
  88. type simpleIoEncWriterWriter struct {
  89. w io.Writer
  90. bw io.ByteWriter
  91. sw ioEncStringWriter
  92. }
  93. func (o *simpleIoEncWriterWriter) WriteByte(c byte) (err error) {
  94. if o.bw != nil {
  95. return o.bw.WriteByte(c)
  96. }
  97. _, err = o.w.Write([]byte{c})
  98. return
  99. }
  100. func (o *simpleIoEncWriterWriter) WriteString(s string) (n int, err error) {
  101. if o.sw != nil {
  102. return o.sw.WriteString(s)
  103. }
  104. return o.w.Write([]byte(s))
  105. }
  106. func (o *simpleIoEncWriterWriter) Write(p []byte) (n int, err error) {
  107. return o.w.Write(p)
  108. }
  109. // ----------------------------------------
  110. // ioEncWriter implements encWriter and can write to an io.Writer implementation
  111. type ioEncWriter struct {
  112. w ioEncWriterWriter
  113. x [8]byte // temp byte array re-used internally for efficiency
  114. }
  115. func (z *ioEncWriter) writeUint16(v uint16) {
  116. bigen.PutUint16(z.x[:2], v)
  117. z.writeb(z.x[:2])
  118. }
  119. func (z *ioEncWriter) writeUint32(v uint32) {
  120. bigen.PutUint32(z.x[:4], v)
  121. z.writeb(z.x[:4])
  122. }
  123. func (z *ioEncWriter) writeUint64(v uint64) {
  124. bigen.PutUint64(z.x[:8], v)
  125. z.writeb(z.x[:8])
  126. }
  127. func (z *ioEncWriter) writeb(bs []byte) {
  128. if len(bs) == 0 {
  129. return
  130. }
  131. n, err := z.w.Write(bs)
  132. if err != nil {
  133. panic(err)
  134. }
  135. if n != len(bs) {
  136. encErr("write: Incorrect num bytes written. Expecting: %v, Wrote: %v", len(bs), n)
  137. }
  138. }
  139. func (z *ioEncWriter) writestr(s string) {
  140. n, err := z.w.WriteString(s)
  141. if err != nil {
  142. panic(err)
  143. }
  144. if n != len(s) {
  145. encErr("write: Incorrect num bytes written. Expecting: %v, Wrote: %v", len(s), n)
  146. }
  147. }
  148. func (z *ioEncWriter) writen1(b byte) {
  149. if err := z.w.WriteByte(b); err != nil {
  150. panic(err)
  151. }
  152. }
  153. func (z *ioEncWriter) writen2(b1 byte, b2 byte) {
  154. z.writen1(b1)
  155. z.writen1(b2)
  156. }
  157. func (z *ioEncWriter) atEndOfEncode() {}
  158. // ----------------------------------------
  159. // bytesEncWriter implements encWriter and can write to an byte slice.
  160. // It is used by Marshal function.
  161. type bytesEncWriter struct {
  162. b []byte
  163. c int // cursor
  164. out *[]byte // write out on atEndOfEncode
  165. }
  166. func (z *bytesEncWriter) writeUint16(v uint16) {
  167. c := z.grow(2)
  168. z.b[c] = byte(v >> 8)
  169. z.b[c+1] = byte(v)
  170. }
  171. func (z *bytesEncWriter) writeUint32(v uint32) {
  172. c := z.grow(4)
  173. z.b[c] = byte(v >> 24)
  174. z.b[c+1] = byte(v >> 16)
  175. z.b[c+2] = byte(v >> 8)
  176. z.b[c+3] = byte(v)
  177. }
  178. func (z *bytesEncWriter) writeUint64(v uint64) {
  179. c := z.grow(8)
  180. z.b[c] = byte(v >> 56)
  181. z.b[c+1] = byte(v >> 48)
  182. z.b[c+2] = byte(v >> 40)
  183. z.b[c+3] = byte(v >> 32)
  184. z.b[c+4] = byte(v >> 24)
  185. z.b[c+5] = byte(v >> 16)
  186. z.b[c+6] = byte(v >> 8)
  187. z.b[c+7] = byte(v)
  188. }
  189. func (z *bytesEncWriter) writeb(s []byte) {
  190. if len(s) == 0 {
  191. return
  192. }
  193. c := z.grow(len(s))
  194. copy(z.b[c:], s)
  195. }
  196. func (z *bytesEncWriter) writestr(s string) {
  197. c := z.grow(len(s))
  198. copy(z.b[c:], s)
  199. }
  200. func (z *bytesEncWriter) writen1(b1 byte) {
  201. c := z.grow(1)
  202. z.b[c] = b1
  203. }
  204. func (z *bytesEncWriter) writen2(b1 byte, b2 byte) {
  205. c := z.grow(2)
  206. z.b[c] = b1
  207. z.b[c+1] = b2
  208. }
  209. func (z *bytesEncWriter) atEndOfEncode() {
  210. *(z.out) = z.b[:z.c]
  211. }
  212. func (z *bytesEncWriter) grow(n int) (oldcursor int) {
  213. oldcursor = z.c
  214. z.c = oldcursor + n
  215. if z.c > cap(z.b) {
  216. // Tried using appendslice logic: (if cap < 1024, *2, else *1.25).
  217. // However, it was too expensive, causing too many iterations of copy.
  218. // Using bytes.Buffer model was much better (2*cap + n)
  219. bs := make([]byte, 2*cap(z.b)+n)
  220. copy(bs, z.b[:oldcursor])
  221. z.b = bs
  222. } else if z.c > len(z.b) {
  223. z.b = z.b[:cap(z.b)]
  224. }
  225. return
  226. }
  227. // ---------------------------------------------
  228. type encFnInfo struct {
  229. ti *typeInfo
  230. e *Encoder
  231. ee encDriver
  232. xfFn func(reflect.Value) ([]byte, error)
  233. xfTag byte
  234. }
  235. func (f *encFnInfo) builtin(rv reflect.Value) {
  236. f.ee.encodeBuiltin(f.ti.rtid, rv.Interface())
  237. }
  238. func (f *encFnInfo) rawExt(rv reflect.Value) {
  239. f.e.encRawExt(rv.Interface().(RawExt))
  240. }
  241. func (f *encFnInfo) ext(rv reflect.Value) {
  242. bs, fnerr := f.xfFn(rv)
  243. if fnerr != nil {
  244. panic(fnerr)
  245. }
  246. if bs == nil {
  247. f.ee.encodeNil()
  248. return
  249. }
  250. if f.e.hh.writeExt() {
  251. f.ee.encodeExtPreamble(f.xfTag, len(bs))
  252. f.e.w.writeb(bs)
  253. } else {
  254. f.ee.encodeStringBytes(c_RAW, bs)
  255. }
  256. }
  257. func (f *encFnInfo) binaryMarshal(rv reflect.Value) {
  258. var bm binaryMarshaler
  259. if f.ti.mIndir == 0 {
  260. bm = rv.Interface().(binaryMarshaler)
  261. } else if f.ti.mIndir == -1 {
  262. bm = rv.Addr().Interface().(binaryMarshaler)
  263. } else {
  264. for j, k := int8(0), f.ti.mIndir; j < k; j++ {
  265. if rv.IsNil() {
  266. f.ee.encodeNil()
  267. return
  268. }
  269. rv = rv.Elem()
  270. }
  271. bm = rv.Interface().(binaryMarshaler)
  272. }
  273. // debugf(">>>> binaryMarshaler: %T", rv.Interface())
  274. bs, fnerr := bm.MarshalBinary()
  275. if fnerr != nil {
  276. panic(fnerr)
  277. }
  278. if bs == nil {
  279. f.ee.encodeNil()
  280. } else {
  281. f.ee.encodeStringBytes(c_RAW, bs)
  282. }
  283. }
  284. func (f *encFnInfo) kBool(rv reflect.Value) {
  285. f.ee.encodeBool(rv.Bool())
  286. }
  287. func (f *encFnInfo) kString(rv reflect.Value) {
  288. f.ee.encodeString(c_UTF8, rv.String())
  289. }
  290. func (f *encFnInfo) kFloat64(rv reflect.Value) {
  291. f.ee.encodeFloat64(rv.Float())
  292. }
  293. func (f *encFnInfo) kFloat32(rv reflect.Value) {
  294. f.ee.encodeFloat32(float32(rv.Float()))
  295. }
  296. func (f *encFnInfo) kInt(rv reflect.Value) {
  297. f.ee.encodeInt(rv.Int())
  298. }
  299. func (f *encFnInfo) kUint(rv reflect.Value) {
  300. f.ee.encodeUint(rv.Uint())
  301. }
  302. func (f *encFnInfo) kInvalid(rv reflect.Value) {
  303. f.ee.encodeNil()
  304. }
  305. func (f *encFnInfo) kErr(rv reflect.Value) {
  306. encErr("Unsupported kind: %s, for: %#v", rv.Kind(), rv)
  307. }
  308. func (f *encFnInfo) kSlice(rv reflect.Value) {
  309. if rv.IsNil() {
  310. f.ee.encodeNil()
  311. return
  312. }
  313. if shortCircuitReflectToFastPath {
  314. switch f.ti.rtid {
  315. case intfSliceTypId:
  316. f.e.encSliceIntf(rv.Interface().([]interface{}))
  317. return
  318. case strSliceTypId:
  319. f.e.encSliceStr(rv.Interface().([]string))
  320. return
  321. case uint64SliceTypId:
  322. f.e.encSliceUint64(rv.Interface().([]uint64))
  323. return
  324. case int64SliceTypId:
  325. f.e.encSliceInt64(rv.Interface().([]int64))
  326. return
  327. }
  328. }
  329. // If in this method, then there was no extension function defined.
  330. // So it's okay to treat as []byte.
  331. if f.ti.rtid == uint8SliceTypId || f.ti.rt.Elem().Kind() == reflect.Uint8 {
  332. f.ee.encodeStringBytes(c_RAW, rv.Bytes())
  333. return
  334. }
  335. l := rv.Len()
  336. if f.ti.mbs {
  337. if l%2 == 1 {
  338. encErr("mapBySlice: invalid length (must be divisible by 2): %v", l)
  339. }
  340. f.ee.encodeMapPreamble(l / 2)
  341. } else {
  342. f.ee.encodeArrayPreamble(l)
  343. }
  344. if l == 0 {
  345. return
  346. }
  347. for j := 0; j < l; j++ {
  348. // TODO: Consider perf implication of encoding odd index values as symbols if type is string
  349. f.e.encodeValue(rv.Index(j))
  350. }
  351. }
  352. func (f *encFnInfo) kArray(rv reflect.Value) {
  353. // We cannot share kSlice method, because the array may be non-addressable.
  354. // E.g. type struct S{B [2]byte}; Encode(S{}) will bomb on "panic: slice of unaddressable array".
  355. // So we have to duplicate the functionality here.
  356. // f.e.encodeValue(rv.Slice(0, rv.Len()))
  357. // f.kSlice(rv.Slice(0, rv.Len()))
  358. l := rv.Len()
  359. // Handle an array of bytes specially (in line with what is done for slices)
  360. if f.ti.rt.Elem().Kind() == reflect.Uint8 {
  361. if l == 0 {
  362. f.ee.encodeStringBytes(c_RAW, nil)
  363. return
  364. }
  365. var bs []byte
  366. if rv.CanAddr() {
  367. bs = rv.Slice(0, l).Bytes()
  368. } else {
  369. bs = make([]byte, l)
  370. for i := 0; i < l; i++ {
  371. bs[i] = byte(rv.Index(i).Uint())
  372. }
  373. }
  374. f.ee.encodeStringBytes(c_RAW, bs)
  375. return
  376. }
  377. if f.ti.mbs {
  378. if l%2 == 1 {
  379. encErr("mapBySlice: invalid length (must be divisible by 2): %v", l)
  380. }
  381. f.ee.encodeMapPreamble(l / 2)
  382. } else {
  383. f.ee.encodeArrayPreamble(l)
  384. }
  385. if l == 0 {
  386. return
  387. }
  388. for j := 0; j < l; j++ {
  389. // TODO: Consider perf implication of encoding odd index values as symbols if type is string
  390. f.e.encodeValue(rv.Index(j))
  391. }
  392. }
  393. func (f *encFnInfo) kStruct(rv reflect.Value) {
  394. fti := f.ti
  395. newlen := len(fti.sfi)
  396. rvals := make([]reflect.Value, newlen)
  397. var encnames []string
  398. e := f.e
  399. tisfi := fti.sfip
  400. toMap := !(fti.toArray || e.h.StructToArray)
  401. // if toMap, use the sorted array. If toArray, use unsorted array (to match sequence in struct)
  402. if toMap {
  403. tisfi = fti.sfi
  404. encnames = make([]string, newlen)
  405. }
  406. newlen = 0
  407. for _, si := range tisfi {
  408. if si.i != -1 {
  409. rvals[newlen] = rv.Field(int(si.i))
  410. } else {
  411. rvals[newlen] = rv.FieldByIndex(si.is)
  412. }
  413. if toMap {
  414. if si.omitEmpty && isEmptyValue(rvals[newlen]) {
  415. continue
  416. }
  417. encnames[newlen] = si.encName
  418. } else {
  419. if si.omitEmpty && isEmptyValue(rvals[newlen]) {
  420. rvals[newlen] = reflect.Value{} //encode as nil
  421. }
  422. }
  423. newlen++
  424. }
  425. // debugf(">>>> kStruct: newlen: %v", newlen)
  426. if toMap {
  427. ee := f.ee //don't dereference everytime
  428. ee.encodeMapPreamble(newlen)
  429. // asSymbols := e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0
  430. asSymbols := e.h.AsSymbols == AsSymbolDefault || e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0
  431. for j := 0; j < newlen; j++ {
  432. if asSymbols {
  433. ee.encodeSymbol(encnames[j])
  434. } else {
  435. ee.encodeString(c_UTF8, encnames[j])
  436. }
  437. e.encodeValue(rvals[j])
  438. }
  439. } else {
  440. f.ee.encodeArrayPreamble(newlen)
  441. for j := 0; j < newlen; j++ {
  442. e.encodeValue(rvals[j])
  443. }
  444. }
  445. }
  446. // func (f *encFnInfo) kPtr(rv reflect.Value) {
  447. // debugf(">>>>>>> ??? encode kPtr called - shouldn't get called")
  448. // if rv.IsNil() {
  449. // f.ee.encodeNil()
  450. // return
  451. // }
  452. // f.e.encodeValue(rv.Elem())
  453. // }
  454. func (f *encFnInfo) kInterface(rv reflect.Value) {
  455. if rv.IsNil() {
  456. f.ee.encodeNil()
  457. return
  458. }
  459. f.e.encodeValue(rv.Elem())
  460. }
  461. func (f *encFnInfo) kMap(rv reflect.Value) {
  462. if rv.IsNil() {
  463. f.ee.encodeNil()
  464. return
  465. }
  466. if shortCircuitReflectToFastPath {
  467. switch f.ti.rtid {
  468. case mapIntfIntfTypId:
  469. f.e.encMapIntfIntf(rv.Interface().(map[interface{}]interface{}))
  470. return
  471. case mapStrIntfTypId:
  472. f.e.encMapStrIntf(rv.Interface().(map[string]interface{}))
  473. return
  474. case mapStrStrTypId:
  475. f.e.encMapStrStr(rv.Interface().(map[string]string))
  476. return
  477. case mapInt64IntfTypId:
  478. f.e.encMapInt64Intf(rv.Interface().(map[int64]interface{}))
  479. return
  480. case mapUint64IntfTypId:
  481. f.e.encMapUint64Intf(rv.Interface().(map[uint64]interface{}))
  482. return
  483. }
  484. }
  485. l := rv.Len()
  486. f.ee.encodeMapPreamble(l)
  487. if l == 0 {
  488. return
  489. }
  490. // keyTypeIsString := f.ti.rt.Key().Kind() == reflect.String
  491. keyTypeIsString := f.ti.rt.Key() == stringTyp
  492. var asSymbols bool
  493. if keyTypeIsString {
  494. asSymbols = f.e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
  495. }
  496. mks := rv.MapKeys()
  497. // for j, lmks := 0, len(mks); j < lmks; j++ {
  498. for j := range mks {
  499. if keyTypeIsString {
  500. if asSymbols {
  501. f.ee.encodeSymbol(mks[j].String())
  502. } else {
  503. f.ee.encodeString(c_UTF8, mks[j].String())
  504. }
  505. } else {
  506. f.e.encodeValue(mks[j])
  507. }
  508. f.e.encodeValue(rv.MapIndex(mks[j]))
  509. }
  510. }
  511. // --------------------------------------------------
  512. // encFn encapsulates the captured variables and the encode function.
  513. // This way, we only do some calculations one times, and pass to the
  514. // code block that should be called (encapsulated in a function)
  515. // instead of executing the checks every time.
  516. type encFn struct {
  517. i *encFnInfo
  518. f func(*encFnInfo, reflect.Value)
  519. }
  520. // --------------------------------------------------
  521. // An Encoder writes an object to an output stream in the codec format.
  522. type Encoder struct {
  523. w encWriter
  524. e encDriver
  525. h *BasicHandle
  526. hh Handle
  527. f map[uintptr]encFn
  528. x []uintptr
  529. s []encFn
  530. }
  531. // NewEncoder returns an Encoder for encoding into an io.Writer.
  532. //
  533. // For efficiency, Users are encouraged to pass in a memory buffered writer
  534. // (eg bufio.Writer, bytes.Buffer).
  535. func NewEncoder(w io.Writer, h Handle) *Encoder {
  536. ww, ok := w.(ioEncWriterWriter)
  537. if !ok {
  538. sww := simpleIoEncWriterWriter{w: w}
  539. sww.bw, _ = w.(io.ByteWriter)
  540. sww.sw, _ = w.(ioEncStringWriter)
  541. ww = &sww
  542. //ww = bufio.NewWriterSize(w, defEncByteBufSize)
  543. }
  544. z := ioEncWriter{
  545. w: ww,
  546. }
  547. return &Encoder{w: &z, hh: h, h: h.getBasicHandle(), e: h.newEncDriver(&z)}
  548. }
  549. // NewEncoderBytes returns an encoder for encoding directly and efficiently
  550. // into a byte slice, using zero-copying to temporary slices.
  551. //
  552. // It will potentially replace the output byte slice pointed to.
  553. // After encoding, the out parameter contains the encoded contents.
  554. func NewEncoderBytes(out *[]byte, h Handle) *Encoder {
  555. in := *out
  556. if in == nil {
  557. in = make([]byte, defEncByteBufSize)
  558. }
  559. z := bytesEncWriter{
  560. b: in,
  561. out: out,
  562. }
  563. return &Encoder{w: &z, hh: h, h: h.getBasicHandle(), e: h.newEncDriver(&z)}
  564. }
  565. // Encode writes an object into a stream in the codec format.
  566. //
  567. // Encoding can be configured via the "codec" struct tag for the fields.
  568. //
  569. // The "codec" key in struct field's tag value is the key name,
  570. // followed by an optional comma and options.
  571. //
  572. // To set an option on all fields (e.g. omitempty on all fields), you
  573. // can create a field called _struct, and set flags on it.
  574. //
  575. // Struct values "usually" encode as maps. Each exported struct field is encoded unless:
  576. // - the field's codec tag is "-", OR
  577. // - the field is empty and its codec tag specifies the "omitempty" option.
  578. //
  579. // When encoding as a map, the first string in the tag (before the comma)
  580. // is the map key string to use when encoding.
  581. //
  582. // However, struct values may encode as arrays. This happens when:
  583. // - StructToArray Encode option is set, OR
  584. // - the codec tag on the _struct field sets the "toarray" option
  585. //
  586. // Values with types that implement MapBySlice are encoded as stream maps.
  587. //
  588. // The empty values (for omitempty option) are false, 0, any nil pointer
  589. // or interface value, and any array, slice, map, or string of length zero.
  590. //
  591. // Anonymous fields are encoded inline if no struct tag is present.
  592. // Else they are encoded as regular fields.
  593. //
  594. // Examples:
  595. //
  596. // type MyStruct struct {
  597. // _struct bool `codec:",omitempty"` //set omitempty for every field
  598. // Field1 string `codec:"-"` //skip this field
  599. // Field2 int `codec:"myName"` //Use key "myName" in encode stream
  600. // Field3 int32 `codec:",omitempty"` //use key "Field3". Omit if empty.
  601. // Field4 bool `codec:"f4,omitempty"` //use key "f4". Omit if empty.
  602. // ...
  603. // }
  604. //
  605. // type MyStruct struct {
  606. // _struct bool `codec:",omitempty,toarray"` //set omitempty for every field
  607. // //and encode struct as an array
  608. // }
  609. //
  610. // The mode of encoding is based on the type of the value. When a value is seen:
  611. // - If an extension is registered for it, call that extension function
  612. // - If it implements BinaryMarshaler, call its MarshalBinary() (data []byte, err error)
  613. // - Else encode it based on its reflect.Kind
  614. //
  615. // Note that struct field names and keys in map[string]XXX will be treated as symbols.
  616. // Some formats support symbols (e.g. binc) and will properly encode the string
  617. // only once in the stream, and use a tag to refer to it thereafter.
  618. func (e *Encoder) Encode(v interface{}) (err error) {
  619. defer panicToErr(&err)
  620. e.encode(v)
  621. e.w.atEndOfEncode()
  622. return
  623. }
  624. func (e *Encoder) encode(iv interface{}) {
  625. switch v := iv.(type) {
  626. case nil:
  627. e.e.encodeNil()
  628. case reflect.Value:
  629. e.encodeValue(v)
  630. case string:
  631. e.e.encodeString(c_UTF8, v)
  632. case bool:
  633. e.e.encodeBool(v)
  634. case int:
  635. e.e.encodeInt(int64(v))
  636. case int8:
  637. e.e.encodeInt(int64(v))
  638. case int16:
  639. e.e.encodeInt(int64(v))
  640. case int32:
  641. e.e.encodeInt(int64(v))
  642. case int64:
  643. e.e.encodeInt(v)
  644. case uint:
  645. e.e.encodeUint(uint64(v))
  646. case uint8:
  647. e.e.encodeUint(uint64(v))
  648. case uint16:
  649. e.e.encodeUint(uint64(v))
  650. case uint32:
  651. e.e.encodeUint(uint64(v))
  652. case uint64:
  653. e.e.encodeUint(v)
  654. case float32:
  655. e.e.encodeFloat32(v)
  656. case float64:
  657. e.e.encodeFloat64(v)
  658. case []interface{}:
  659. e.encSliceIntf(v)
  660. case []string:
  661. e.encSliceStr(v)
  662. case []int64:
  663. e.encSliceInt64(v)
  664. case []uint64:
  665. e.encSliceUint64(v)
  666. case []uint8:
  667. e.e.encodeStringBytes(c_RAW, v)
  668. case map[interface{}]interface{}:
  669. e.encMapIntfIntf(v)
  670. case map[string]interface{}:
  671. e.encMapStrIntf(v)
  672. case map[string]string:
  673. e.encMapStrStr(v)
  674. case map[int64]interface{}:
  675. e.encMapInt64Intf(v)
  676. case map[uint64]interface{}:
  677. e.encMapUint64Intf(v)
  678. case *string:
  679. e.e.encodeString(c_UTF8, *v)
  680. case *bool:
  681. e.e.encodeBool(*v)
  682. case *int:
  683. e.e.encodeInt(int64(*v))
  684. case *int8:
  685. e.e.encodeInt(int64(*v))
  686. case *int16:
  687. e.e.encodeInt(int64(*v))
  688. case *int32:
  689. e.e.encodeInt(int64(*v))
  690. case *int64:
  691. e.e.encodeInt(*v)
  692. case *uint:
  693. e.e.encodeUint(uint64(*v))
  694. case *uint8:
  695. e.e.encodeUint(uint64(*v))
  696. case *uint16:
  697. e.e.encodeUint(uint64(*v))
  698. case *uint32:
  699. e.e.encodeUint(uint64(*v))
  700. case *uint64:
  701. e.e.encodeUint(*v)
  702. case *float32:
  703. e.e.encodeFloat32(*v)
  704. case *float64:
  705. e.e.encodeFloat64(*v)
  706. case *[]interface{}:
  707. e.encSliceIntf(*v)
  708. case *[]string:
  709. e.encSliceStr(*v)
  710. case *[]int64:
  711. e.encSliceInt64(*v)
  712. case *[]uint64:
  713. e.encSliceUint64(*v)
  714. case *[]uint8:
  715. e.e.encodeStringBytes(c_RAW, *v)
  716. case *map[interface{}]interface{}:
  717. e.encMapIntfIntf(*v)
  718. case *map[string]interface{}:
  719. e.encMapStrIntf(*v)
  720. case *map[string]string:
  721. e.encMapStrStr(*v)
  722. case *map[int64]interface{}:
  723. e.encMapInt64Intf(*v)
  724. case *map[uint64]interface{}:
  725. e.encMapUint64Intf(*v)
  726. default:
  727. e.encodeValue(reflect.ValueOf(iv))
  728. }
  729. }
  730. func (e *Encoder) encodeValue(rv reflect.Value) {
  731. for rv.Kind() == reflect.Ptr {
  732. if rv.IsNil() {
  733. e.e.encodeNil()
  734. return
  735. }
  736. rv = rv.Elem()
  737. }
  738. rt := rv.Type()
  739. rtid := reflect.ValueOf(rt).Pointer()
  740. // if e.f == nil && e.s == nil { debugf("---->Creating new enc f map for type: %v\n", rt) }
  741. var fn encFn
  742. var ok bool
  743. if useMapForCodecCache {
  744. fn, ok = e.f[rtid]
  745. } else {
  746. for i, v := range e.x {
  747. if v == rtid {
  748. fn, ok = e.s[i], true
  749. break
  750. }
  751. }
  752. }
  753. if !ok {
  754. // debugf("\tCreating new enc fn for type: %v\n", rt)
  755. fi := encFnInfo{ti: getTypeInfo(rtid, rt), e: e, ee: e.e}
  756. fn.i = &fi
  757. if rtid == rawExtTypId {
  758. fn.f = (*encFnInfo).rawExt
  759. } else if e.e.isBuiltinType(rtid) {
  760. fn.f = (*encFnInfo).builtin
  761. } else if xfTag, xfFn := e.h.getEncodeExt(rtid); xfFn != nil {
  762. fi.xfTag, fi.xfFn = xfTag, xfFn
  763. fn.f = (*encFnInfo).ext
  764. } else if supportBinaryMarshal && fi.ti.m {
  765. fn.f = (*encFnInfo).binaryMarshal
  766. } else {
  767. switch rk := rt.Kind(); rk {
  768. case reflect.Bool:
  769. fn.f = (*encFnInfo).kBool
  770. case reflect.String:
  771. fn.f = (*encFnInfo).kString
  772. case reflect.Float64:
  773. fn.f = (*encFnInfo).kFloat64
  774. case reflect.Float32:
  775. fn.f = (*encFnInfo).kFloat32
  776. case reflect.Int, reflect.Int8, reflect.Int64, reflect.Int32, reflect.Int16:
  777. fn.f = (*encFnInfo).kInt
  778. case reflect.Uint8, reflect.Uint64, reflect.Uint, reflect.Uint32, reflect.Uint16:
  779. fn.f = (*encFnInfo).kUint
  780. case reflect.Invalid:
  781. fn.f = (*encFnInfo).kInvalid
  782. case reflect.Slice:
  783. fn.f = (*encFnInfo).kSlice
  784. case reflect.Array:
  785. fn.f = (*encFnInfo).kArray
  786. case reflect.Struct:
  787. fn.f = (*encFnInfo).kStruct
  788. // case reflect.Ptr:
  789. // fn.f = (*encFnInfo).kPtr
  790. case reflect.Interface:
  791. fn.f = (*encFnInfo).kInterface
  792. case reflect.Map:
  793. fn.f = (*encFnInfo).kMap
  794. default:
  795. fn.f = (*encFnInfo).kErr
  796. }
  797. }
  798. if useMapForCodecCache {
  799. if e.f == nil {
  800. e.f = make(map[uintptr]encFn, 16)
  801. }
  802. e.f[rtid] = fn
  803. } else {
  804. e.s = append(e.s, fn)
  805. e.x = append(e.x, rtid)
  806. }
  807. }
  808. fn.f(fn.i, rv)
  809. }
  810. func (e *Encoder) encRawExt(re RawExt) {
  811. if re.Data == nil {
  812. e.e.encodeNil()
  813. return
  814. }
  815. if e.hh.writeExt() {
  816. e.e.encodeExtPreamble(re.Tag, len(re.Data))
  817. e.w.writeb(re.Data)
  818. } else {
  819. e.e.encodeStringBytes(c_RAW, re.Data)
  820. }
  821. }
  822. // ---------------------------------------------
  823. // short circuit functions for common maps and slices
  824. func (e *Encoder) encSliceIntf(v []interface{}) {
  825. e.e.encodeArrayPreamble(len(v))
  826. for _, v2 := range v {
  827. e.encode(v2)
  828. }
  829. }
  830. func (e *Encoder) encSliceStr(v []string) {
  831. e.e.encodeArrayPreamble(len(v))
  832. for _, v2 := range v {
  833. e.e.encodeString(c_UTF8, v2)
  834. }
  835. }
  836. func (e *Encoder) encSliceInt64(v []int64) {
  837. e.e.encodeArrayPreamble(len(v))
  838. for _, v2 := range v {
  839. e.e.encodeInt(v2)
  840. }
  841. }
  842. func (e *Encoder) encSliceUint64(v []uint64) {
  843. e.e.encodeArrayPreamble(len(v))
  844. for _, v2 := range v {
  845. e.e.encodeUint(v2)
  846. }
  847. }
  848. func (e *Encoder) encMapStrStr(v map[string]string) {
  849. e.e.encodeMapPreamble(len(v))
  850. asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
  851. for k2, v2 := range v {
  852. if asSymbols {
  853. e.e.encodeSymbol(k2)
  854. } else {
  855. e.e.encodeString(c_UTF8, k2)
  856. }
  857. e.e.encodeString(c_UTF8, v2)
  858. }
  859. }
  860. func (e *Encoder) encMapStrIntf(v map[string]interface{}) {
  861. e.e.encodeMapPreamble(len(v))
  862. asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
  863. for k2, v2 := range v {
  864. if asSymbols {
  865. e.e.encodeSymbol(k2)
  866. } else {
  867. e.e.encodeString(c_UTF8, k2)
  868. }
  869. e.encode(v2)
  870. }
  871. }
  872. func (e *Encoder) encMapInt64Intf(v map[int64]interface{}) {
  873. e.e.encodeMapPreamble(len(v))
  874. for k2, v2 := range v {
  875. e.e.encodeInt(k2)
  876. e.encode(v2)
  877. }
  878. }
  879. func (e *Encoder) encMapUint64Intf(v map[uint64]interface{}) {
  880. e.e.encodeMapPreamble(len(v))
  881. for k2, v2 := range v {
  882. e.e.encodeUint(uint64(k2))
  883. e.encode(v2)
  884. }
  885. }
  886. func (e *Encoder) encMapIntfIntf(v map[interface{}]interface{}) {
  887. e.e.encodeMapPreamble(len(v))
  888. for k2, v2 := range v {
  889. e.encode(k2)
  890. e.encode(v2)
  891. }
  892. }
  893. // ----------------------------------------
  894. func encErr(format string, params ...interface{}) {
  895. doPanic(msgTagEnc, format, params...)
  896. }