go/json-iterator
1
0
Fork 0
mirror of https://github.com/json-iterator/go.git synced 2025-04-26 11:42:56 +02:00
Code Issues Releases Activity

rename Encoder => ValEncoder and Decoder => ValDecoder

Browse Source
This commit is contained in:
Tao Wen 2017-06-20 07:59:45 +08:00
parent 43a832beee
commit b3170a8cef
7 changed files with 68 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
feature_config.go
View File

@ -60,8 +60,8 @@ func (cfg Config) Froze() *frozenConfig {
streamPool: make(chan *Stream, 16), streamPool: make(chan *Stream, 16),
iteratorPool: make(chan *Iterator, 16), iteratorPool: make(chan *Iterator, 16),
} }
atomic.StorePointer(&frozenConfig.decoderCache, unsafe.Pointer(&map[string]Decoder{})) atomic.StorePointer(&frozenConfig.decoderCache, unsafe.Pointer(&map[string]ValDecoder{}))
atomic.StorePointer(&frozenConfig.encoderCache, unsafe.Pointer(&map[string]Encoder{})) atomic.StorePointer(&frozenConfig.encoderCache, unsafe.Pointer(&map[string]ValEncoder{}))
if cfg.MarshalFloatWith6Digits { if cfg.MarshalFloatWith6Digits {
frozenConfig.marshalFloatWith6Digits() frozenConfig.marshalFloatWith6Digits()
} }
@ -158,12 +158,12 @@ func (cfg *frozenConfig) escapeHtml() {
cfg.addEncoderToCache(reflect.TypeOf((*string)(nil)).Elem(), &htmlEscapedStringEncoder{}) cfg.addEncoderToCache(reflect.TypeOf((*string)(nil)).Elem(), &htmlEscapedStringEncoder{})
} }
func (cfg *frozenConfig) addDecoderToCache(cacheKey reflect.Type, decoder Decoder) { func (cfg *frozenConfig) addDecoderToCache(cacheKey reflect.Type, decoder ValDecoder) {
done := false done := false
for !done { for !done {
ptr := atomic.LoadPointer(&cfg.decoderCache) ptr := atomic.LoadPointer(&cfg.decoderCache)
cache := *(*map[reflect.Type]Decoder)(ptr) cache := *(*map[reflect.Type]ValDecoder)(ptr)
copied := map[reflect.Type]Decoder{} copied := map[reflect.Type]ValDecoder{}
for k, v := range cache { for k, v := range cache {
copied[k] = v copied[k] = v
} }
@ -172,12 +172,12 @@ func (cfg *frozenConfig) addDecoderToCache(cacheKey reflect.Type, decoder Decode
} }
} }
func (cfg *frozenConfig) addEncoderToCache(cacheKey reflect.Type, encoder Encoder) { func (cfg *frozenConfig) addEncoderToCache(cacheKey reflect.Type, encoder ValEncoder) {
done := false done := false
for !done { for !done {
ptr := atomic.LoadPointer(&cfg.encoderCache) ptr := atomic.LoadPointer(&cfg.encoderCache)
cache := *(*map[reflect.Type]Encoder)(ptr) cache := *(*map[reflect.Type]ValEncoder)(ptr)
copied := map[reflect.Type]Encoder{} copied := map[reflect.Type]ValEncoder{}
for k, v := range cache { for k, v := range cache {
copied[k] = v copied[k] = v
} }
@ -186,30 +186,30 @@ func (cfg *frozenConfig) addEncoderToCache(cacheKey reflect.Type, encoder Encode
} }
} }
func (cfg *frozenConfig) getDecoderFromCache(cacheKey reflect.Type) Decoder { func (cfg *frozenConfig) getDecoderFromCache(cacheKey reflect.Type) ValDecoder {
ptr := atomic.LoadPointer(&cfg.decoderCache) ptr := atomic.LoadPointer(&cfg.decoderCache)
cache := *(*map[reflect.Type]Decoder)(ptr) cache := *(*map[reflect.Type]ValDecoder)(ptr)
return cache[cacheKey] return cache[cacheKey]
} }
func (cfg *frozenConfig) getEncoderFromCache(cacheKey reflect.Type) Encoder { func (cfg *frozenConfig) getEncoderFromCache(cacheKey reflect.Type) ValEncoder {
ptr := atomic.LoadPointer(&cfg.encoderCache) ptr := atomic.LoadPointer(&cfg.encoderCache)
cache := *(*map[reflect.Type]Encoder)(ptr) cache := *(*map[reflect.Type]ValEncoder)(ptr)
return cache[cacheKey] return cache[cacheKey]
} }
// cleanDecoders cleans decoders registered or cached // cleanDecoders cleans decoders registered or cached
func (cfg *frozenConfig) cleanDecoders() { func (cfg *frozenConfig) cleanDecoders() {
typeDecoders = map[string]Decoder{} typeDecoders = map[string]ValDecoder{}
fieldDecoders = map[string]Decoder{} fieldDecoders = map[string]ValDecoder{}
atomic.StorePointer(&cfg.decoderCache, unsafe.Pointer(&map[string]Decoder{})) atomic.StorePointer(&cfg.decoderCache, unsafe.Pointer(&map[string]ValDecoder{}))
} }
// cleanEncoders cleans encoders registered or cached // cleanEncoders cleans encoders registered or cached
func (cfg *frozenConfig) cleanEncoders() { func (cfg *frozenConfig) cleanEncoders() {
typeEncoders = map[string]Encoder{} typeEncoders = map[string]ValEncoder{}
fieldEncoders = map[string]Encoder{} fieldEncoders = map[string]ValEncoder{}
atomic.StorePointer(&cfg.encoderCache, unsafe.Pointer(&map[string]Encoder{})) atomic.StorePointer(&cfg.encoderCache, unsafe.Pointer(&map[string]ValEncoder{}))
} }
func (cfg *frozenConfig) MarshalToString(v interface{}) (string, error) { func (cfg *frozenConfig) MarshalToString(v interface{}) (string, error) {

60
feature_reflect.go
View File

@ -9,8 +9,8 @@ import (
"unsafe" "unsafe"
) )
// Decoder is an internal type registered to cache as needed. // ValDecoder is an internal type registered to cache as needed.
// Don't confuse jsoniter.Decoder with json.Decoder. // Don't confuse jsoniter.ValDecoder with json.Decoder.
// For json.Decoder's adapter, refer to jsoniter.AdapterDecoder(todo link). // For json.Decoder's adapter, refer to jsoniter.AdapterDecoder(todo link).
// //
// Reflection on type to create decoders, which is then cached // Reflection on type to create decoders, which is then cached
@ -19,20 +19,20 @@ import (
// 2. append to slice, if the existing cap is not enough, allocate will be done using Reflect.New // 2. append to slice, if the existing cap is not enough, allocate will be done using Reflect.New
// 3. assignment to map, both key and value will be reflect.Value // 3. assignment to map, both key and value will be reflect.Value
// For a simple struct binding, it will be reflect.Value free and allocation free // For a simple struct binding, it will be reflect.Value free and allocation free
type Decoder interface { type ValDecoder interface {
decode(ptr unsafe.Pointer, iter *Iterator) decode(ptr unsafe.Pointer, iter *Iterator)
} }
// Encoder is an internal type registered to cache as needed. // ValEncoder is an internal type registered to cache as needed.
// Don't confuse jsoniter.Encoder with json.Encoder. // Don't confuse jsoniter.ValEncoder with json.Encoder.
// For json.Encoder's adapter, refer to jsoniter.AdapterEncoder(todo godoc link). // For json.Encoder's adapter, refer to jsoniter.AdapterEncoder(todo godoc link).
type Encoder interface { type ValEncoder interface {
isEmpty(ptr unsafe.Pointer) bool isEmpty(ptr unsafe.Pointer) bool
encode(ptr unsafe.Pointer, stream *Stream) encode(ptr unsafe.Pointer, stream *Stream)
encodeInterface(val interface{}, stream *Stream) encodeInterface(val interface{}, stream *Stream)
} }
func writeToStream(val interface{}, stream *Stream, encoder Encoder) { func writeToStream(val interface{}, stream *Stream, encoder ValEncoder) {
e := (*emptyInterface)(unsafe.Pointer(&val)) e := (*emptyInterface)(unsafe.Pointer(&val))
if e.word == nil { if e.word == nil {
stream.WriteNil() stream.WriteNil()
@ -77,10 +77,10 @@ func (encoder *funcEncoder) isEmpty(ptr unsafe.Pointer) bool {
return encoder.isEmptyFunc(ptr) return encoder.isEmptyFunc(ptr)
} }
var typeDecoders map[string]Decoder var typeDecoders map[string]ValDecoder
var fieldDecoders map[string]Decoder var fieldDecoders map[string]ValDecoder
var typeEncoders map[string]Encoder var typeEncoders map[string]ValEncoder
var fieldEncoders map[string]Encoder var fieldEncoders map[string]ValEncoder
var extensions []ExtensionFunc var extensions []ExtensionFunc
var jsonNumberType reflect.Type var jsonNumberType reflect.Type
var jsonRawMessageType reflect.Type var jsonRawMessageType reflect.Type
@ -91,10 +91,10 @@ var unmarshalerType reflect.Type
var textUnmarshalerType reflect.Type var textUnmarshalerType reflect.Type
func init() { func init() {
typeDecoders = map[string]Decoder{} typeDecoders = map[string]ValDecoder{}
fieldDecoders = map[string]Decoder{} fieldDecoders = map[string]ValDecoder{}
typeEncoders = map[string]Encoder{} typeEncoders = map[string]ValEncoder{}
fieldEncoders = map[string]Encoder{} fieldEncoders = map[string]ValEncoder{}
extensions = []ExtensionFunc{} extensions = []ExtensionFunc{}
jsonNumberType = reflect.TypeOf((*json.Number)(nil)).Elem() jsonNumberType = reflect.TypeOf((*json.Number)(nil)).Elem()
jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem() jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem()
@ -130,7 +130,7 @@ func RegisterExtension(extension ExtensionFunc) {
type optionalDecoder struct { type optionalDecoder struct {
valueType reflect.Type valueType reflect.Type
valueDecoder Decoder valueDecoder ValDecoder
} }
func (decoder *optionalDecoder) decode(ptr unsafe.Pointer, iter *Iterator) { func (decoder *optionalDecoder) decode(ptr unsafe.Pointer, iter *Iterator) {
@ -150,7 +150,7 @@ func (decoder *optionalDecoder) decode(ptr unsafe.Pointer, iter *Iterator) {
} }
type optionalEncoder struct { type optionalEncoder struct {
valueEncoder Encoder valueEncoder ValEncoder
} }
func (encoder *optionalEncoder) encode(ptr unsafe.Pointer, stream *Stream) { func (encoder *optionalEncoder) encode(ptr unsafe.Pointer, stream *Stream) {
@ -190,7 +190,7 @@ func (encoder *placeholderEncoder) isEmpty(ptr unsafe.Pointer) bool {
return encoder.getRealEncoder().isEmpty(ptr) return encoder.getRealEncoder().isEmpty(ptr)
} }
func (encoder *placeholderEncoder) getRealEncoder() Encoder { func (encoder *placeholderEncoder) getRealEncoder() ValEncoder {
for i := 0; i < 30; i++ { for i := 0; i < 30; i++ {
realDecoder := encoder.cfg.getEncoderFromCache(encoder.cacheKey) realDecoder := encoder.cfg.getEncoderFromCache(encoder.cacheKey)
_, isPlaceholder := realDecoder.(*placeholderEncoder) _, isPlaceholder := realDecoder.(*placeholderEncoder)
@ -282,21 +282,21 @@ func (stream *Stream) WriteVal(val interface{}) {
type prefix string type prefix string
func (p prefix) addToDecoder(decoder Decoder, err error) (Decoder, error) { func (p prefix) addToDecoder(decoder ValDecoder, err error) (ValDecoder, error) {
if err != nil { if err != nil {
return nil, fmt.Errorf("%s: %s", p, err.Error()) return nil, fmt.Errorf("%s: %s", p, err.Error())
} }
return decoder, err return decoder, err
} }
func (p prefix) addToEncoder(encoder Encoder, err error) (Encoder, error) { func (p prefix) addToEncoder(encoder ValEncoder, err error) (ValEncoder, error) {
if err != nil { if err != nil {
return nil, fmt.Errorf("%s: %s", p, err.Error()) return nil, fmt.Errorf("%s: %s", p, err.Error())
} }
return encoder, err return encoder, err
} }
func decoderOfType(cfg *frozenConfig, typ reflect.Type) (Decoder, error) { func decoderOfType(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
typeName := typ.String() typeName := typ.String()
typeDecoder := typeDecoders[typeName] typeDecoder := typeDecoders[typeName]
if typeDecoder != nil { if typeDecoder != nil {
@ -320,7 +320,7 @@ func decoderOfType(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
return newDecoder, err return newDecoder, err
} }
func createDecoderOfType(cfg *frozenConfig, typ reflect.Type) (Decoder, error) { func createDecoderOfType(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
if typ.String() == "[]uint8" { if typ.String() == "[]uint8" {
return &base64Codec{}, nil return &base64Codec{}, nil
} }
@ -335,7 +335,7 @@ func createDecoderOfType(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
} }
if typ.ConvertibleTo(unmarshalerType) { if typ.ConvertibleTo(unmarshalerType) {
templateInterface := reflect.New(typ).Elem().Interface() templateInterface := reflect.New(typ).Elem().Interface()
var decoder Decoder = &unmarshalerDecoder{extractInterface(templateInterface)} var decoder ValDecoder = &unmarshalerDecoder{extractInterface(templateInterface)}
if typ.Kind() != reflect.Struct { if typ.Kind() != reflect.Struct {
decoder = &optionalDecoder{typ, decoder} decoder = &optionalDecoder{typ, decoder}
} }
@ -394,7 +394,7 @@ func createDecoderOfType(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
} }
} }
func encoderOfType(cfg *frozenConfig, typ reflect.Type) (Encoder, error) { func encoderOfType(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
typeName := typ.String() typeName := typ.String()
typeEncoder := typeEncoders[typeName] typeEncoder := typeEncoders[typeName]
if typeEncoder != nil { if typeEncoder != nil {
@ -418,7 +418,7 @@ func encoderOfType(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
return newEncoder, err return newEncoder, err
} }
func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (Encoder, error) { func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
if typ.String() == "[]uint8" { if typ.String() == "[]uint8" {
return &base64Codec{}, nil return &base64Codec{}, nil
} }
@ -433,7 +433,7 @@ func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
} }
if typ.ConvertibleTo(marshalerType) { if typ.ConvertibleTo(marshalerType) {
templateInterface := reflect.New(typ).Elem().Interface() templateInterface := reflect.New(typ).Elem().Interface()
var encoder Encoder = &marshalerEncoder{extractInterface(templateInterface)} var encoder ValEncoder = &marshalerEncoder{extractInterface(templateInterface)}
if typ.Kind() != reflect.Struct { if typ.Kind() != reflect.Struct {
encoder = &optionalEncoder{encoder} encoder = &optionalEncoder{encoder}
} }
@ -493,7 +493,7 @@ func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
} }
} }
func decoderOfOptional(cfg *frozenConfig, typ reflect.Type) (Decoder, error) { func decoderOfOptional(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
elemType := typ.Elem() elemType := typ.Elem()
decoder, err := decoderOfType(cfg, elemType) decoder, err := decoderOfType(cfg, elemType)
if err != nil { if err != nil {
@ -502,7 +502,7 @@ func decoderOfOptional(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
return &optionalDecoder{elemType, decoder}, nil return &optionalDecoder{elemType, decoder}, nil
} }
func encoderOfOptional(cfg *frozenConfig, typ reflect.Type) (Encoder, error) { func encoderOfOptional(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
elemType := typ.Elem() elemType := typ.Elem()
elemEncoder, err := encoderOfType(cfg, elemType) elemEncoder, err := encoderOfType(cfg, elemType)
if err != nil { if err != nil {
@ -515,7 +515,7 @@ func encoderOfOptional(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
return encoder, nil return encoder, nil
} }
func decoderOfMap(cfg *frozenConfig, typ reflect.Type) (Decoder, error) { func decoderOfMap(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
decoder, err := decoderOfType(cfg, typ.Elem()) decoder, err := decoderOfType(cfg, typ.Elem())
if err != nil { if err != nil {
return nil, err return nil, err
@ -528,7 +528,7 @@ func extractInterface(val interface{}) emptyInterface {
return *((*emptyInterface)(unsafe.Pointer(&val))) return *((*emptyInterface)(unsafe.Pointer(&val)))
} }
func encoderOfMap(cfg *frozenConfig, typ reflect.Type) (Encoder, error) { func encoderOfMap(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
elemType := typ.Elem() elemType := typ.Elem()
encoder, err := encoderOfType(cfg, elemType) encoder, err := encoderOfType(cfg, elemType)
if err != nil { if err != nil {

8
feature_reflect_array.go
View File

@ -7,7 +7,7 @@ import (
"unsafe" "unsafe"
) )
func decoderOfArray(cfg *frozenConfig, typ reflect.Type) (Decoder, error) { func decoderOfArray(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
decoder, err := decoderOfType(cfg, typ.Elem()) decoder, err := decoderOfType(cfg, typ.Elem())
if err != nil { if err != nil {
return nil, err return nil, err
@ -15,7 +15,7 @@ func decoderOfArray(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
return &arrayDecoder{typ, typ.Elem(), decoder}, nil return &arrayDecoder{typ, typ.Elem(), decoder}, nil
} }
func encoderOfArray(cfg *frozenConfig, typ reflect.Type) (Encoder, error) { func encoderOfArray(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
encoder, err := encoderOfType(cfg, typ.Elem()) encoder, err := encoderOfType(cfg, typ.Elem())
if err != nil { if err != nil {
return nil, err return nil, err
@ -29,7 +29,7 @@ func encoderOfArray(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
type arrayEncoder struct { type arrayEncoder struct {
arrayType reflect.Type arrayType reflect.Type
elemType reflect.Type elemType reflect.Type
elemEncoder Encoder elemEncoder ValEncoder
} }
func (encoder *arrayEncoder) encode(ptr unsafe.Pointer, stream *Stream) { func (encoder *arrayEncoder) encode(ptr unsafe.Pointer, stream *Stream) {
@ -62,7 +62,7 @@ func (encoder *arrayEncoder) isEmpty(ptr unsafe.Pointer) bool {
type arrayDecoder struct { type arrayDecoder struct {
arrayType reflect.Type arrayType reflect.Type
elemType reflect.Type elemType reflect.Type
elemDecoder Decoder elemDecoder ValDecoder
} }
func (decoder *arrayDecoder) decode(ptr unsafe.Pointer, iter *Iterator) { func (decoder *arrayDecoder) decode(ptr unsafe.Pointer, iter *Iterator) {

6
feature_reflect_map.go
View File

@ -13,7 +13,7 @@ type mapDecoder struct {
mapType reflect.Type mapType reflect.Type
keyType reflect.Type keyType reflect.Type
elemType reflect.Type elemType reflect.Type
elemDecoder Decoder elemDecoder ValDecoder
mapInterface emptyInterface mapInterface emptyInterface
} }
@ -72,7 +72,7 @@ func (decoder *mapDecoder) decode(ptr unsafe.Pointer, iter *Iterator) {
type mapEncoder struct { type mapEncoder struct {
mapType reflect.Type mapType reflect.Type
elemType reflect.Type elemType reflect.Type
elemEncoder Encoder elemEncoder ValEncoder
mapInterface emptyInterface mapInterface emptyInterface
} }
@ -141,7 +141,7 @@ func (encoder *mapEncoder) isEmpty(ptr unsafe.Pointer) bool {
type sortKeysMapEncoder struct { type sortKeysMapEncoder struct {
mapType reflect.Type mapType reflect.Type
elemType reflect.Type elemType reflect.Type
elemEncoder Encoder elemEncoder ValEncoder
mapInterface emptyInterface mapInterface emptyInterface
} }

4
feature_reflect_native.go
View File

@ -447,7 +447,7 @@ func (encoder *base64Codec) isEmpty(ptr unsafe.Pointer) bool {
} }
type stringModeDecoder struct { type stringModeDecoder struct {
elemDecoder Decoder elemDecoder ValDecoder
} }
func (decoder *stringModeDecoder) decode(ptr unsafe.Pointer, iter *Iterator) { func (decoder *stringModeDecoder) decode(ptr unsafe.Pointer, iter *Iterator) {
@ -468,7 +468,7 @@ func (decoder *stringModeDecoder) decode(ptr unsafe.Pointer, iter *Iterator) {
} }
type stringModeEncoder struct { type stringModeEncoder struct {
elemEncoder Encoder elemEncoder ValEncoder
} }
func (encoder *stringModeEncoder) encode(ptr unsafe.Pointer, stream *Stream) { func (encoder *stringModeEncoder) encode(ptr unsafe.Pointer, stream *Stream) {

12
feature_reflect_object.go
View File

@ -9,7 +9,7 @@ import (
"unsafe" "unsafe"
) )
func encoderOfStruct(cfg *frozenConfig, typ reflect.Type) (Encoder, error) { func encoderOfStruct(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
structEncoder_ := &structEncoder{} structEncoder_ := &structEncoder{}
fields := map[string]*structFieldEncoder{} fields := map[string]*structFieldEncoder{}
for _, field := range listStructFields(typ) { for _, field := range listStructFields(typ) {
@ -86,7 +86,7 @@ func listStructFields(typ reflect.Type) []*reflect.StructField {
return fields return fields
} }
func decoderOfStruct(cfg *frozenConfig, typ reflect.Type) (Decoder, error) { func decoderOfStruct(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
fields := map[string]*structFieldDecoder{} fields := map[string]*structFieldDecoder{}
for _, field := range listStructFields(typ) { for _, field := range listStructFields(typ) {
fieldDecoderKey := fmt.Sprintf("%s/%s", typ.String(), field.Name) fieldDecoderKey := fmt.Sprintf("%s/%s", typ.String(), field.Name)
@ -155,7 +155,7 @@ func calcFieldNames(originalFieldName string, tagProvidedFieldName string, exten
return fieldNames return fieldNames
} }
func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder) (Decoder, error) { func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder) (ValDecoder, error) {
knownHash := map[int32]struct{}{ knownHash := map[int32]struct{}{
0: {}, 0: {},
} }
@ -1059,7 +1059,7 @@ func (decoder *tenFieldsStructDecoder) decode(ptr unsafe.Pointer, iter *Iterator
type structFieldDecoder struct { type structFieldDecoder struct {
field *reflect.StructField field *reflect.StructField
fieldDecoder Decoder fieldDecoder ValDecoder
} }
func (decoder *structFieldDecoder) decode(ptr unsafe.Pointer, iter *Iterator) { func (decoder *structFieldDecoder) decode(ptr unsafe.Pointer, iter *Iterator) {
@ -1073,7 +1073,7 @@ func (decoder *structFieldDecoder) decode(ptr unsafe.Pointer, iter *Iterator) {
type structFieldEncoder struct { type structFieldEncoder struct {
field *reflect.StructField field *reflect.StructField
fieldName string fieldName string
fieldEncoder Encoder fieldEncoder ValEncoder
omitempty bool omitempty bool
} }
@ -1116,7 +1116,7 @@ func (encoder *structEncoder) encode(ptr unsafe.Pointer, stream *Stream) {
} }
func (encoder *structEncoder) encodeInterface(val interface{}, stream *Stream) { func (encoder *structEncoder) encodeInterface(val interface{}, stream *Stream) {
var encoderToUse Encoder var encoderToUse ValEncoder
encoderToUse = encoder encoderToUse = encoder
if len(encoder.fields) == 1 { if len(encoder.fields) == 1 {
firstEncoder := encoder.fields[0].fieldEncoder firstEncoder := encoder.fields[0].fieldEncoder

8
feature_reflect_slice.go
View File

@ -7,7 +7,7 @@ import (
"unsafe" "unsafe"
) )
func decoderOfSlice(cfg *frozenConfig, typ reflect.Type) (Decoder, error) { func decoderOfSlice(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
decoder, err := decoderOfType(cfg, typ.Elem()) decoder, err := decoderOfType(cfg, typ.Elem())
if err != nil { if err != nil {
return nil, err return nil, err
@ -15,7 +15,7 @@ func decoderOfSlice(cfg *frozenConfig, typ reflect.Type) (Decoder, error) {
return &sliceDecoder{typ, typ.Elem(), decoder}, nil return &sliceDecoder{typ, typ.Elem(), decoder}, nil
} }
func encoderOfSlice(cfg *frozenConfig, typ reflect.Type) (Encoder, error) { func encoderOfSlice(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
encoder, err := encoderOfType(cfg, typ.Elem()) encoder, err := encoderOfType(cfg, typ.Elem())
if err != nil { if err != nil {
return nil, err return nil, err
@ -29,7 +29,7 @@ func encoderOfSlice(cfg *frozenConfig, typ reflect.Type) (Encoder, error) {
type sliceEncoder struct { type sliceEncoder struct {
sliceType reflect.Type sliceType reflect.Type
elemType reflect.Type elemType reflect.Type
elemEncoder Encoder elemEncoder ValEncoder
} }
func (encoder *sliceEncoder) encode(ptr unsafe.Pointer, stream *Stream) { func (encoder *sliceEncoder) encode(ptr unsafe.Pointer, stream *Stream) {
@ -68,7 +68,7 @@ func (encoder *sliceEncoder) isEmpty(ptr unsafe.Pointer) bool {
type sliceDecoder struct { type sliceDecoder struct {
sliceType reflect.Type sliceType reflect.Type
elemType reflect.Type elemType reflect.Type
elemDecoder Decoder elemDecoder ValDecoder
} }
// sliceHeader is a safe version of SliceHeader used within this package. // sliceHeader is a safe version of SliceHeader used within this package.