Source file src/github.com/ugorji/go/codec/encode.go

Documentation: github.com/ugorji/go/codec

     1  // Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
     2  // Use of this source code is governed by a MIT license found in the LICENSE file.
     3  
     4  package codec
     5  
     6  import (
     7  	"encoding"
     8  	"errors"
     9  	"io"
    10  	"reflect"
    11  	"sort"
    12  	"strconv"
    13  	"time"
    14  )
    15  
    16  // defEncByteBufSize is the default size of []byte used
    17  // for bufio buffer or []byte (when nil passed)
    18  const defEncByteBufSize = 1 << 10 // 4:16, 6:64, 8:256, 10:1024
    19  
    20  var errEncoderNotInitialized = errors.New("Encoder not initialized")
    21  
    22  // encDriver abstracts the actual codec (binc vs msgpack, etc)
    23  type encDriver interface {
    24  	EncodeNil()
    25  	EncodeInt(i int64)
    26  	EncodeUint(i uint64)
    27  	EncodeBool(b bool)
    28  	EncodeFloat32(f float32)
    29  	EncodeFloat64(f float64)
    30  	EncodeRawExt(re *RawExt)
    31  	EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext)
    32  	// EncodeString using cUTF8, honor'ing StringToRaw flag
    33  	EncodeString(v string)
    34  	EncodeStringBytesRaw(v []byte)
    35  	EncodeTime(time.Time)
    36  	WriteArrayStart(length int)
    37  	WriteArrayEnd()
    38  	WriteMapStart(length int)
    39  	WriteMapEnd()
    40  
    41  	// reset will reset current encoding runtime state, and cached information from the handle
    42  	reset()
    43  
    44  	encoder() *Encoder
    45  
    46  	driverStateManager
    47  }
    48  
    49  type encDriverContainerTracker interface {
    50  	WriteArrayElem()
    51  	WriteMapElemKey()
    52  	WriteMapElemValue()
    53  }
    54  
    55  type encDriverNoState struct{}
    56  
    57  func (encDriverNoState) captureState() interface{}  { return nil }
    58  func (encDriverNoState) reset()                     {}
    59  func (encDriverNoState) resetState()                {}
    60  func (encDriverNoState) restoreState(v interface{}) {}
    61  
    62  type encDriverNoopContainerWriter struct{}
    63  
    64  func (encDriverNoopContainerWriter) WriteArrayStart(length int) {}
    65  func (encDriverNoopContainerWriter) WriteArrayEnd()             {}
    66  func (encDriverNoopContainerWriter) WriteMapStart(length int)   {}
    67  func (encDriverNoopContainerWriter) WriteMapEnd()               {}
    68  
    69  // encStructFieldObj[Slice] is used for sorting when there are missing fields and canonical flag is set
    70  type encStructFieldObj struct {
    71  	key   string
    72  	rv    reflect.Value
    73  	intf  interface{}
    74  	ascii bool
    75  	isRv  bool
    76  }
    77  
    78  type encStructFieldObjSlice []encStructFieldObj
    79  
    80  func (p encStructFieldObjSlice) Len() int      { return len(p) }
    81  func (p encStructFieldObjSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
    82  func (p encStructFieldObjSlice) Less(i, j int) bool {
    83  	return p[uint(i)].key < p[uint(j)].key
    84  }
    85  
    86  // EncodeOptions captures configuration options during encode.
    87  type EncodeOptions struct {
    88  	// WriterBufferSize is the size of the buffer used when writing.
    89  	//
    90  	// if > 0, we use a smart buffer internally for performance purposes.
    91  	WriterBufferSize int
    92  
    93  	// ChanRecvTimeout is the timeout used when selecting from a chan.
    94  	//
    95  	// Configuring this controls how we receive from a chan during the encoding process.
    96  	//   - If ==0, we only consume the elements currently available in the chan.
    97  	//   - if  <0, we consume until the chan is closed.
    98  	//   - If  >0, we consume until this timeout.
    99  	ChanRecvTimeout time.Duration
   100  
   101  	// StructToArray specifies to encode a struct as an array, and not as a map
   102  	StructToArray bool
   103  
   104  	// Canonical representation means that encoding a value will always result in the same
   105  	// sequence of bytes.
   106  	//
   107  	// This only affects maps, as the iteration order for maps is random.
   108  	//
   109  	// The implementation MAY use the natural sort order for the map keys if possible:
   110  	//
   111  	//     - If there is a natural sort order (ie for number, bool, string or []byte keys),
   112  	//       then the map keys are first sorted in natural order and then written
   113  	//       with corresponding map values to the strema.
   114  	//     - If there is no natural sort order, then the map keys will first be
   115  	//       encoded into []byte, and then sorted,
   116  	//       before writing the sorted keys and the corresponding map values to the stream.
   117  	//
   118  	Canonical bool
   119  
   120  	// CheckCircularRef controls whether we check for circular references
   121  	// and error fast during an encode.
   122  	//
   123  	// If enabled, an error is received if a pointer to a struct
   124  	// references itself either directly or through one of its fields (iteratively).
   125  	//
   126  	// This is opt-in, as there may be a performance hit to checking circular references.
   127  	CheckCircularRef bool
   128  
   129  	// RecursiveEmptyCheck controls how we determine whether a value is empty.
   130  	//
   131  	// If true, we descend into interfaces and pointers to reursively check if value is empty.
   132  	//
   133  	// We *might* check struct fields one by one to see if empty
   134  	// (if we cannot directly check if a struct value is equal to its zero value).
   135  	// If so, we honor IsZero, Comparable, IsCodecEmpty(), etc.
   136  	// Note: This *may* make OmitEmpty more expensive due to the large number of reflect calls.
   137  	//
   138  	// If false, we check if the value is equal to its zero value (newly allocated state).
   139  	RecursiveEmptyCheck bool
   140  
   141  	// Raw controls whether we encode Raw values.
   142  	// This is a "dangerous" option and must be explicitly set.
   143  	// If set, we blindly encode Raw values as-is, without checking
   144  	// if they are a correct representation of a value in that format.
   145  	// If unset, we error out.
   146  	Raw bool
   147  
   148  	// StringToRaw controls how strings are encoded.
   149  	//
   150  	// As a go string is just an (immutable) sequence of bytes,
   151  	// it can be encoded either as raw bytes or as a UTF string.
   152  	//
   153  	// By default, strings are encoded as UTF-8.
   154  	// but can be treated as []byte during an encode.
   155  	//
   156  	// Note that things which we know (by definition) to be UTF-8
   157  	// are ALWAYS encoded as UTF-8 strings.
   158  	// These include encoding.TextMarshaler, time.Format calls, struct field names, etc.
   159  	StringToRaw bool
   160  
   161  	// OptimumSize controls whether we optimize for the smallest size.
   162  	//
   163  	// Some formats will use this flag to determine whether to encode
   164  	// in the smallest size possible, even if it takes slightly longer.
   165  	//
   166  	// For example, some formats that support half-floats might check if it is possible
   167  	// to store a float64 as a half float. Doing this check has a small performance cost,
   168  	// but the benefit is that the encoded message will be smaller.
   169  	OptimumSize bool
   170  
   171  	// NoAddressableReadonly controls whether we try to force a non-addressable value
   172  	// to be addressable so we can call a pointer method on it e.g. for types
   173  	// that support Selfer, json.Marshaler, etc.
   174  	//
   175  	// Use it in the very rare occurrence that your types modify a pointer value when calling
   176  	// an encode callback function e.g. JsonMarshal, TextMarshal, BinaryMarshal or CodecEncodeSelf.
   177  	NoAddressableReadonly bool
   178  }
   179  
   180  // ---------------------------------------------
   181  
   182  func (e *Encoder) rawExt(f *codecFnInfo, rv reflect.Value) {
   183  	e.e.EncodeRawExt(rv2i(rv).(*RawExt))
   184  }
   185  
   186  func (e *Encoder) ext(f *codecFnInfo, rv reflect.Value) {
   187  	e.e.EncodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn)
   188  }
   189  
   190  func (e *Encoder) selferMarshal(f *codecFnInfo, rv reflect.Value) {
   191  	rv2i(rv).(Selfer).CodecEncodeSelf(e)
   192  }
   193  
   194  func (e *Encoder) binaryMarshal(f *codecFnInfo, rv reflect.Value) {
   195  	bs, fnerr := rv2i(rv).(encoding.BinaryMarshaler).MarshalBinary()
   196  	e.marshalRaw(bs, fnerr)
   197  }
   198  
   199  func (e *Encoder) textMarshal(f *codecFnInfo, rv reflect.Value) {
   200  	bs, fnerr := rv2i(rv).(encoding.TextMarshaler).MarshalText()
   201  	e.marshalUtf8(bs, fnerr)
   202  }
   203  
   204  func (e *Encoder) jsonMarshal(f *codecFnInfo, rv reflect.Value) {
   205  	bs, fnerr := rv2i(rv).(jsonMarshaler).MarshalJSON()
   206  	e.marshalAsis(bs, fnerr)
   207  }
   208  
   209  func (e *Encoder) raw(f *codecFnInfo, rv reflect.Value) {
   210  	e.rawBytes(rv2i(rv).(Raw))
   211  }
   212  
   213  func (e *Encoder) encodeComplex64(v complex64) {
   214  	if imag(v) != 0 {
   215  		e.errorf("cannot encode complex number: %v, with imaginary values: %v", v, imag(v))
   216  	}
   217  	e.e.EncodeFloat32(real(v))
   218  }
   219  
   220  func (e *Encoder) encodeComplex128(v complex128) {
   221  	if imag(v) != 0 {
   222  		e.errorf("cannot encode complex number: %v, with imaginary values: %v", v, imag(v))
   223  	}
   224  	e.e.EncodeFloat64(real(v))
   225  }
   226  
   227  func (e *Encoder) kBool(f *codecFnInfo, rv reflect.Value) {
   228  	e.e.EncodeBool(rvGetBool(rv))
   229  }
   230  
   231  func (e *Encoder) kTime(f *codecFnInfo, rv reflect.Value) {
   232  	e.e.EncodeTime(rvGetTime(rv))
   233  }
   234  
   235  func (e *Encoder) kString(f *codecFnInfo, rv reflect.Value) {
   236  	e.e.EncodeString(rvGetString(rv))
   237  }
   238  
   239  func (e *Encoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
   240  	e.e.EncodeFloat32(rvGetFloat32(rv))
   241  }
   242  
   243  func (e *Encoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
   244  	e.e.EncodeFloat64(rvGetFloat64(rv))
   245  }
   246  
   247  func (e *Encoder) kComplex64(f *codecFnInfo, rv reflect.Value) {
   248  	e.encodeComplex64(rvGetComplex64(rv))
   249  }
   250  
   251  func (e *Encoder) kComplex128(f *codecFnInfo, rv reflect.Value) {
   252  	e.encodeComplex128(rvGetComplex128(rv))
   253  }
   254  
   255  func (e *Encoder) kInt(f *codecFnInfo, rv reflect.Value) {
   256  	e.e.EncodeInt(int64(rvGetInt(rv)))
   257  }
   258  
   259  func (e *Encoder) kInt8(f *codecFnInfo, rv reflect.Value) {
   260  	e.e.EncodeInt(int64(rvGetInt8(rv)))
   261  }
   262  
   263  func (e *Encoder) kInt16(f *codecFnInfo, rv reflect.Value) {
   264  	e.e.EncodeInt(int64(rvGetInt16(rv)))
   265  }
   266  
   267  func (e *Encoder) kInt32(f *codecFnInfo, rv reflect.Value) {
   268  	e.e.EncodeInt(int64(rvGetInt32(rv)))
   269  }
   270  
   271  func (e *Encoder) kInt64(f *codecFnInfo, rv reflect.Value) {
   272  	e.e.EncodeInt(int64(rvGetInt64(rv)))
   273  }
   274  
   275  func (e *Encoder) kUint(f *codecFnInfo, rv reflect.Value) {
   276  	e.e.EncodeUint(uint64(rvGetUint(rv)))
   277  }
   278  
   279  func (e *Encoder) kUint8(f *codecFnInfo, rv reflect.Value) {
   280  	e.e.EncodeUint(uint64(rvGetUint8(rv)))
   281  }
   282  
   283  func (e *Encoder) kUint16(f *codecFnInfo, rv reflect.Value) {
   284  	e.e.EncodeUint(uint64(rvGetUint16(rv)))
   285  }
   286  
   287  func (e *Encoder) kUint32(f *codecFnInfo, rv reflect.Value) {
   288  	e.e.EncodeUint(uint64(rvGetUint32(rv)))
   289  }
   290  
   291  func (e *Encoder) kUint64(f *codecFnInfo, rv reflect.Value) {
   292  	e.e.EncodeUint(uint64(rvGetUint64(rv)))
   293  }
   294  
   295  func (e *Encoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
   296  	e.e.EncodeUint(uint64(rvGetUintptr(rv)))
   297  }
   298  
   299  func (e *Encoder) kErr(f *codecFnInfo, rv reflect.Value) {
   300  	e.errorf("unsupported kind %s, for %#v", rv.Kind(), rv)
   301  }
   302  
   303  func chanToSlice(rv reflect.Value, rtslice reflect.Type, timeout time.Duration) (rvcs reflect.Value) {
   304  	rvcs = rvZeroK(rtslice, reflect.Slice)
   305  	if timeout < 0 { // consume until close
   306  		for {
   307  			recv, recvOk := rv.Recv()
   308  			if !recvOk {
   309  				break
   310  			}
   311  			rvcs = reflect.Append(rvcs, recv)
   312  		}
   313  	} else {
   314  		cases := make([]reflect.SelectCase, 2)
   315  		cases[0] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: rv}
   316  		if timeout == 0 {
   317  			cases[1] = reflect.SelectCase{Dir: reflect.SelectDefault}
   318  		} else {
   319  			tt := time.NewTimer(timeout)
   320  			cases[1] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(tt.C)}
   321  		}
   322  		for {
   323  			chosen, recv, recvOk := reflect.Select(cases)
   324  			if chosen == 1 || !recvOk {
   325  				break
   326  			}
   327  			rvcs = reflect.Append(rvcs, recv)
   328  		}
   329  	}
   330  	return
   331  }
   332  
   333  func (e *Encoder) kSeqFn(rtelem reflect.Type) (fn *codecFn) {
   334  	for rtelem.Kind() == reflect.Ptr {
   335  		rtelem = rtelem.Elem()
   336  	}
   337  	// if kind is reflect.Interface, do not pre-determine the encoding type,
   338  	// because preEncodeValue may break it down to a concrete type and kInterface will bomb.
   339  	if rtelem.Kind() != reflect.Interface {
   340  		fn = e.h.fn(rtelem)
   341  	}
   342  	return
   343  }
   344  
   345  func (e *Encoder) kSliceWMbs(rv reflect.Value, ti *typeInfo) {
   346  	var l = rvLenSlice(rv)
   347  	if l == 0 {
   348  		e.mapStart(0)
   349  	} else {
   350  		e.haltOnMbsOddLen(l)
   351  		e.mapStart(l >> 1) // e.mapStart(l / 2)
   352  		fn := e.kSeqFn(ti.elem)
   353  		for j := 0; j < l; j++ {
   354  			if j&1 == 0 { // j%2 == 0 {
   355  				e.mapElemKey()
   356  			} else {
   357  				e.mapElemValue()
   358  			}
   359  			e.encodeValue(rvSliceIndex(rv, j, ti), fn)
   360  		}
   361  	}
   362  	e.mapEnd()
   363  }
   364  
   365  func (e *Encoder) kSliceW(rv reflect.Value, ti *typeInfo) {
   366  	var l = rvLenSlice(rv)
   367  	e.arrayStart(l)
   368  	if l > 0 {
   369  		fn := e.kSeqFn(ti.elem)
   370  		for j := 0; j < l; j++ {
   371  			e.arrayElem()
   372  			e.encodeValue(rvSliceIndex(rv, j, ti), fn)
   373  		}
   374  	}
   375  	e.arrayEnd()
   376  }
   377  
   378  func (e *Encoder) kArrayWMbs(rv reflect.Value, ti *typeInfo) {
   379  	var l = rv.Len()
   380  	if l == 0 {
   381  		e.mapStart(0)
   382  	} else {
   383  		e.haltOnMbsOddLen(l)
   384  		e.mapStart(l >> 1) // e.mapStart(l / 2)
   385  		fn := e.kSeqFn(ti.elem)
   386  		for j := 0; j < l; j++ {
   387  			if j&1 == 0 { // j%2 == 0 {
   388  				e.mapElemKey()
   389  			} else {
   390  				e.mapElemValue()
   391  			}
   392  			e.encodeValue(rv.Index(j), fn)
   393  		}
   394  	}
   395  	e.mapEnd()
   396  }
   397  
   398  func (e *Encoder) kArrayW(rv reflect.Value, ti *typeInfo) {
   399  	var l = rv.Len()
   400  	e.arrayStart(l)
   401  	if l > 0 {
   402  		fn := e.kSeqFn(ti.elem)
   403  		for j := 0; j < l; j++ {
   404  			e.arrayElem()
   405  			e.encodeValue(rv.Index(j), fn)
   406  		}
   407  	}
   408  	e.arrayEnd()
   409  }
   410  
   411  func (e *Encoder) kChan(f *codecFnInfo, rv reflect.Value) {
   412  	if f.ti.chandir&uint8(reflect.RecvDir) == 0 {
   413  		e.errorf("send-only channel cannot be encoded")
   414  	}
   415  	if !f.ti.mbs && uint8TypId == rt2id(f.ti.elem) {
   416  		e.kSliceBytesChan(rv)
   417  		return
   418  	}
   419  	rtslice := reflect.SliceOf(f.ti.elem)
   420  	rv = chanToSlice(rv, rtslice, e.h.ChanRecvTimeout)
   421  	ti := e.h.getTypeInfo(rt2id(rtslice), rtslice)
   422  	if f.ti.mbs {
   423  		e.kSliceWMbs(rv, ti)
   424  	} else {
   425  		e.kSliceW(rv, ti)
   426  	}
   427  }
   428  
   429  func (e *Encoder) kSlice(f *codecFnInfo, rv reflect.Value) {
   430  	if f.ti.mbs {
   431  		e.kSliceWMbs(rv, f.ti)
   432  	} else if f.ti.rtid == uint8SliceTypId || uint8TypId == rt2id(f.ti.elem) {
   433  		e.e.EncodeStringBytesRaw(rvGetBytes(rv))
   434  	} else {
   435  		e.kSliceW(rv, f.ti)
   436  	}
   437  }
   438  
   439  func (e *Encoder) kArray(f *codecFnInfo, rv reflect.Value) {
   440  	if f.ti.mbs {
   441  		e.kArrayWMbs(rv, f.ti)
   442  	} else if handleBytesWithinKArray && uint8TypId == rt2id(f.ti.elem) {
   443  		e.e.EncodeStringBytesRaw(rvGetArrayBytes(rv, []byte{}))
   444  	} else {
   445  		e.kArrayW(rv, f.ti)
   446  	}
   447  }
   448  
   449  func (e *Encoder) kSliceBytesChan(rv reflect.Value) {
   450  	// do not use range, so that the number of elements encoded
   451  	// does not change, and encoding does not hang waiting on someone to close chan.
   452  
   453  	bs0 := e.blist.peek(32, true)
   454  	bs := bs0
   455  
   456  	irv := rv2i(rv)
   457  	ch, ok := irv.(<-chan byte)
   458  	if !ok {
   459  		ch = irv.(chan byte)
   460  	}
   461  
   462  L1:
   463  	switch timeout := e.h.ChanRecvTimeout; {
   464  	case timeout == 0: // only consume available
   465  		for {
   466  			select {
   467  			case b := <-ch:
   468  				bs = append(bs, b)
   469  			default:
   470  				break L1
   471  			}
   472  		}
   473  	case timeout > 0: // consume until timeout
   474  		tt := time.NewTimer(timeout)
   475  		for {
   476  			select {
   477  			case b := <-ch:
   478  				bs = append(bs, b)
   479  			case <-tt.C:
   480  				// close(tt.C)
   481  				break L1
   482  			}
   483  		}
   484  	default: // consume until close
   485  		for b := range ch {
   486  			bs = append(bs, b)
   487  		}
   488  	}
   489  
   490  	e.e.EncodeStringBytesRaw(bs)
   491  	e.blist.put(bs)
   492  	if !byteSliceSameData(bs0, bs) {
   493  		e.blist.put(bs0)
   494  	}
   495  }
   496  
   497  func (e *Encoder) kStructSfi(f *codecFnInfo) []*structFieldInfo {
   498  	if e.h.Canonical {
   499  		return f.ti.sfi.sorted()
   500  	}
   501  	return f.ti.sfi.source()
   502  }
   503  
   504  func (e *Encoder) kStructNoOmitempty(f *codecFnInfo, rv reflect.Value) {
   505  	var tisfi []*structFieldInfo
   506  	if f.ti.toArray || e.h.StructToArray { // toArray
   507  		tisfi = f.ti.sfi.source()
   508  		e.arrayStart(len(tisfi))
   509  		for _, si := range tisfi {
   510  			e.arrayElem()
   511  			e.encodeValue(si.path.field(rv), nil)
   512  		}
   513  		e.arrayEnd()
   514  	} else {
   515  		tisfi = e.kStructSfi(f)
   516  		e.mapStart(len(tisfi))
   517  		keytyp := f.ti.keyType
   518  		for _, si := range tisfi {
   519  			e.mapElemKey()
   520  			e.kStructFieldKey(keytyp, si.path.encNameAsciiAlphaNum, si.encName)
   521  			e.mapElemValue()
   522  			e.encodeValue(si.path.field(rv), nil)
   523  		}
   524  		e.mapEnd()
   525  	}
   526  }
   527  
   528  func (e *Encoder) kStructFieldKey(keyType valueType, encNameAsciiAlphaNum bool, encName string) {
   529  	encStructFieldKey(encName, e.e, e.w(), keyType, encNameAsciiAlphaNum, e.js)
   530  }
   531  
   532  func (e *Encoder) kStruct(f *codecFnInfo, rv reflect.Value) {
   533  	var newlen int
   534  	ti := f.ti
   535  	toMap := !(ti.toArray || e.h.StructToArray)
   536  	var mf map[string]interface{}
   537  	if ti.flagMissingFielder {
   538  		mf = rv2i(rv).(MissingFielder).CodecMissingFields()
   539  		toMap = true
   540  		newlen += len(mf)
   541  	} else if ti.flagMissingFielderPtr {
   542  		rv2 := e.addrRV(rv, ti.rt, ti.ptr)
   543  		mf = rv2i(rv2).(MissingFielder).CodecMissingFields()
   544  		toMap = true
   545  		newlen += len(mf)
   546  	}
   547  	tisfi := ti.sfi.source()
   548  	newlen += len(tisfi)
   549  
   550  	var fkvs = e.slist.get(newlen)[:newlen]
   551  
   552  	recur := e.h.RecursiveEmptyCheck
   553  
   554  	var kv sfiRv
   555  	var j int
   556  	if toMap {
   557  		newlen = 0
   558  		for _, si := range e.kStructSfi(f) {
   559  			kv.r = si.path.field(rv)
   560  			if si.path.omitEmpty && isEmptyValue(kv.r, e.h.TypeInfos, recur) {
   561  				continue
   562  			}
   563  			kv.v = si
   564  			fkvs[newlen] = kv
   565  			newlen++
   566  		}
   567  
   568  		var mf2s []stringIntf
   569  		if len(mf) > 0 {
   570  			mf2s = make([]stringIntf, 0, len(mf))
   571  			for k, v := range mf {
   572  				if k == "" {
   573  					continue
   574  				}
   575  				if ti.infoFieldOmitempty && isEmptyValue(reflect.ValueOf(v), e.h.TypeInfos, recur) {
   576  					continue
   577  				}
   578  				mf2s = append(mf2s, stringIntf{k, v})
   579  			}
   580  		}
   581  
   582  		e.mapStart(newlen + len(mf2s))
   583  
   584  		// When there are missing fields, and Canonical flag is set,
   585  		// we cannot have the missing fields and struct fields sorted independently.
   586  		// We have to capture them together and sort as a unit.
   587  
   588  		if len(mf2s) > 0 && e.h.Canonical {
   589  			mf2w := make([]encStructFieldObj, newlen+len(mf2s))
   590  			for j = 0; j < newlen; j++ {
   591  				kv = fkvs[j]
   592  				mf2w[j] = encStructFieldObj{kv.v.encName, kv.r, nil, kv.v.path.encNameAsciiAlphaNum, true}
   593  			}
   594  			for _, v := range mf2s {
   595  				mf2w[j] = encStructFieldObj{v.v, reflect.Value{}, v.i, false, false}
   596  				j++
   597  			}
   598  			sort.Sort((encStructFieldObjSlice)(mf2w))
   599  			for _, v := range mf2w {
   600  				e.mapElemKey()
   601  				e.kStructFieldKey(ti.keyType, v.ascii, v.key)
   602  				e.mapElemValue()
   603  				if v.isRv {
   604  					e.encodeValue(v.rv, nil)
   605  				} else {
   606  					e.encode(v.intf)
   607  				}
   608  			}
   609  		} else {
   610  			keytyp := ti.keyType
   611  			for j = 0; j < newlen; j++ {
   612  				kv = fkvs[j]
   613  				e.mapElemKey()
   614  				e.kStructFieldKey(keytyp, kv.v.path.encNameAsciiAlphaNum, kv.v.encName)
   615  				e.mapElemValue()
   616  				e.encodeValue(kv.r, nil)
   617  			}
   618  			for _, v := range mf2s {
   619  				e.mapElemKey()
   620  				e.kStructFieldKey(keytyp, false, v.v)
   621  				e.mapElemValue()
   622  				e.encode(v.i)
   623  			}
   624  		}
   625  
   626  		e.mapEnd()
   627  	} else {
   628  		newlen = len(tisfi)
   629  		for i, si := range tisfi { // use unsorted array (to match sequence in struct)
   630  			kv.r = si.path.field(rv)
   631  			// use the zero value.
   632  			// if a reference or struct, set to nil (so you do not output too much)
   633  			if si.path.omitEmpty && isEmptyValue(kv.r, e.h.TypeInfos, recur) {
   634  				switch kv.r.Kind() {
   635  				case reflect.Struct, reflect.Interface, reflect.Ptr, reflect.Array, reflect.Map, reflect.Slice:
   636  					kv.r = reflect.Value{} //encode as nil
   637  				}
   638  			}
   639  			fkvs[i] = kv
   640  		}
   641  		// encode it all
   642  		e.arrayStart(newlen)
   643  		for j = 0; j < newlen; j++ {
   644  			e.arrayElem()
   645  			e.encodeValue(fkvs[j].r, nil)
   646  		}
   647  		e.arrayEnd()
   648  	}
   649  
   650  	// do not use defer. Instead, use explicit pool return at end of function.
   651  	// defer has a cost we are trying to avoid.
   652  	// If there is a panic and these slices are not returned, it is ok.
   653  	e.slist.put(fkvs)
   654  }
   655  
   656  func (e *Encoder) kMap(f *codecFnInfo, rv reflect.Value) {
   657  	l := rvLenMap(rv)
   658  	e.mapStart(l)
   659  	if l == 0 {
   660  		e.mapEnd()
   661  		return
   662  	}
   663  
   664  	// determine the underlying key and val encFn's for the map.
   665  	// This eliminates some work which is done for each loop iteration i.e.
   666  	// rv.Type(), ref.ValueOf(rt).Pointer(), then check map/list for fn.
   667  	//
   668  	// However, if kind is reflect.Interface, do not pre-determine the
   669  	// encoding type, because preEncodeValue may break it down to
   670  	// a concrete type and kInterface will bomb.
   671  
   672  	var keyFn, valFn *codecFn
   673  
   674  	ktypeKind := reflect.Kind(f.ti.keykind)
   675  	vtypeKind := reflect.Kind(f.ti.elemkind)
   676  
   677  	rtval := f.ti.elem
   678  	rtvalkind := vtypeKind
   679  	for rtvalkind == reflect.Ptr {
   680  		rtval = rtval.Elem()
   681  		rtvalkind = rtval.Kind()
   682  	}
   683  	if rtvalkind != reflect.Interface {
   684  		valFn = e.h.fn(rtval)
   685  	}
   686  
   687  	var rvv = mapAddrLoopvarRV(f.ti.elem, vtypeKind)
   688  
   689  	rtkey := f.ti.key
   690  	var keyTypeIsString = stringTypId == rt2id(rtkey) // rtkeyid
   691  	if keyTypeIsString {
   692  		keyFn = e.h.fn(rtkey)
   693  	} else {
   694  		for rtkey.Kind() == reflect.Ptr {
   695  			rtkey = rtkey.Elem()
   696  		}
   697  		if rtkey.Kind() != reflect.Interface {
   698  			keyFn = e.h.fn(rtkey)
   699  		}
   700  	}
   701  
   702  	if e.h.Canonical {
   703  		e.kMapCanonical(f.ti, rv, rvv, keyFn, valFn)
   704  		e.mapEnd()
   705  		return
   706  	}
   707  
   708  	var rvk = mapAddrLoopvarRV(f.ti.key, ktypeKind)
   709  
   710  	var it mapIter
   711  	mapRange(&it, rv, rvk, rvv, true)
   712  
   713  	for it.Next() {
   714  		e.mapElemKey()
   715  		if keyTypeIsString {
   716  			e.e.EncodeString(it.Key().String())
   717  		} else {
   718  			e.encodeValue(it.Key(), keyFn)
   719  		}
   720  		e.mapElemValue()
   721  		e.encodeValue(it.Value(), valFn)
   722  	}
   723  	it.Done()
   724  
   725  	e.mapEnd()
   726  }
   727  
   728  func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, keyFn, valFn *codecFn) {
   729  	// The base kind of the type of the map key is sufficient for ordering.
   730  	// We only do out of band if that kind is not ordered (number or string), bool or time.Time.
   731  	// If the key is a predeclared type, directly call methods on encDriver e.g. EncodeString
   732  	// but if not, call encodeValue, in case it has an extension registered or otherwise.
   733  	rtkey := ti.key
   734  	rtkeydecl := rtkey.PkgPath() == "" && rtkey.Name() != "" // key type is predeclared
   735  
   736  	mks := rv.MapKeys()
   737  	rtkeyKind := rtkey.Kind()
   738  	kfast := mapKeyFastKindFor(rtkeyKind)
   739  	visindirect := mapStoresElemIndirect(uintptr(ti.elemsize))
   740  	visref := refBitset.isset(ti.elemkind)
   741  
   742  	switch rtkeyKind {
   743  	case reflect.Bool:
   744  		// though bool keys make no sense in a map, it *could* happen.
   745  		// in that case, we MUST support it in reflection mode,
   746  		// as that is the fallback for even codecgen and others.
   747  
   748  		// sort the keys so that false comes before true
   749  		// ie if 2 keys in order (true, false), then swap them
   750  		if len(mks) == 2 && mks[0].Bool() {
   751  			mks[0], mks[1] = mks[1], mks[0]
   752  		}
   753  		for i := range mks {
   754  			e.mapElemKey()
   755  			if rtkeydecl {
   756  				e.e.EncodeBool(mks[i].Bool())
   757  			} else {
   758  				e.encodeValueNonNil(mks[i], keyFn)
   759  			}
   760  			e.mapElemValue()
   761  			e.encodeValue(mapGet(rv, mks[i], rvv, kfast, visindirect, visref), valFn)
   762  		}
   763  	case reflect.String:
   764  		mksv := make([]stringRv, len(mks))
   765  		for i, k := range mks {
   766  			v := &mksv[i]
   767  			v.r = k
   768  			v.v = k.String()
   769  		}
   770  		sort.Sort(stringRvSlice(mksv))
   771  		for i := range mksv {
   772  			e.mapElemKey()
   773  			if rtkeydecl {
   774  				e.e.EncodeString(mksv[i].v)
   775  			} else {
   776  				e.encodeValueNonNil(mksv[i].r, keyFn)
   777  			}
   778  			e.mapElemValue()
   779  			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
   780  		}
   781  	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr:
   782  		mksv := make([]uint64Rv, len(mks))
   783  		for i, k := range mks {
   784  			v := &mksv[i]
   785  			v.r = k
   786  			v.v = k.Uint()
   787  		}
   788  		sort.Sort(uint64RvSlice(mksv))
   789  		for i := range mksv {
   790  			e.mapElemKey()
   791  			if rtkeydecl {
   792  				e.e.EncodeUint(mksv[i].v)
   793  			} else {
   794  				e.encodeValueNonNil(mksv[i].r, keyFn)
   795  			}
   796  			e.mapElemValue()
   797  			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
   798  		}
   799  	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
   800  		mksv := make([]int64Rv, len(mks))
   801  		for i, k := range mks {
   802  			v := &mksv[i]
   803  			v.r = k
   804  			v.v = k.Int()
   805  		}
   806  		sort.Sort(int64RvSlice(mksv))
   807  		for i := range mksv {
   808  			e.mapElemKey()
   809  			if rtkeydecl {
   810  				e.e.EncodeInt(mksv[i].v)
   811  			} else {
   812  				e.encodeValueNonNil(mksv[i].r, keyFn)
   813  			}
   814  			e.mapElemValue()
   815  			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
   816  		}
   817  	case reflect.Float32:
   818  		mksv := make([]float64Rv, len(mks))
   819  		for i, k := range mks {
   820  			v := &mksv[i]
   821  			v.r = k
   822  			v.v = k.Float()
   823  		}
   824  		sort.Sort(float64RvSlice(mksv))
   825  		for i := range mksv {
   826  			e.mapElemKey()
   827  			if rtkeydecl {
   828  				e.e.EncodeFloat32(float32(mksv[i].v))
   829  			} else {
   830  				e.encodeValueNonNil(mksv[i].r, keyFn)
   831  			}
   832  			e.mapElemValue()
   833  			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
   834  		}
   835  	case reflect.Float64:
   836  		mksv := make([]float64Rv, len(mks))
   837  		for i, k := range mks {
   838  			v := &mksv[i]
   839  			v.r = k
   840  			v.v = k.Float()
   841  		}
   842  		sort.Sort(float64RvSlice(mksv))
   843  		for i := range mksv {
   844  			e.mapElemKey()
   845  			if rtkeydecl {
   846  				e.e.EncodeFloat64(mksv[i].v)
   847  			} else {
   848  				e.encodeValueNonNil(mksv[i].r, keyFn)
   849  			}
   850  			e.mapElemValue()
   851  			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
   852  		}
   853  	default:
   854  		if rtkey == timeTyp {
   855  			mksv := make([]timeRv, len(mks))
   856  			for i, k := range mks {
   857  				v := &mksv[i]
   858  				v.r = k
   859  				v.v = rv2i(k).(time.Time)
   860  			}
   861  			sort.Sort(timeRvSlice(mksv))
   862  			for i := range mksv {
   863  				e.mapElemKey()
   864  				e.e.EncodeTime(mksv[i].v)
   865  				e.mapElemValue()
   866  				e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
   867  			}
   868  			break
   869  		}
   870  
   871  		// out-of-band
   872  		// first encode each key to a []byte first, then sort them, then record
   873  		bs0 := e.blist.get(len(mks) * 16)
   874  		mksv := bs0
   875  		mksbv := make([]bytesRv, len(mks))
   876  
   877  		func() {
   878  			// replicate sideEncode logic
   879  			defer func(wb bytesEncAppender, bytes bool, c containerState, state interface{}) {
   880  				e.wb = wb
   881  				e.bytes = bytes
   882  				e.c = c
   883  				e.e.restoreState(state)
   884  			}(e.wb, e.bytes, e.c, e.e.captureState())
   885  
   886  			// e2 := NewEncoderBytes(&mksv, e.hh)
   887  			e.wb = bytesEncAppender{mksv[:0], &mksv}
   888  			e.bytes = true
   889  			e.c = 0
   890  			e.e.resetState()
   891  
   892  			for i, k := range mks {
   893  				v := &mksbv[i]
   894  				l := len(mksv)
   895  
   896  				e.c = containerMapKey
   897  				e.encodeValue(k, nil)
   898  				e.atEndOfEncode()
   899  				e.w().end()
   900  
   901  				v.r = k
   902  				v.v = mksv[l:]
   903  			}
   904  		}()
   905  
   906  		sort.Sort(bytesRvSlice(mksbv))
   907  		for j := range mksbv {
   908  			e.mapElemKey()
   909  			e.encWr.writeb(mksbv[j].v)
   910  			e.mapElemValue()
   911  			e.encodeValue(mapGet(rv, mksbv[j].r, rvv, kfast, visindirect, visref), valFn)
   912  		}
   913  		e.blist.put(mksv)
   914  		if !byteSliceSameData(bs0, mksv) {
   915  			e.blist.put(bs0)
   916  		}
   917  	}
   918  }
   919  
   920  // Encoder writes an object to an output stream in a supported format.
   921  //
   922  // Encoder is NOT safe for concurrent use i.e. a Encoder cannot be used
   923  // concurrently in multiple goroutines.
   924  //
   925  // However, as Encoder could be allocation heavy to initialize, a Reset method is provided
   926  // so its state can be reused to decode new input streams repeatedly.
   927  // This is the idiomatic way to use.
   928  type Encoder struct {
   929  	panicHdl
   930  
   931  	e encDriver
   932  
   933  	h *BasicHandle
   934  
   935  	// hopefully, reduce derefencing cost by laying the encWriter inside the Encoder
   936  	encWr
   937  
   938  	// ---- cpu cache line boundary
   939  	hh Handle
   940  
   941  	blist bytesFreelist
   942  	err   error
   943  
   944  	// ---- cpu cache line boundary
   945  
   946  	// ---- writable fields during execution --- *try* to keep in sep cache line
   947  
   948  	// ci holds interfaces during an encoding (if CheckCircularRef=true)
   949  	//
   950  	// We considered using a []uintptr (slice of pointer addresses) retrievable via rv.UnsafeAddr.
   951  	// However, it is possible for the same pointer to point to 2 different types e.g.
   952  	//    type T struct { tHelper }
   953  	//    Here, for var v T; &v and &v.tHelper are the same pointer.
   954  	// Consequently, we need a tuple of type and pointer, which interface{} natively provides.
   955  	ci []interface{} // []uintptr
   956  
   957  	perType encPerType
   958  
   959  	slist sfiRvFreelist
   960  }
   961  
   962  // NewEncoder returns an Encoder for encoding into an io.Writer.
   963  //
   964  // For efficiency, Users are encouraged to configure WriterBufferSize on the handle
   965  // OR pass in a memory buffered writer (eg bufio.Writer, bytes.Buffer).
   966  func NewEncoder(w io.Writer, h Handle) *Encoder {
   967  	e := h.newEncDriver().encoder()
   968  	if w != nil {
   969  		e.Reset(w)
   970  	}
   971  	return e
   972  }
   973  
   974  // NewEncoderBytes returns an encoder for encoding directly and efficiently
   975  // into a byte slice, using zero-copying to temporary slices.
   976  //
   977  // It will potentially replace the output byte slice pointed to.
   978  // After encoding, the out parameter contains the encoded contents.
   979  func NewEncoderBytes(out *[]byte, h Handle) *Encoder {
   980  	e := h.newEncDriver().encoder()
   981  	if out != nil {
   982  		e.ResetBytes(out)
   983  	}
   984  	return e
   985  }
   986  
   987  func (e *Encoder) HandleName() string {
   988  	return e.hh.Name()
   989  }
   990  
   991  func (e *Encoder) init(h Handle) {
   992  	initHandle(h)
   993  	e.err = errEncoderNotInitialized
   994  	e.bytes = true
   995  	e.hh = h
   996  	e.h = h.getBasicHandle()
   997  	e.be = e.hh.isBinary()
   998  }
   999  
  1000  func (e *Encoder) w() *encWr {
  1001  	return &e.encWr
  1002  }
  1003  
  1004  func (e *Encoder) resetCommon() {
  1005  	e.e.reset()
  1006  	if e.ci != nil {
  1007  		e.ci = e.ci[:0]
  1008  	}
  1009  	e.c = 0
  1010  	e.calls = 0
  1011  	e.seq = 0
  1012  	e.err = nil
  1013  }
  1014  
  1015  // Reset resets the Encoder with a new output stream.
  1016  //
  1017  // This accommodates using the state of the Encoder,
  1018  // where it has "cached" information about sub-engines.
  1019  func (e *Encoder) Reset(w io.Writer) {
  1020  	e.bytes = false
  1021  	if e.wf == nil {
  1022  		e.wf = new(bufioEncWriter)
  1023  	}
  1024  	e.wf.reset(w, e.h.WriterBufferSize, &e.blist)
  1025  	e.resetCommon()
  1026  }
  1027  
  1028  // ResetBytes resets the Encoder with a new destination output []byte.
  1029  func (e *Encoder) ResetBytes(out *[]byte) {
  1030  	e.bytes = true
  1031  	e.wb.reset(encInBytes(out), out)
  1032  	e.resetCommon()
  1033  }
  1034  
  1035  // Encode writes an object into a stream.
  1036  //
  1037  // Encoding can be configured via the struct tag for the fields.
  1038  // The key (in the struct tags) that we look at is configurable.
  1039  //
  1040  // By default, we look up the "codec" key in the struct field's tags,
  1041  // and fall bak to the "json" key if "codec" is absent.
  1042  // That key in struct field's tag value is the key name,
  1043  // followed by an optional comma and options.
  1044  //
  1045  // To set an option on all fields (e.g. omitempty on all fields), you
  1046  // can create a field called _struct, and set flags on it. The options
  1047  // which can be set on _struct are:
  1048  //   - omitempty: so all fields are omitted if empty
  1049  //   - toarray: so struct is encoded as an array
  1050  //   - int: so struct key names are encoded as signed integers (instead of strings)
  1051  //   - uint: so struct key names are encoded as unsigned integers (instead of strings)
  1052  //   - float: so struct key names are encoded as floats (instead of strings)
  1053  //
  1054  // More details on these below.
  1055  //
  1056  // Struct values "usually" encode as maps. Each exported struct field is encoded unless:
  1057  //   - the field's tag is "-", OR
  1058  //   - the field is empty (empty or the zero value) and its tag specifies the "omitempty" option.
  1059  //
  1060  // When encoding as a map, the first string in the tag (before the comma)
  1061  // is the map key string to use when encoding.
  1062  // ...
  1063  // This key is typically encoded as a string.
  1064  // However, there are instances where the encoded stream has mapping keys encoded as numbers.
  1065  // For example, some cbor streams have keys as integer codes in the stream, but they should map
  1066  // to fields in a structured object. Consequently, a struct is the natural representation in code.
  1067  // For these, configure the struct to encode/decode the keys as numbers (instead of string).
  1068  // This is done with the int,uint or float option on the _struct field (see above).
  1069  //
  1070  // However, struct values may encode as arrays. This happens when:
  1071  //   - StructToArray Encode option is set, OR
  1072  //   - the tag on the _struct field sets the "toarray" option
  1073  //
  1074  // Note that omitempty is ignored when encoding struct values as arrays,
  1075  // as an entry must be encoded for each field, to maintain its position.
  1076  //
  1077  // Values with types that implement MapBySlice are encoded as stream maps.
  1078  //
  1079  // The empty values (for omitempty option) are false, 0, any nil pointer
  1080  // or interface value, and any array, slice, map, or string of length zero.
  1081  //
  1082  // Anonymous fields are encoded inline except:
  1083  //   - the struct tag specifies a replacement name (first value)
  1084  //   - the field is of an interface type
  1085  //
  1086  // Examples:
  1087  //
  1088  //	// NOTE: 'json:' can be used as struct tag key, in place 'codec:' below.
  1089  //	type MyStruct struct {
  1090  //	    _struct bool    `codec:",omitempty"`   //set omitempty for every field
  1091  //	    Field1 string   `codec:"-"`            //skip this field
  1092  //	    Field2 int      `codec:"myName"`       //Use key "myName" in encode stream
  1093  //	    Field3 int32    `codec:",omitempty"`   //use key "Field3". Omit if empty.
  1094  //	    Field4 bool     `codec:"f4,omitempty"` //use key "f4". Omit if empty.
  1095  //	    io.Reader                              //use key "Reader".
  1096  //	    MyStruct        `codec:"my1"           //use key "my1".
  1097  //	    MyStruct                               //inline it
  1098  //	    ...
  1099  //	}
  1100  //
  1101  //	type MyStruct struct {
  1102  //	    _struct bool    `codec:",toarray"`     //encode struct as an array
  1103  //	}
  1104  //
  1105  //	type MyStruct struct {
  1106  //	    _struct bool    `codec:",uint"`        //encode struct with "unsigned integer" keys
  1107  //	    Field1 string   `codec:"1"`            //encode Field1 key using: EncodeInt(1)
  1108  //	    Field2 string   `codec:"2"`            //encode Field2 key using: EncodeInt(2)
  1109  //	}
  1110  //
  1111  // The mode of encoding is based on the type of the value. When a value is seen:
  1112  //   - If a Selfer, call its CodecEncodeSelf method
  1113  //   - If an extension is registered for it, call that extension function
  1114  //   - If implements encoding.(Binary|Text|JSON)Marshaler, call Marshal(Binary|Text|JSON) method
  1115  //   - Else encode it based on its reflect.Kind
  1116  //
  1117  // Note that struct field names and keys in map[string]XXX will be treated as symbols.
  1118  // Some formats support symbols (e.g. binc) and will properly encode the string
  1119  // only once in the stream, and use a tag to refer to it thereafter.
  1120  func (e *Encoder) Encode(v interface{}) (err error) {
  1121  	// tried to use closure, as runtime optimizes defer with no params.
  1122  	// This seemed to be causing weird issues (like circular reference found, unexpected panic, etc).
  1123  	// Also, see https://github.com/golang/go/issues/14939#issuecomment-417836139
  1124  	if !debugging {
  1125  		defer func() {
  1126  			// if error occurred during encoding, return that error;
  1127  			// else if error occurred on end'ing (i.e. during flush), return that error.
  1128  			if x := recover(); x != nil {
  1129  				panicValToErr(e, x, &e.err)
  1130  				err = e.err
  1131  			}
  1132  		}()
  1133  	}
  1134  
  1135  	e.MustEncode(v)
  1136  	return
  1137  }
  1138  
  1139  // MustEncode is like Encode, but panics if unable to Encode.
  1140  //
  1141  // Note: This provides insight to the code location that triggered the error.
  1142  func (e *Encoder) MustEncode(v interface{}) {
  1143  	halt.onerror(e.err)
  1144  	if e.hh == nil {
  1145  		halt.onerror(errNoFormatHandle)
  1146  	}
  1147  
  1148  	e.calls++
  1149  	e.encode(v)
  1150  	e.calls--
  1151  	if e.calls == 0 {
  1152  		e.atEndOfEncode()
  1153  		e.w().end()
  1154  	}
  1155  }
  1156  
  1157  // Release is a no-op.
  1158  //
  1159  // Deprecated: Pooled resources are not used with an Encoder.
  1160  // This method is kept for compatibility reasons only.
  1161  func (e *Encoder) Release() {
  1162  }
  1163  
  1164  func (e *Encoder) encode(iv interface{}) {
  1165  	// MARKER: a switch with only concrete types can be optimized.
  1166  	// consequently, we deal with nil and interfaces outside the switch.
  1167  
  1168  	if iv == nil {
  1169  		e.e.EncodeNil()
  1170  		return
  1171  	}
  1172  
  1173  	rv, ok := isNil(iv)
  1174  	if ok {
  1175  		e.e.EncodeNil()
  1176  		return
  1177  	}
  1178  
  1179  	switch v := iv.(type) {
  1180  	// case nil:
  1181  	// case Selfer:
  1182  	case Raw:
  1183  		e.rawBytes(v)
  1184  	case reflect.Value:
  1185  		e.encodeValue(v, nil)
  1186  
  1187  	case string:
  1188  		e.e.EncodeString(v)
  1189  	case bool:
  1190  		e.e.EncodeBool(v)
  1191  	case int:
  1192  		e.e.EncodeInt(int64(v))
  1193  	case int8:
  1194  		e.e.EncodeInt(int64(v))
  1195  	case int16:
  1196  		e.e.EncodeInt(int64(v))
  1197  	case int32:
  1198  		e.e.EncodeInt(int64(v))
  1199  	case int64:
  1200  		e.e.EncodeInt(v)
  1201  	case uint:
  1202  		e.e.EncodeUint(uint64(v))
  1203  	case uint8:
  1204  		e.e.EncodeUint(uint64(v))
  1205  	case uint16:
  1206  		e.e.EncodeUint(uint64(v))
  1207  	case uint32:
  1208  		e.e.EncodeUint(uint64(v))
  1209  	case uint64:
  1210  		e.e.EncodeUint(v)
  1211  	case uintptr:
  1212  		e.e.EncodeUint(uint64(v))
  1213  	case float32:
  1214  		e.e.EncodeFloat32(v)
  1215  	case float64:
  1216  		e.e.EncodeFloat64(v)
  1217  	case complex64:
  1218  		e.encodeComplex64(v)
  1219  	case complex128:
  1220  		e.encodeComplex128(v)
  1221  	case time.Time:
  1222  		e.e.EncodeTime(v)
  1223  	case []byte:
  1224  		e.e.EncodeStringBytesRaw(v)
  1225  	case *Raw:
  1226  		e.rawBytes(*v)
  1227  	case *string:
  1228  		e.e.EncodeString(*v)
  1229  	case *bool:
  1230  		e.e.EncodeBool(*v)
  1231  	case *int:
  1232  		e.e.EncodeInt(int64(*v))
  1233  	case *int8:
  1234  		e.e.EncodeInt(int64(*v))
  1235  	case *int16:
  1236  		e.e.EncodeInt(int64(*v))
  1237  	case *int32:
  1238  		e.e.EncodeInt(int64(*v))
  1239  	case *int64:
  1240  		e.e.EncodeInt(*v)
  1241  	case *uint:
  1242  		e.e.EncodeUint(uint64(*v))
  1243  	case *uint8:
  1244  		e.e.EncodeUint(uint64(*v))
  1245  	case *uint16:
  1246  		e.e.EncodeUint(uint64(*v))
  1247  	case *uint32:
  1248  		e.e.EncodeUint(uint64(*v))
  1249  	case *uint64:
  1250  		e.e.EncodeUint(*v)
  1251  	case *uintptr:
  1252  		e.e.EncodeUint(uint64(*v))
  1253  	case *float32:
  1254  		e.e.EncodeFloat32(*v)
  1255  	case *float64:
  1256  		e.e.EncodeFloat64(*v)
  1257  	case *complex64:
  1258  		e.encodeComplex64(*v)
  1259  	case *complex128:
  1260  		e.encodeComplex128(*v)
  1261  	case *time.Time:
  1262  		e.e.EncodeTime(*v)
  1263  	case *[]byte:
  1264  		if *v == nil {
  1265  			e.e.EncodeNil()
  1266  		} else {
  1267  			e.e.EncodeStringBytesRaw(*v)
  1268  		}
  1269  	default:
  1270  		// we can't check non-predefined types, as they might be a Selfer or extension.
  1271  		if skipFastpathTypeSwitchInDirectCall || !fastpathEncodeTypeSwitch(iv, e) {
  1272  			e.encodeValue(rv, nil)
  1273  		}
  1274  	}
  1275  }
  1276  
  1277  // encodeValue will encode a value.
  1278  //
  1279  // Note that encodeValue will handle nil in the stream early, so that the
  1280  // subsequent calls i.e. kXXX methods, etc do not have to handle it themselves.
  1281  func (e *Encoder) encodeValue(rv reflect.Value, fn *codecFn) {
  1282  	// if a valid fn is passed, it MUST BE for the dereferenced type of rv
  1283  
  1284  	// MARKER: We check if value is nil here, so that the kXXX method do not have to.
  1285  
  1286  	var sptr interface{}
  1287  	var rvp reflect.Value
  1288  	var rvpValid bool
  1289  TOP:
  1290  	switch rv.Kind() {
  1291  	case reflect.Ptr:
  1292  		if rvIsNil(rv) {
  1293  			e.e.EncodeNil()
  1294  			return
  1295  		}
  1296  		rvpValid = true
  1297  		rvp = rv
  1298  		rv = rv.Elem()
  1299  		goto TOP
  1300  	case reflect.Interface:
  1301  		if rvIsNil(rv) {
  1302  			e.e.EncodeNil()
  1303  			return
  1304  		}
  1305  		rvpValid = false
  1306  		rvp = reflect.Value{}
  1307  		rv = rv.Elem()
  1308  		goto TOP
  1309  	case reflect.Struct:
  1310  		if rvpValid && e.h.CheckCircularRef {
  1311  			sptr = rv2i(rvp)
  1312  			for _, vv := range e.ci {
  1313  				if eq4i(sptr, vv) { // error if sptr already seen
  1314  					e.errorf("circular reference found: %p, %T", sptr, sptr)
  1315  				}
  1316  			}
  1317  			e.ci = append(e.ci, sptr)
  1318  		}
  1319  	case reflect.Slice, reflect.Map, reflect.Chan:
  1320  		if rvIsNil(rv) {
  1321  			e.e.EncodeNil()
  1322  			return
  1323  		}
  1324  	case reflect.Invalid, reflect.Func:
  1325  		e.e.EncodeNil()
  1326  		return
  1327  	}
  1328  
  1329  	if fn == nil {
  1330  		fn = e.h.fn(rv.Type())
  1331  	}
  1332  
  1333  	if !fn.i.addrE { // typically, addrE = false, so check it first
  1334  		// keep rv same
  1335  	} else if rvpValid {
  1336  		rv = rvp
  1337  	} else {
  1338  		rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr)
  1339  	}
  1340  	fn.fe(e, &fn.i, rv)
  1341  
  1342  	if sptr != nil { // remove sptr
  1343  		e.ci = e.ci[:len(e.ci)-1]
  1344  	}
  1345  }
  1346  
  1347  // encodeValueNonNil can encode a number, bool, or string
  1348  // OR non-nil values of kind map, slice and chan.
  1349  func (e *Encoder) encodeValueNonNil(rv reflect.Value, fn *codecFn) {
  1350  	if fn == nil {
  1351  		fn = e.h.fn(rv.Type())
  1352  	}
  1353  
  1354  	if fn.i.addrE { // typically, addrE = false, so check it first
  1355  		rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr)
  1356  	}
  1357  	fn.fe(e, &fn.i, rv)
  1358  }
  1359  
  1360  // addrRV returns a addressable value which may be readonly
  1361  func (e *Encoder) addrRV(rv reflect.Value, typ, ptrType reflect.Type) (rva reflect.Value) {
  1362  	if rv.CanAddr() {
  1363  		return rvAddr(rv, ptrType)
  1364  	}
  1365  	if e.h.NoAddressableReadonly {
  1366  		rva = reflect.New(typ)
  1367  		rvSetDirect(rva.Elem(), rv)
  1368  		return
  1369  	}
  1370  	return rvAddr(e.perType.AddressableRO(rv), ptrType)
  1371  }
  1372  
  1373  func (e *Encoder) marshalUtf8(bs []byte, fnerr error) {
  1374  	e.onerror(fnerr)
  1375  	if bs == nil {
  1376  		e.e.EncodeNil()
  1377  	} else {
  1378  		e.e.EncodeString(stringView(bs))
  1379  	}
  1380  }
  1381  
  1382  func (e *Encoder) marshalAsis(bs []byte, fnerr error) {
  1383  	e.onerror(fnerr)
  1384  	if bs == nil {
  1385  		e.e.EncodeNil()
  1386  	} else {
  1387  		e.encWr.writeb(bs) // e.asis(bs)
  1388  	}
  1389  }
  1390  
  1391  func (e *Encoder) marshalRaw(bs []byte, fnerr error) {
  1392  	e.onerror(fnerr)
  1393  	if bs == nil {
  1394  		e.e.EncodeNil()
  1395  	} else {
  1396  		e.e.EncodeStringBytesRaw(bs)
  1397  	}
  1398  }
  1399  
  1400  func (e *Encoder) rawBytes(vv Raw) {
  1401  	v := []byte(vv)
  1402  	if !e.h.Raw {
  1403  		e.errorf("Raw values cannot be encoded: %v", v)
  1404  	}
  1405  	e.encWr.writeb(v)
  1406  }
  1407  
  1408  func (e *Encoder) wrapErr(v error, err *error) {
  1409  	*err = wrapCodecErr(v, e.hh.Name(), 0, true)
  1410  }
  1411  
  1412  // ---- container tracker methods
  1413  // Note: We update the .c after calling the callback.
  1414  // This way, the callback can know what the last status was.
  1415  
  1416  func (e *Encoder) mapStart(length int) {
  1417  	e.e.WriteMapStart(length)
  1418  	e.c = containerMapStart
  1419  }
  1420  
  1421  func (e *Encoder) mapElemKey() {
  1422  	if e.js {
  1423  		e.jsondriver().WriteMapElemKey()
  1424  	}
  1425  	e.c = containerMapKey
  1426  }
  1427  
  1428  func (e *Encoder) mapElemValue() {
  1429  	if e.js {
  1430  		e.jsondriver().WriteMapElemValue()
  1431  	}
  1432  	e.c = containerMapValue
  1433  }
  1434  
  1435  func (e *Encoder) mapEnd() {
  1436  	e.e.WriteMapEnd()
  1437  	e.c = 0
  1438  }
  1439  
  1440  func (e *Encoder) arrayStart(length int) {
  1441  	e.e.WriteArrayStart(length)
  1442  	e.c = containerArrayStart
  1443  }
  1444  
  1445  func (e *Encoder) arrayElem() {
  1446  	if e.js {
  1447  		e.jsondriver().WriteArrayElem()
  1448  	}
  1449  	e.c = containerArrayElem
  1450  }
  1451  
  1452  func (e *Encoder) arrayEnd() {
  1453  	e.e.WriteArrayEnd()
  1454  	e.c = 0
  1455  }
  1456  
  1457  // ----------
  1458  
  1459  func (e *Encoder) haltOnMbsOddLen(length int) {
  1460  	if length&1 != 0 { // similar to &1==1 or %2 == 1
  1461  		e.errorf("mapBySlice requires even slice length, but got %v", length)
  1462  	}
  1463  }
  1464  
  1465  func (e *Encoder) atEndOfEncode() {
  1466  	// e.e.atEndOfEncode()
  1467  	if e.js {
  1468  		e.jsondriver().atEndOfEncode()
  1469  	}
  1470  }
  1471  
  1472  func (e *Encoder) sideEncode(v interface{}, basetype reflect.Type, bs *[]byte) {
  1473  	// rv := baseRV(v)
  1474  	// e2 := NewEncoderBytes(bs, e.hh)
  1475  	// e2.encodeValue(rv, e2.h.fnNoExt(basetype))
  1476  	// e2.atEndOfEncode()
  1477  	// e2.w().end()
  1478  
  1479  	defer func(wb bytesEncAppender, bytes bool, c containerState, state interface{}) {
  1480  		e.wb = wb
  1481  		e.bytes = bytes
  1482  		e.c = c
  1483  		e.e.restoreState(state)
  1484  	}(e.wb, e.bytes, e.c, e.e.captureState())
  1485  
  1486  	e.wb = bytesEncAppender{encInBytes(bs)[:0], bs}
  1487  	e.bytes = true
  1488  	e.c = 0
  1489  	e.e.resetState()
  1490  
  1491  	// must call using fnNoExt
  1492  	rv := baseRV(v)
  1493  	e.encodeValue(rv, e.h.fnNoExt(basetype))
  1494  	e.atEndOfEncode()
  1495  	e.w().end()
  1496  }
  1497  
  1498  func encInBytes(out *[]byte) (in []byte) {
  1499  	in = *out
  1500  	if in == nil {
  1501  		in = make([]byte, defEncByteBufSize)
  1502  	}
  1503  	return
  1504  }
  1505  
  1506  func encStructFieldKey(encName string, ee encDriver, w *encWr,
  1507  	keyType valueType, encNameAsciiAlphaNum bool, js bool) {
  1508  	// use if-else-if, not switch (which compiles to binary-search)
  1509  	// since keyType is typically valueTypeString, branch prediction is pretty good.
  1510  
  1511  	if keyType == valueTypeString {
  1512  		if js && encNameAsciiAlphaNum { // keyType == valueTypeString
  1513  			w.writeqstr(encName)
  1514  		} else { // keyType == valueTypeString
  1515  			ee.EncodeString(encName)
  1516  		}
  1517  	} else if keyType == valueTypeInt {
  1518  		ee.EncodeInt(must.Int(strconv.ParseInt(encName, 10, 64)))
  1519  	} else if keyType == valueTypeUint {
  1520  		ee.EncodeUint(must.Uint(strconv.ParseUint(encName, 10, 64)))
  1521  	} else if keyType == valueTypeFloat {
  1522  		ee.EncodeFloat64(must.Float(strconv.ParseFloat(encName, 64)))
  1523  	} else {
  1524  		halt.errorf("invalid struct key type: %v", keyType)
  1525  	}
  1526  }
  1527  

View as plain text