123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479 |
- // Copyright (c) 2012-2020 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"
- "io"
- "reflect"
- "sort"
- "strconv"
- "time"
- )
- // defEncByteBufSize is the default size of []byte used
- // for bufio buffer or []byte (when nil passed)
- const defEncByteBufSize = 1 << 10 // 4:16, 6:64, 8:256, 10:1024
- var errEncoderNotInitialized = errors.New("Encoder not initialized")
- // encDriver abstracts the actual codec (binc vs msgpack, etc)
- type encDriver interface {
- EncodeNil()
- EncodeInt(i int64)
- EncodeUint(i uint64)
- EncodeBool(b bool)
- EncodeFloat32(f float32)
- EncodeFloat64(f float64)
- EncodeRawExt(re *RawExt)
- EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext)
- // EncodeString using cUTF8, honor'ing StringToRaw flag
- EncodeString(v string)
- EncodeStringBytesRaw(v []byte)
- EncodeTime(time.Time)
- WriteArrayStart(length int)
- WriteArrayEnd()
- WriteMapStart(length int)
- WriteMapEnd()
- // reset will reset current encoding runtime state, and cached information from the handle
- reset()
- encoder() *Encoder
- driverStateManager
- }
- type encDriverContainerTracker interface {
- WriteArrayElem()
- WriteMapElemKey()
- WriteMapElemValue()
- }
- type encDriverNoState struct{}
- func (encDriverNoState) captureState() interface{} { return nil }
- func (encDriverNoState) reset() {}
- func (encDriverNoState) resetState() {}
- func (encDriverNoState) restoreState(v interface{}) {}
- type encDriverNoopContainerWriter struct{}
- func (encDriverNoopContainerWriter) WriteArrayStart(length int) {}
- func (encDriverNoopContainerWriter) WriteArrayEnd() {}
- func (encDriverNoopContainerWriter) WriteMapStart(length int) {}
- func (encDriverNoopContainerWriter) WriteMapEnd() {}
- // encStructFieldObj[Slice] is used for sorting when there are missing fields and canonical flag is set
- type encStructFieldObj struct {
- key string
- rv reflect.Value
- intf interface{}
- ascii bool
- isRv bool
- }
- type encStructFieldObjSlice []encStructFieldObj
- func (p encStructFieldObjSlice) Len() int { return len(p) }
- func (p encStructFieldObjSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
- func (p encStructFieldObjSlice) Less(i, j int) bool {
- return p[uint(i)].key < p[uint(j)].key
- }
- // EncodeOptions captures configuration options during encode.
- type EncodeOptions struct {
- // WriterBufferSize is the size of the buffer used when writing.
- //
- // if > 0, we use a smart buffer internally for performance purposes.
- WriterBufferSize int
- // ChanRecvTimeout is the timeout used when selecting from a chan.
- //
- // Configuring this controls how we receive from a chan during the encoding process.
- // - If ==0, we only consume the elements currently available in the chan.
- // - if <0, we consume until the chan is closed.
- // - If >0, we consume until this timeout.
- ChanRecvTimeout time.Duration
- // StructToArray specifies to encode a struct as an array, and not as a map
- StructToArray bool
- // Canonical representation means that encoding a value will always result in the same
- // sequence of bytes.
- //
- // This only affects maps, as the iteration order for maps is random.
- //
- // The implementation MAY use the natural sort order for the map keys if possible:
- //
- // - If there is a natural sort order (ie for number, bool, string or []byte keys),
- // then the map keys are first sorted in natural order and then written
- // with corresponding map values to the strema.
- // - If there is no natural sort order, then the map keys will first be
- // encoded into []byte, and then sorted,
- // before writing the sorted keys and the corresponding map values to the stream.
- //
- Canonical bool
- // CheckCircularRef controls whether we check for circular references
- // and error fast during an encode.
- //
- // If enabled, an error is received if a pointer to a struct
- // references itself either directly or through one of its fields (iteratively).
- //
- // This is opt-in, as there may be a performance hit to checking circular references.
- CheckCircularRef bool
- // RecursiveEmptyCheck controls how we determine whether a value is empty.
- //
- // If true, we descend into interfaces and pointers to reursively check if value is empty.
- //
- // We *might* check struct fields one by one to see if empty
- // (if we cannot directly check if a struct value is equal to its zero value).
- // If so, we honor IsZero, Comparable, IsCodecEmpty(), etc.
- // Note: This *may* make OmitEmpty more expensive due to the large number of reflect calls.
- //
- // If false, we check if the value is equal to its zero value (newly allocated state).
- RecursiveEmptyCheck bool
- // Raw controls whether we encode Raw values.
- // This is a "dangerous" option and must be explicitly set.
- // If set, we blindly encode Raw values as-is, without checking
- // if they are a correct representation of a value in that format.
- // If unset, we error out.
- Raw bool
- // StringToRaw controls how strings are encoded.
- //
- // As a go string is just an (immutable) sequence of bytes,
- // it can be encoded either as raw bytes or as a UTF string.
- //
- // By default, strings are encoded as UTF-8.
- // but can be treated as []byte during an encode.
- //
- // Note that things which we know (by definition) to be UTF-8
- // are ALWAYS encoded as UTF-8 strings.
- // These include encoding.TextMarshaler, time.Format calls, struct field names, etc.
- StringToRaw bool
- // OptimumSize controls whether we optimize for the smallest size.
- //
- // Some formats will use this flag to determine whether to encode
- // in the smallest size possible, even if it takes slightly longer.
- //
- // For example, some formats that support half-floats might check if it is possible
- // to store a float64 as a half float. Doing this check has a small performance cost,
- // but the benefit is that the encoded message will be smaller.
- OptimumSize bool
- // NoAddressableReadonly controls whether we try to force a non-addressable value
- // to be addressable so we can call a pointer method on it e.g. for types
- // that support Selfer, json.Marshaler, etc.
- //
- // Use it in the very rare occurrence that your types modify a pointer value when calling
- // an encode callback function e.g. JsonMarshal, TextMarshal, BinaryMarshal or CodecEncodeSelf.
- NoAddressableReadonly bool
- }
- // ---------------------------------------------
- func (e *Encoder) rawExt(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeRawExt(rv2i(rv).(*RawExt))
- }
- func (e *Encoder) ext(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn)
- }
- func (e *Encoder) selferMarshal(f *codecFnInfo, rv reflect.Value) {
- rv2i(rv).(Selfer).CodecEncodeSelf(e)
- }
- func (e *Encoder) binaryMarshal(f *codecFnInfo, rv reflect.Value) {
- bs, fnerr := rv2i(rv).(encoding.BinaryMarshaler).MarshalBinary()
- e.marshalRaw(bs, fnerr)
- }
- func (e *Encoder) textMarshal(f *codecFnInfo, rv reflect.Value) {
- bs, fnerr := rv2i(rv).(encoding.TextMarshaler).MarshalText()
- e.marshalUtf8(bs, fnerr)
- }
- func (e *Encoder) jsonMarshal(f *codecFnInfo, rv reflect.Value) {
- bs, fnerr := rv2i(rv).(jsonMarshaler).MarshalJSON()
- e.marshalAsis(bs, fnerr)
- }
- func (e *Encoder) raw(f *codecFnInfo, rv reflect.Value) {
- e.rawBytes(rv2i(rv).(Raw))
- }
- func (e *Encoder) encodeComplex64(v complex64) {
- if imag(v) != 0 {
- e.errorf("cannot encode complex number: %v, with imaginary values: %v", v, imag(v))
- }
- e.e.EncodeFloat32(real(v))
- }
- func (e *Encoder) encodeComplex128(v complex128) {
- if imag(v) != 0 {
- e.errorf("cannot encode complex number: %v, with imaginary values: %v", v, imag(v))
- }
- e.e.EncodeFloat64(real(v))
- }
- func (e *Encoder) kBool(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeBool(rvGetBool(rv))
- }
- func (e *Encoder) kTime(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeTime(rvGetTime(rv))
- }
- func (e *Encoder) kString(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeString(rvGetString(rv))
- }
- func (e *Encoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeFloat32(rvGetFloat32(rv))
- }
- func (e *Encoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeFloat64(rvGetFloat64(rv))
- }
- func (e *Encoder) kComplex64(f *codecFnInfo, rv reflect.Value) {
- e.encodeComplex64(rvGetComplex64(rv))
- }
- func (e *Encoder) kComplex128(f *codecFnInfo, rv reflect.Value) {
- e.encodeComplex128(rvGetComplex128(rv))
- }
- func (e *Encoder) kInt(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeInt(int64(rvGetInt(rv)))
- }
- func (e *Encoder) kInt8(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeInt(int64(rvGetInt8(rv)))
- }
- func (e *Encoder) kInt16(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeInt(int64(rvGetInt16(rv)))
- }
- func (e *Encoder) kInt32(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeInt(int64(rvGetInt32(rv)))
- }
- func (e *Encoder) kInt64(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeInt(int64(rvGetInt64(rv)))
- }
- func (e *Encoder) kUint(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUint(rv)))
- }
- func (e *Encoder) kUint8(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUint8(rv)))
- }
- func (e *Encoder) kUint16(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUint16(rv)))
- }
- func (e *Encoder) kUint32(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUint32(rv)))
- }
- func (e *Encoder) kUint64(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUint64(rv)))
- }
- func (e *Encoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
- e.e.EncodeUint(uint64(rvGetUintptr(rv)))
- }
- func (e *Encoder) kErr(f *codecFnInfo, rv reflect.Value) {
- e.errorf("unsupported kind %s, for %#v", rv.Kind(), rv)
- }
- func chanToSlice(rv reflect.Value, rtslice reflect.Type, timeout time.Duration) (rvcs reflect.Value) {
- rvcs = rvZeroK(rtslice, reflect.Slice)
- if timeout < 0 { // consume until close
- for {
- recv, recvOk := rv.Recv()
- if !recvOk {
- break
- }
- rvcs = reflect.Append(rvcs, recv)
- }
- } else {
- cases := make([]reflect.SelectCase, 2)
- cases[0] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: rv}
- if timeout == 0 {
- cases[1] = reflect.SelectCase{Dir: reflect.SelectDefault}
- } else {
- tt := time.NewTimer(timeout)
- cases[1] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(tt.C)}
- }
- for {
- chosen, recv, recvOk := reflect.Select(cases)
- if chosen == 1 || !recvOk {
- break
- }
- rvcs = reflect.Append(rvcs, recv)
- }
- }
- return
- }
- func (e *Encoder) kSeqFn(rtelem reflect.Type) (fn *codecFn) {
- for rtelem.Kind() == reflect.Ptr {
- rtelem = rtelem.Elem()
- }
- // if kind is reflect.Interface, do not pre-determine the encoding type,
- // because preEncodeValue may break it down to a concrete type and kInterface will bomb.
- if rtelem.Kind() != reflect.Interface {
- fn = e.h.fn(rtelem)
- }
- return
- }
- func (e *Encoder) kSliceWMbs(rv reflect.Value, ti *typeInfo) {
- var l = rvLenSlice(rv)
- if l == 0 {
- e.mapStart(0)
- } else {
- e.haltOnMbsOddLen(l)
- e.mapStart(l >> 1) // e.mapStart(l / 2)
- fn := e.kSeqFn(ti.elem)
- for j := 0; j < l; j++ {
- if j&1 == 0 { // j%2 == 0 {
- e.mapElemKey()
- } else {
- e.mapElemValue()
- }
- e.encodeValue(rvSliceIndex(rv, j, ti), fn)
- }
- }
- e.mapEnd()
- }
- func (e *Encoder) kSliceW(rv reflect.Value, ti *typeInfo) {
- var l = rvLenSlice(rv)
- e.arrayStart(l)
- if l > 0 {
- fn := e.kSeqFn(ti.elem)
- for j := 0; j < l; j++ {
- e.arrayElem()
- e.encodeValue(rvSliceIndex(rv, j, ti), fn)
- }
- }
- e.arrayEnd()
- }
- func (e *Encoder) kArrayWMbs(rv reflect.Value, ti *typeInfo) {
- var l = rv.Len()
- if l == 0 {
- e.mapStart(0)
- } else {
- e.haltOnMbsOddLen(l)
- e.mapStart(l >> 1) // e.mapStart(l / 2)
- fn := e.kSeqFn(ti.elem)
- for j := 0; j < l; j++ {
- if j&1 == 0 { // j%2 == 0 {
- e.mapElemKey()
- } else {
- e.mapElemValue()
- }
- e.encodeValue(rv.Index(j), fn)
- }
- }
- e.mapEnd()
- }
- func (e *Encoder) kArrayW(rv reflect.Value, ti *typeInfo) {
- var l = rv.Len()
- e.arrayStart(l)
- if l > 0 {
- fn := e.kSeqFn(ti.elem)
- for j := 0; j < l; j++ {
- e.arrayElem()
- e.encodeValue(rv.Index(j), fn)
- }
- }
- e.arrayEnd()
- }
- func (e *Encoder) kChan(f *codecFnInfo, rv reflect.Value) {
- if f.ti.chandir&uint8(reflect.RecvDir) == 0 {
- e.errorf("send-only channel cannot be encoded")
- }
- if !f.ti.mbs && uint8TypId == rt2id(f.ti.elem) {
- e.kSliceBytesChan(rv)
- return
- }
- rtslice := reflect.SliceOf(f.ti.elem)
- rv = chanToSlice(rv, rtslice, e.h.ChanRecvTimeout)
- ti := e.h.getTypeInfo(rt2id(rtslice), rtslice)
- if f.ti.mbs {
- e.kSliceWMbs(rv, ti)
- } else {
- e.kSliceW(rv, ti)
- }
- }
- func (e *Encoder) kSlice(f *codecFnInfo, rv reflect.Value) {
- if f.ti.mbs {
- e.kSliceWMbs(rv, f.ti)
- } else if f.ti.rtid == uint8SliceTypId || uint8TypId == rt2id(f.ti.elem) {
- e.e.EncodeStringBytesRaw(rvGetBytes(rv))
- } else {
- e.kSliceW(rv, f.ti)
- }
- }
- func (e *Encoder) kArray(f *codecFnInfo, rv reflect.Value) {
- if f.ti.mbs {
- e.kArrayWMbs(rv, f.ti)
- } else if handleBytesWithinKArray && uint8TypId == rt2id(f.ti.elem) {
- e.e.EncodeStringBytesRaw(rvGetArrayBytes(rv, []byte{}))
- } else {
- e.kArrayW(rv, f.ti)
- }
- }
- func (e *Encoder) kSliceBytesChan(rv reflect.Value) {
- // do not use range, so that the number of elements encoded
- // does not change, and encoding does not hang waiting on someone to close chan.
- bs0 := e.blist.peek(32, true)
- bs := bs0
- irv := rv2i(rv)
- ch, ok := irv.(<-chan byte)
- if !ok {
- ch = irv.(chan byte)
- }
- L1:
- switch timeout := e.h.ChanRecvTimeout; {
- case timeout == 0: // only consume available
- for {
- select {
- case b := <-ch:
- bs = append(bs, b)
- default:
- break L1
- }
- }
- case timeout > 0: // consume until timeout
- tt := time.NewTimer(timeout)
- for {
- select {
- case b := <-ch:
- bs = append(bs, b)
- case <-tt.C:
- // close(tt.C)
- break L1
- }
- }
- default: // consume until close
- for b := range ch {
- bs = append(bs, b)
- }
- }
- e.e.EncodeStringBytesRaw(bs)
- e.blist.put(bs)
- if !byteSliceSameData(bs0, bs) {
- e.blist.put(bs0)
- }
- }
- func (e *Encoder) kStructSfi(f *codecFnInfo) []*structFieldInfo {
- if e.h.Canonical {
- return f.ti.sfi.sorted()
- }
- return f.ti.sfi.source()
- }
- func (e *Encoder) kStructNoOmitempty(f *codecFnInfo, rv reflect.Value) {
- var tisfi []*structFieldInfo
- if f.ti.toArray || e.h.StructToArray { // toArray
- tisfi = f.ti.sfi.source()
- e.arrayStart(len(tisfi))
- for _, si := range tisfi {
- e.arrayElem()
- e.encodeValue(si.path.field(rv), nil)
- }
- e.arrayEnd()
- } else {
- tisfi = e.kStructSfi(f)
- e.mapStart(len(tisfi))
- keytyp := f.ti.keyType
- for _, si := range tisfi {
- e.mapElemKey()
- e.kStructFieldKey(keytyp, si.path.encNameAsciiAlphaNum, si.encName)
- e.mapElemValue()
- e.encodeValue(si.path.field(rv), nil)
- }
- e.mapEnd()
- }
- }
- func (e *Encoder) kStructFieldKey(keyType valueType, encNameAsciiAlphaNum bool, encName string) {
- encStructFieldKey(encName, e.e, e.w(), keyType, encNameAsciiAlphaNum, e.js)
- }
- func (e *Encoder) kStruct(f *codecFnInfo, rv reflect.Value) {
- var newlen int
- ti := f.ti
- toMap := !(ti.toArray || e.h.StructToArray)
- var mf map[string]interface{}
- if ti.flagMissingFielder {
- mf = rv2i(rv).(MissingFielder).CodecMissingFields()
- toMap = true
- newlen += len(mf)
- } else if ti.flagMissingFielderPtr {
- rv2 := e.addrRV(rv, ti.rt, ti.ptr)
- mf = rv2i(rv2).(MissingFielder).CodecMissingFields()
- toMap = true
- newlen += len(mf)
- }
- tisfi := ti.sfi.source()
- newlen += len(tisfi)
- var fkvs = e.slist.get(newlen)[:newlen]
- recur := e.h.RecursiveEmptyCheck
- var kv sfiRv
- var j int
- if toMap {
- newlen = 0
- for _, si := range e.kStructSfi(f) {
- kv.r = si.path.field(rv)
- if si.path.omitEmpty && isEmptyValue(kv.r, e.h.TypeInfos, recur) {
- continue
- }
- kv.v = si
- fkvs[newlen] = kv
- newlen++
- }
- var mf2s []stringIntf
- if len(mf) > 0 {
- mf2s = make([]stringIntf, 0, len(mf))
- for k, v := range mf {
- if k == "" {
- continue
- }
- if ti.infoFieldOmitempty && isEmptyValue(reflect.ValueOf(v), e.h.TypeInfos, recur) {
- continue
- }
- mf2s = append(mf2s, stringIntf{k, v})
- }
- }
- e.mapStart(newlen + len(mf2s))
- // When there are missing fields, and Canonical flag is set,
- // we cannot have the missing fields and struct fields sorted independently.
- // We have to capture them together and sort as a unit.
- if len(mf2s) > 0 && e.h.Canonical {
- mf2w := make([]encStructFieldObj, newlen+len(mf2s))
- for j = 0; j < newlen; j++ {
- kv = fkvs[j]
- mf2w[j] = encStructFieldObj{kv.v.encName, kv.r, nil, kv.v.path.encNameAsciiAlphaNum, true}
- }
- for _, v := range mf2s {
- mf2w[j] = encStructFieldObj{v.v, reflect.Value{}, v.i, false, false}
- j++
- }
- sort.Sort((encStructFieldObjSlice)(mf2w))
- for _, v := range mf2w {
- e.mapElemKey()
- e.kStructFieldKey(ti.keyType, v.ascii, v.key)
- e.mapElemValue()
- if v.isRv {
- e.encodeValue(v.rv, nil)
- } else {
- e.encode(v.intf)
- }
- }
- } else {
- keytyp := ti.keyType
- for j = 0; j < newlen; j++ {
- kv = fkvs[j]
- e.mapElemKey()
- e.kStructFieldKey(keytyp, kv.v.path.encNameAsciiAlphaNum, kv.v.encName)
- e.mapElemValue()
- e.encodeValue(kv.r, nil)
- }
- for _, v := range mf2s {
- e.mapElemKey()
- e.kStructFieldKey(keytyp, false, v.v)
- e.mapElemValue()
- e.encode(v.i)
- }
- }
- e.mapEnd()
- } else {
- newlen = len(tisfi)
- for i, si := range tisfi { // use unsorted array (to match sequence in struct)
- kv.r = si.path.field(rv)
- // use the zero value.
- // if a reference or struct, set to nil (so you do not output too much)
- if si.path.omitEmpty && isEmptyValue(kv.r, e.h.TypeInfos, recur) {
- switch kv.r.Kind() {
- case reflect.Struct, reflect.Interface, reflect.Ptr, reflect.Array, reflect.Map, reflect.Slice:
- kv.r = reflect.Value{} //encode as nil
- }
- }
- fkvs[i] = kv
- }
- // encode it all
- e.arrayStart(newlen)
- for j = 0; j < newlen; j++ {
- e.arrayElem()
- e.encodeValue(fkvs[j].r, nil)
- }
- e.arrayEnd()
- }
- // do not use defer. Instead, use explicit pool return at end of function.
- // defer has a cost we are trying to avoid.
- // If there is a panic and these slices are not returned, it is ok.
- e.slist.put(fkvs)
- }
- func (e *Encoder) kMap(f *codecFnInfo, rv reflect.Value) {
- l := rvLenMap(rv)
- e.mapStart(l)
- if l == 0 {
- e.mapEnd()
- return
- }
- // determine the underlying key and val encFn's for the map.
- // This eliminates some work which is done for each loop iteration i.e.
- // rv.Type(), ref.ValueOf(rt).Pointer(), then check map/list for fn.
- //
- // However, if kind is reflect.Interface, do not pre-determine the
- // encoding type, because preEncodeValue may break it down to
- // a concrete type and kInterface will bomb.
- var keyFn, valFn *codecFn
- ktypeKind := reflect.Kind(f.ti.keykind)
- vtypeKind := reflect.Kind(f.ti.elemkind)
- rtval := f.ti.elem
- rtvalkind := vtypeKind
- for rtvalkind == reflect.Ptr {
- rtval = rtval.Elem()
- rtvalkind = rtval.Kind()
- }
- if rtvalkind != reflect.Interface {
- valFn = e.h.fn(rtval)
- }
- var rvv = mapAddrLoopvarRV(f.ti.elem, vtypeKind)
- if e.h.Canonical {
- e.kMapCanonical(f.ti, rv, rvv, valFn)
- e.mapEnd()
- return
- }
- rtkey := f.ti.key
- var keyTypeIsString = stringTypId == rt2id(rtkey) // rtkeyid
- if !keyTypeIsString {
- for rtkey.Kind() == reflect.Ptr {
- rtkey = rtkey.Elem()
- }
- if rtkey.Kind() != reflect.Interface {
- keyFn = e.h.fn(rtkey)
- }
- }
- var rvk = mapAddrLoopvarRV(f.ti.key, ktypeKind)
- var it mapIter
- mapRange(&it, rv, rvk, rvv, true)
- for it.Next() {
- e.mapElemKey()
- if keyTypeIsString {
- e.e.EncodeString(it.Key().String())
- } else {
- e.encodeValue(it.Key(), keyFn)
- }
- e.mapElemValue()
- e.encodeValue(it.Value(), valFn)
- }
- it.Done()
- e.mapEnd()
- }
- func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, valFn *codecFn) {
- // we previously did out-of-band if an extension was registered.
- // This is not necessary, as the natural kind is sufficient for ordering.
- rtkey := ti.key
- mks := rv.MapKeys()
- rtkeyKind := rtkey.Kind()
- kfast := mapKeyFastKindFor(rtkeyKind)
- visindirect := mapStoresElemIndirect(uintptr(ti.elemsize))
- visref := refBitset.isset(ti.elemkind)
- switch rtkeyKind {
- case reflect.Bool:
- mksv := make([]boolRv, len(mks))
- for i, k := range mks {
- v := &mksv[i]
- v.r = k
- v.v = k.Bool()
- }
- sort.Sort(boolRvSlice(mksv))
- for i := range mksv {
- e.mapElemKey()
- e.e.EncodeBool(mksv[i].v)
- e.mapElemValue()
- e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
- }
- case reflect.String:
- mksv := make([]stringRv, len(mks))
- for i, k := range mks {
- v := &mksv[i]
- v.r = k
- v.v = k.String()
- }
- sort.Sort(stringRvSlice(mksv))
- for i := range mksv {
- e.mapElemKey()
- e.e.EncodeString(mksv[i].v)
- e.mapElemValue()
- e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
- }
- case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr:
- mksv := make([]uint64Rv, len(mks))
- for i, k := range mks {
- v := &mksv[i]
- v.r = k
- v.v = k.Uint()
- }
- sort.Sort(uint64RvSlice(mksv))
- for i := range mksv {
- e.mapElemKey()
- e.e.EncodeUint(mksv[i].v)
- e.mapElemValue()
- e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
- }
- case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
- mksv := make([]int64Rv, len(mks))
- for i, k := range mks {
- v := &mksv[i]
- v.r = k
- v.v = k.Int()
- }
- sort.Sort(int64RvSlice(mksv))
- for i := range mksv {
- e.mapElemKey()
- e.e.EncodeInt(mksv[i].v)
- e.mapElemValue()
- e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
- }
- case reflect.Float32:
- mksv := make([]float64Rv, len(mks))
- for i, k := range mks {
- v := &mksv[i]
- v.r = k
- v.v = k.Float()
- }
- sort.Sort(float64RvSlice(mksv))
- for i := range mksv {
- e.mapElemKey()
- e.e.EncodeFloat32(float32(mksv[i].v))
- e.mapElemValue()
- e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
- }
- case reflect.Float64:
- mksv := make([]float64Rv, len(mks))
- for i, k := range mks {
- v := &mksv[i]
- v.r = k
- v.v = k.Float()
- }
- sort.Sort(float64RvSlice(mksv))
- for i := range mksv {
- e.mapElemKey()
- e.e.EncodeFloat64(mksv[i].v)
- e.mapElemValue()
- e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
- }
- case reflect.Struct:
- if rtkey == timeTyp {
- mksv := make([]timeRv, len(mks))
- for i, k := range mks {
- v := &mksv[i]
- v.r = k
- v.v = rv2i(k).(time.Time)
- }
- sort.Sort(timeRvSlice(mksv))
- for i := range mksv {
- e.mapElemKey()
- e.e.EncodeTime(mksv[i].v)
- e.mapElemValue()
- e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
- }
- break
- }
- fallthrough
- default:
- // out-of-band
- // first encode each key to a []byte first, then sort them, then record
- bs0 := e.blist.get(len(mks) * 16)
- mksv := bs0
- mksbv := make([]bytesRv, len(mks))
- func() {
- // replicate sideEncode logic
- defer func(wb bytesEncAppender, bytes bool, c containerState, state interface{}) {
- e.wb = wb
- e.bytes = bytes
- e.c = c
- e.e.restoreState(state)
- }(e.wb, e.bytes, e.c, e.e.captureState())
- // e2 := NewEncoderBytes(&mksv, e.hh)
- e.wb = bytesEncAppender{mksv[:0], &mksv}
- e.bytes = true
- e.c = 0
- e.e.resetState()
- for i, k := range mks {
- v := &mksbv[i]
- l := len(mksv)
- e.encodeValue(k, nil)
- e.atEndOfEncode()
- e.w().end()
- v.r = k
- v.v = mksv[l:]
- }
- }()
- sort.Sort(bytesRvSlice(mksbv))
- for j := range mksbv {
- e.mapElemKey()
- e.encWr.writeb(mksbv[j].v)
- e.mapElemValue()
- e.encodeValue(mapGet(rv, mksbv[j].r, rvv, kfast, visindirect, visref), valFn)
- }
- e.blist.put(mksv)
- if !byteSliceSameData(bs0, mksv) {
- e.blist.put(bs0)
- }
- }
- }
- // Encoder writes an object to an output stream in a supported format.
- //
- // Encoder is NOT safe for concurrent use i.e. a Encoder cannot be used
- // concurrently in multiple goroutines.
- //
- // However, as Encoder could be allocation heavy to initialize, a Reset method is provided
- // so its state can be reused to decode new input streams repeatedly.
- // This is the idiomatic way to use.
- type Encoder struct {
- panicHdl
- e encDriver
- h *BasicHandle
- // hopefully, reduce derefencing cost by laying the encWriter inside the Encoder
- encWr
- // ---- cpu cache line boundary
- hh Handle
- blist bytesFreelist
- err error
- // ---- cpu cache line boundary
- // ---- writable fields during execution --- *try* to keep in sep cache line
- // ci holds interfaces during an encoding (if CheckCircularRef=true)
- //
- // We considered using a []uintptr (slice of pointer addresses) retrievable via rv.UnsafeAddr.
- // However, it is possible for the same pointer to point to 2 different types e.g.
- // type T struct { tHelper }
- // Here, for var v T; &v and &v.tHelper are the same pointer.
- // Consequently, we need a tuple of type and pointer, which interface{} natively provides.
- ci []interface{} // []uintptr
- perType encPerType
- slist sfiRvFreelist
- }
- // NewEncoder returns an Encoder for encoding into an io.Writer.
- //
- // For efficiency, Users are encouraged to configure WriterBufferSize on the handle
- // OR pass in a memory buffered writer (eg bufio.Writer, bytes.Buffer).
- func NewEncoder(w io.Writer, h Handle) *Encoder {
- e := h.newEncDriver().encoder()
- if w != nil {
- e.Reset(w)
- }
- return e
- }
- // NewEncoderBytes returns an encoder for encoding directly and efficiently
- // into a byte slice, using zero-copying to temporary slices.
- //
- // It will potentially replace the output byte slice pointed to.
- // After encoding, the out parameter contains the encoded contents.
- func NewEncoderBytes(out *[]byte, h Handle) *Encoder {
- e := h.newEncDriver().encoder()
- if out != nil {
- e.ResetBytes(out)
- }
- return e
- }
- func (e *Encoder) init(h Handle) {
- initHandle(h)
- e.err = errEncoderNotInitialized
- e.bytes = true
- e.hh = h
- e.h = h.getBasicHandle()
- e.be = e.hh.isBinary()
- }
- func (e *Encoder) w() *encWr {
- return &e.encWr
- }
- func (e *Encoder) resetCommon() {
- e.e.reset()
- if e.ci != nil {
- e.ci = e.ci[:0]
- }
- e.c = 0
- e.calls = 0
- e.seq = 0
- e.err = nil
- }
- // Reset resets the Encoder with a new output stream.
- //
- // This accommodates using the state of the Encoder,
- // where it has "cached" information about sub-engines.
- func (e *Encoder) Reset(w io.Writer) {
- e.bytes = false
- if e.wf == nil {
- e.wf = new(bufioEncWriter)
- }
- e.wf.reset(w, e.h.WriterBufferSize, &e.blist)
- e.resetCommon()
- }
- // ResetBytes resets the Encoder with a new destination output []byte.
- func (e *Encoder) ResetBytes(out *[]byte) {
- e.bytes = true
- e.wb.reset(encInBytes(out), out)
- e.resetCommon()
- }
- // Encode writes an object into a stream.
- //
- // Encoding can be configured via the struct tag for the fields.
- // The key (in the struct tags) that we look at is configurable.
- //
- // By default, we look up the "codec" key in the struct field's tags,
- // and fall bak to the "json" key if "codec" is absent.
- // That key in struct field's tag value is the key name,
- // followed by an optional comma and options.
- //
- // To set an option on all fields (e.g. omitempty on all fields), you
- // can create a field called _struct, and set flags on it. The options
- // which can be set on _struct are:
- // - omitempty: so all fields are omitted if empty
- // - toarray: so struct is encoded as an array
- // - int: so struct key names are encoded as signed integers (instead of strings)
- // - uint: so struct key names are encoded as unsigned integers (instead of strings)
- // - float: so struct key names are encoded as floats (instead of strings)
- // More details on these below.
- //
- // Struct values "usually" encode as maps. Each exported struct field is encoded unless:
- // - the field's tag is "-", OR
- // - the field is empty (empty or the zero value) and its tag specifies the "omitempty" option.
- //
- // When encoding as a map, the first string in the tag (before the comma)
- // is the map key string to use when encoding.
- // ...
- // This key is typically encoded as a string.
- // However, there are instances where the encoded stream has mapping keys encoded as numbers.
- // For example, some cbor streams have keys as integer codes in the stream, but they should map
- // to fields in a structured object. Consequently, a struct is the natural representation in code.
- // For these, configure the struct to encode/decode the keys as numbers (instead of string).
- // This is done with the int,uint or float option on the _struct field (see above).
- //
- // However, struct values may encode as arrays. This happens when:
- // - StructToArray Encode option is set, OR
- // - the tag on the _struct field sets the "toarray" option
- // Note that omitempty is ignored when encoding struct values as arrays,
- // as an entry must be encoded for each field, to maintain its position.
- //
- // Values with types that implement MapBySlice are encoded as stream maps.
- //
- // The empty values (for omitempty option) are false, 0, any nil pointer
- // or interface value, and any array, slice, map, or string of length zero.
- //
- // Anonymous fields are encoded inline except:
- // - the struct tag specifies a replacement name (first value)
- // - the field is of an interface type
- //
- // Examples:
- //
- // // NOTE: 'json:' can be used as struct tag key, in place 'codec:' below.
- // type MyStruct struct {
- // _struct bool `codec:",omitempty"` //set omitempty for every field
- // Field1 string `codec:"-"` //skip this field
- // Field2 int `codec:"myName"` //Use key "myName" in encode stream
- // Field3 int32 `codec:",omitempty"` //use key "Field3". Omit if empty.
- // Field4 bool `codec:"f4,omitempty"` //use key "f4". Omit if empty.
- // io.Reader //use key "Reader".
- // MyStruct `codec:"my1" //use key "my1".
- // MyStruct //inline it
- // ...
- // }
- //
- // type MyStruct struct {
- // _struct bool `codec:",toarray"` //encode struct as an array
- // }
- //
- // type MyStruct struct {
- // _struct bool `codec:",uint"` //encode struct with "unsigned integer" keys
- // Field1 string `codec:"1"` //encode Field1 key using: EncodeInt(1)
- // Field2 string `codec:"2"` //encode Field2 key using: EncodeInt(2)
- // }
- //
- // The mode of encoding is based on the type of the value. When a value is seen:
- // - If a Selfer, call its CodecEncodeSelf method
- // - If an extension is registered for it, call that extension function
- // - If implements encoding.(Binary|Text|JSON)Marshaler, call Marshal(Binary|Text|JSON) method
- // - Else encode it based on its reflect.Kind
- //
- // Note that struct field names and keys in map[string]XXX will be treated as symbols.
- // Some formats support symbols (e.g. binc) and will properly encode the string
- // only once in the stream, and use a tag to refer to it thereafter.
- func (e *Encoder) Encode(v interface{}) (err error) {
- // tried to use closure, as runtime optimizes defer with no params.
- // This seemed to be causing weird issues (like circular reference found, unexpected panic, etc).
- // Also, see https://github.com/golang/go/issues/14939#issuecomment-417836139
- if !debugging {
- defer func() {
- // if error occurred during encoding, return that error;
- // else if error occurred on end'ing (i.e. during flush), return that error.
- if x := recover(); x != nil {
- panicValToErr(e, x, &e.err)
- err = e.err
- }
- }()
- }
- e.MustEncode(v)
- return
- }
- // MustEncode is like Encode, but panics if unable to Encode.
- //
- // Note: This provides insight to the code location that triggered the error.
- func (e *Encoder) MustEncode(v interface{}) {
- halt.onerror(e.err)
- if e.hh == nil {
- halt.onerror(errNoFormatHandle)
- }
- e.calls++
- e.encode(v)
- e.calls--
- if e.calls == 0 {
- e.atEndOfEncode()
- e.w().end()
- }
- }
- // Release releases shared (pooled) resources.
- //
- // It is important to call Release() when done with an Encoder, so those resources
- // are released instantly for use by subsequently created Encoders.
- //
- // Deprecated: Release is a no-op as pooled resources are not used with an Encoder.
- // This method is kept for compatibility reasons only.
- func (e *Encoder) Release() {
- }
- func (e *Encoder) encode(iv interface{}) {
- // MARKER: a switch with only concrete types can be optimized.
- // consequently, we deal with nil and interfaces outside the switch.
- if iv == nil {
- e.e.EncodeNil()
- return
- }
- rv, ok := isNil(iv)
- if ok {
- e.e.EncodeNil()
- return
- }
- switch v := iv.(type) {
- // case nil:
- // case Selfer:
- case Raw:
- e.rawBytes(v)
- case reflect.Value:
- e.encodeValue(v, nil)
- case string:
- e.e.EncodeString(v)
- case bool:
- e.e.EncodeBool(v)
- case int:
- e.e.EncodeInt(int64(v))
- case int8:
- e.e.EncodeInt(int64(v))
- case int16:
- e.e.EncodeInt(int64(v))
- case int32:
- e.e.EncodeInt(int64(v))
- case int64:
- e.e.EncodeInt(v)
- case uint:
- e.e.EncodeUint(uint64(v))
- case uint8:
- e.e.EncodeUint(uint64(v))
- case uint16:
- e.e.EncodeUint(uint64(v))
- case uint32:
- e.e.EncodeUint(uint64(v))
- case uint64:
- e.e.EncodeUint(v)
- case uintptr:
- e.e.EncodeUint(uint64(v))
- case float32:
- e.e.EncodeFloat32(v)
- case float64:
- e.e.EncodeFloat64(v)
- case complex64:
- e.encodeComplex64(v)
- case complex128:
- e.encodeComplex128(v)
- case time.Time:
- e.e.EncodeTime(v)
- case []byte:
- e.e.EncodeStringBytesRaw(v)
- case *Raw:
- e.rawBytes(*v)
- case *string:
- e.e.EncodeString(*v)
- case *bool:
- e.e.EncodeBool(*v)
- case *int:
- e.e.EncodeInt(int64(*v))
- case *int8:
- e.e.EncodeInt(int64(*v))
- case *int16:
- e.e.EncodeInt(int64(*v))
- case *int32:
- e.e.EncodeInt(int64(*v))
- case *int64:
- e.e.EncodeInt(*v)
- case *uint:
- e.e.EncodeUint(uint64(*v))
- case *uint8:
- e.e.EncodeUint(uint64(*v))
- case *uint16:
- e.e.EncodeUint(uint64(*v))
- case *uint32:
- e.e.EncodeUint(uint64(*v))
- case *uint64:
- e.e.EncodeUint(*v)
- case *uintptr:
- e.e.EncodeUint(uint64(*v))
- case *float32:
- e.e.EncodeFloat32(*v)
- case *float64:
- e.e.EncodeFloat64(*v)
- case *complex64:
- e.encodeComplex64(*v)
- case *complex128:
- e.encodeComplex128(*v)
- case *time.Time:
- e.e.EncodeTime(*v)
- case *[]byte:
- if *v == nil {
- e.e.EncodeNil()
- } else {
- e.e.EncodeStringBytesRaw(*v)
- }
- default:
- // we can't check non-predefined types, as they might be a Selfer or extension.
- if skipFastpathTypeSwitchInDirectCall || !fastpathEncodeTypeSwitch(iv, e) {
- e.encodeValue(rv, nil)
- }
- }
- }
- // encodeValue will encode a value.
- //
- // Note that encodeValue will handle nil in the stream early, so that the
- // subsequent calls i.e. kXXX methods, etc do not have to handle it themselves.
- func (e *Encoder) encodeValue(rv reflect.Value, fn *codecFn) {
- // if a valid fn is passed, it MUST BE for the dereferenced type of rv
- // MARKER: We check if value is nil here, so that the kXXX method do not have to.
- var sptr interface{}
- var rvp reflect.Value
- var rvpValid bool
- TOP:
- switch rv.Kind() {
- case reflect.Ptr:
- if rvIsNil(rv) {
- e.e.EncodeNil()
- return
- }
- rvpValid = true
- rvp = rv
- rv = rv.Elem()
- goto TOP
- case reflect.Interface:
- if rvIsNil(rv) {
- e.e.EncodeNil()
- return
- }
- rvpValid = false
- rvp = reflect.Value{}
- rv = rv.Elem()
- goto TOP
- case reflect.Struct:
- if rvpValid && e.h.CheckCircularRef {
- sptr = rv2i(rvp)
- for _, vv := range e.ci {
- if eq4i(sptr, vv) { // error if sptr already seen
- e.errorf("circular reference found: %p, %T", sptr, sptr)
- }
- }
- e.ci = append(e.ci, sptr)
- }
- case reflect.Slice, reflect.Map, reflect.Chan:
- if rvIsNil(rv) {
- e.e.EncodeNil()
- return
- }
- case reflect.Invalid, reflect.Func:
- e.e.EncodeNil()
- return
- }
- if fn == nil {
- fn = e.h.fn(rvType(rv))
- }
- if !fn.i.addrE { // typically, addrE = false, so check it first
- // keep rv same
- } else if rvpValid {
- rv = rvp
- } else {
- rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr)
- }
- fn.fe(e, &fn.i, rv)
- if sptr != nil { // remove sptr
- e.ci = e.ci[:len(e.ci)-1]
- }
- }
- // addrRV returns a addressable value which may be readonly
- func (e *Encoder) addrRV(rv reflect.Value, typ, ptrType reflect.Type) (rva reflect.Value) {
- if rv.CanAddr() {
- return rvAddr(rv, ptrType)
- }
- if e.h.NoAddressableReadonly {
- rva = reflect.New(typ)
- rvSetDirect(rva.Elem(), rv)
- return
- }
- return rvAddr(e.perType.AddressableRO(rv), ptrType)
- }
- func (e *Encoder) marshalUtf8(bs []byte, fnerr error) {
- e.onerror(fnerr)
- if bs == nil {
- e.e.EncodeNil()
- } else {
- e.e.EncodeString(stringView(bs))
- }
- }
- func (e *Encoder) marshalAsis(bs []byte, fnerr error) {
- e.onerror(fnerr)
- if bs == nil {
- e.e.EncodeNil()
- } else {
- e.encWr.writeb(bs) // e.asis(bs)
- }
- }
- func (e *Encoder) marshalRaw(bs []byte, fnerr error) {
- e.onerror(fnerr)
- if bs == nil {
- e.e.EncodeNil()
- } else {
- e.e.EncodeStringBytesRaw(bs)
- }
- }
- func (e *Encoder) rawBytes(vv Raw) {
- v := []byte(vv)
- if !e.h.Raw {
- e.errorf("Raw values cannot be encoded: %v", v)
- }
- e.encWr.writeb(v)
- }
- func (e *Encoder) wrapErr(v error, err *error) {
- *err = wrapCodecErr(v, e.hh.Name(), 0, true)
- }
- // ---- container tracker methods
- // Note: We update the .c after calling the callback.
- // This way, the callback can know what the last status was.
- func (e *Encoder) mapStart(length int) {
- e.e.WriteMapStart(length)
- e.c = containerMapStart
- }
- func (e *Encoder) mapElemKey() {
- if e.js {
- e.jsondriver().WriteMapElemKey()
- }
- e.c = containerMapKey
- }
- func (e *Encoder) mapElemValue() {
- if e.js {
- e.jsondriver().WriteMapElemValue()
- }
- e.c = containerMapValue
- }
- func (e *Encoder) mapEnd() {
- e.e.WriteMapEnd()
- e.c = 0
- }
- func (e *Encoder) arrayStart(length int) {
- e.e.WriteArrayStart(length)
- e.c = containerArrayStart
- }
- func (e *Encoder) arrayElem() {
- if e.js {
- e.jsondriver().WriteArrayElem()
- }
- e.c = containerArrayElem
- }
- func (e *Encoder) arrayEnd() {
- e.e.WriteArrayEnd()
- e.c = 0
- }
- // ----------
- func (e *Encoder) haltOnMbsOddLen(length int) {
- if length&1 != 0 { // similar to &1==1 or %2 == 1
- e.errorf("mapBySlice requires even slice length, but got %v", length)
- }
- }
- func (e *Encoder) atEndOfEncode() {
- // e.e.atEndOfEncode()
- if e.js {
- e.jsondriver().atEndOfEncode()
- }
- }
- func (e *Encoder) sideEncode(v interface{}, basetype reflect.Type, bs *[]byte) {
- // rv := baseRV(v)
- // e2 := NewEncoderBytes(bs, e.hh)
- // e2.encodeValue(rv, e2.h.fnNoExt(basetype))
- // e2.atEndOfEncode()
- // e2.w().end()
- defer func(wb bytesEncAppender, bytes bool, c containerState, state interface{}) {
- e.wb = wb
- e.bytes = bytes
- e.c = c
- e.e.restoreState(state)
- }(e.wb, e.bytes, e.c, e.e.captureState())
- e.wb = bytesEncAppender{encInBytes(bs)[:0], bs}
- e.bytes = true
- e.c = 0
- e.e.resetState()
- // must call using fnNoExt
- rv := baseRV(v)
- e.encodeValue(rv, e.h.fnNoExt(basetype))
- e.atEndOfEncode()
- e.w().end()
- }
- func encInBytes(out *[]byte) (in []byte) {
- in = *out
- if in == nil {
- in = make([]byte, defEncByteBufSize)
- }
- return
- }
- func encStructFieldKey(encName string, ee encDriver, w *encWr,
- keyType valueType, encNameAsciiAlphaNum bool, js bool) {
- // use if-else-if, not switch (which compiles to binary-search)
- // since keyType is typically valueTypeString, branch prediction is pretty good.
- if keyType == valueTypeString {
- if js && encNameAsciiAlphaNum { // keyType == valueTypeString
- w.writeqstr(encName)
- } else { // keyType == valueTypeString
- ee.EncodeString(encName)
- }
- } else if keyType == valueTypeInt {
- ee.EncodeInt(must.Int(strconv.ParseInt(encName, 10, 64)))
- } else if keyType == valueTypeUint {
- ee.EncodeUint(must.Uint(strconv.ParseUint(encName, 10, 64)))
- } else if keyType == valueTypeFloat {
- ee.EncodeFloat64(must.Float(strconv.ParseFloat(encName, 64)))
- } else {
- halt.errorf("invalid struct key type: %v", keyType)
- }
- }
|