1package jsoniter
2
3import (
4	"fmt"
5	"reflect"
6	"sort"
7	"strings"
8	"unicode"
9	"unsafe"
10)
11
12var typeDecoders = map[string]ValDecoder{}
13var fieldDecoders = map[string]ValDecoder{}
14var typeEncoders = map[string]ValEncoder{}
15var fieldEncoders = map[string]ValEncoder{}
16var extensions = []Extension{}
17
18// StructDescriptor describe how should we encode/decode the struct
19type StructDescriptor struct {
20	onePtrEmbedded     bool
21	onePtrOptimization bool
22	Type               reflect.Type
23	Fields             []*Binding
24}
25
26// GetField get one field from the descriptor by its name.
27// Can not use map here to keep field orders.
28func (structDescriptor *StructDescriptor) GetField(fieldName string) *Binding {
29	for _, binding := range structDescriptor.Fields {
30		if binding.Field.Name == fieldName {
31			return binding
32		}
33	}
34	return nil
35}
36
37// Binding describe how should we encode/decode the struct field
38type Binding struct {
39	levels    []int
40	Field     *reflect.StructField
41	FromNames []string
42	ToNames   []string
43	Encoder   ValEncoder
44	Decoder   ValDecoder
45}
46
47// Extension the one for all SPI. Customize encoding/decoding by specifying alternate encoder/decoder.
48// Can also rename fields by UpdateStructDescriptor.
49type Extension interface {
50	UpdateStructDescriptor(structDescriptor *StructDescriptor)
51	CreateDecoder(typ reflect.Type) ValDecoder
52	CreateEncoder(typ reflect.Type) ValEncoder
53	DecorateDecoder(typ reflect.Type, decoder ValDecoder) ValDecoder
54	DecorateEncoder(typ reflect.Type, encoder ValEncoder) ValEncoder
55}
56
57// DummyExtension embed this type get dummy implementation for all methods of Extension
58type DummyExtension struct {
59}
60
61// UpdateStructDescriptor No-op
62func (extension *DummyExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
63}
64
65// CreateDecoder No-op
66func (extension *DummyExtension) CreateDecoder(typ reflect.Type) ValDecoder {
67	return nil
68}
69
70// CreateEncoder No-op
71func (extension *DummyExtension) CreateEncoder(typ reflect.Type) ValEncoder {
72	return nil
73}
74
75// DecorateDecoder No-op
76func (extension *DummyExtension) DecorateDecoder(typ reflect.Type, decoder ValDecoder) ValDecoder {
77	return decoder
78}
79
80// DecorateEncoder No-op
81func (extension *DummyExtension) DecorateEncoder(typ reflect.Type, encoder ValEncoder) ValEncoder {
82	return encoder
83}
84
85type funcDecoder struct {
86	fun DecoderFunc
87}
88
89func (decoder *funcDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
90	decoder.fun(ptr, iter)
91}
92
93type funcEncoder struct {
94	fun         EncoderFunc
95	isEmptyFunc func(ptr unsafe.Pointer) bool
96}
97
98func (encoder *funcEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
99	encoder.fun(ptr, stream)
100}
101
102func (encoder *funcEncoder) EncodeInterface(val interface{}, stream *Stream) {
103	WriteToStream(val, stream, encoder)
104}
105
106func (encoder *funcEncoder) IsEmpty(ptr unsafe.Pointer) bool {
107	if encoder.isEmptyFunc == nil {
108		return false
109	}
110	return encoder.isEmptyFunc(ptr)
111}
112
113// DecoderFunc the function form of TypeDecoder
114type DecoderFunc func(ptr unsafe.Pointer, iter *Iterator)
115
116// EncoderFunc the function form of TypeEncoder
117type EncoderFunc func(ptr unsafe.Pointer, stream *Stream)
118
119// RegisterTypeDecoderFunc register TypeDecoder for a type with function
120func RegisterTypeDecoderFunc(typ string, fun DecoderFunc) {
121	typeDecoders[typ] = &funcDecoder{fun}
122}
123
124// RegisterTypeDecoder register TypeDecoder for a typ
125func RegisterTypeDecoder(typ string, decoder ValDecoder) {
126	typeDecoders[typ] = decoder
127}
128
129// RegisterFieldDecoderFunc register TypeDecoder for a struct field with function
130func RegisterFieldDecoderFunc(typ string, field string, fun DecoderFunc) {
131	RegisterFieldDecoder(typ, field, &funcDecoder{fun})
132}
133
134// RegisterFieldDecoder register TypeDecoder for a struct field
135func RegisterFieldDecoder(typ string, field string, decoder ValDecoder) {
136	fieldDecoders[fmt.Sprintf("%s/%s", typ, field)] = decoder
137}
138
139// RegisterTypeEncoderFunc register TypeEncoder for a type with encode/isEmpty function
140func RegisterTypeEncoderFunc(typ string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool) {
141	typeEncoders[typ] = &funcEncoder{fun, isEmptyFunc}
142}
143
144// RegisterTypeEncoder register TypeEncoder for a type
145func RegisterTypeEncoder(typ string, encoder ValEncoder) {
146	typeEncoders[typ] = encoder
147}
148
149// RegisterFieldEncoderFunc register TypeEncoder for a struct field with encode/isEmpty function
150func RegisterFieldEncoderFunc(typ string, field string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool) {
151	RegisterFieldEncoder(typ, field, &funcEncoder{fun, isEmptyFunc})
152}
153
154// RegisterFieldEncoder register TypeEncoder for a struct field
155func RegisterFieldEncoder(typ string, field string, encoder ValEncoder) {
156	fieldEncoders[fmt.Sprintf("%s/%s", typ, field)] = encoder
157}
158
159// RegisterExtension register extension
160func RegisterExtension(extension Extension) {
161	extensions = append(extensions, extension)
162}
163
164func getTypeDecoderFromExtension(typ reflect.Type) ValDecoder {
165	decoder := _getTypeDecoderFromExtension(typ)
166	if decoder != nil {
167		for _, extension := range extensions {
168			decoder = extension.DecorateDecoder(typ, decoder)
169		}
170	}
171	return decoder
172}
173func _getTypeDecoderFromExtension(typ reflect.Type) ValDecoder {
174	for _, extension := range extensions {
175		decoder := extension.CreateDecoder(typ)
176		if decoder != nil {
177			return decoder
178		}
179	}
180	typeName := typ.String()
181	decoder := typeDecoders[typeName]
182	if decoder != nil {
183		return decoder
184	}
185	if typ.Kind() == reflect.Ptr {
186		decoder := typeDecoders[typ.Elem().String()]
187		if decoder != nil {
188			return &optionalDecoder{typ.Elem(), decoder}
189		}
190	}
191	return nil
192}
193
194func getTypeEncoderFromExtension(typ reflect.Type) ValEncoder {
195	encoder := _getTypeEncoderFromExtension(typ)
196	if encoder != nil {
197		for _, extension := range extensions {
198			encoder = extension.DecorateEncoder(typ, encoder)
199		}
200	}
201	return encoder
202}
203
204func _getTypeEncoderFromExtension(typ reflect.Type) ValEncoder {
205	for _, extension := range extensions {
206		encoder := extension.CreateEncoder(typ)
207		if encoder != nil {
208			return encoder
209		}
210	}
211	typeName := typ.String()
212	encoder := typeEncoders[typeName]
213	if encoder != nil {
214		return encoder
215	}
216	if typ.Kind() == reflect.Ptr {
217		encoder := typeEncoders[typ.Elem().String()]
218		if encoder != nil {
219			return &optionalEncoder{encoder}
220		}
221	}
222	return nil
223}
224
225func describeStruct(cfg *frozenConfig, typ reflect.Type) (*StructDescriptor, error) {
226	embeddedBindings := []*Binding{}
227	bindings := []*Binding{}
228	for i := 0; i < typ.NumField(); i++ {
229		field := typ.Field(i)
230		tag := field.Tag.Get(cfg.getTagKey())
231		tagParts := strings.Split(tag, ",")
232		if tag == "-" {
233			continue
234		}
235		if field.Anonymous && (tag == "" || tagParts[0] == "") {
236			if field.Type.Kind() == reflect.Struct {
237				structDescriptor, err := describeStruct(cfg, field.Type)
238				if err != nil {
239					return nil, err
240				}
241				for _, binding := range structDescriptor.Fields {
242					binding.levels = append([]int{i}, binding.levels...)
243					omitempty := binding.Encoder.(*structFieldEncoder).omitempty
244					binding.Encoder = &structFieldEncoder{&field, binding.Encoder, omitempty}
245					binding.Decoder = &structFieldDecoder{&field, binding.Decoder}
246					embeddedBindings = append(embeddedBindings, binding)
247				}
248				continue
249			} else if field.Type.Kind() == reflect.Ptr && field.Type.Elem().Kind() == reflect.Struct {
250				structDescriptor, err := describeStruct(cfg, field.Type.Elem())
251				if err != nil {
252					return nil, err
253				}
254				for _, binding := range structDescriptor.Fields {
255					binding.levels = append([]int{i}, binding.levels...)
256					omitempty := binding.Encoder.(*structFieldEncoder).omitempty
257					binding.Encoder = &optionalEncoder{binding.Encoder}
258					binding.Encoder = &structFieldEncoder{&field, binding.Encoder, omitempty}
259					binding.Decoder = &deferenceDecoder{field.Type.Elem(), binding.Decoder}
260					binding.Decoder = &structFieldDecoder{&field, binding.Decoder}
261					embeddedBindings = append(embeddedBindings, binding)
262				}
263				continue
264			}
265		}
266		fieldNames := calcFieldNames(field.Name, tagParts[0], tag)
267		fieldCacheKey := fmt.Sprintf("%s/%s", typ.String(), field.Name)
268		decoder := fieldDecoders[fieldCacheKey]
269		if decoder == nil {
270			var err error
271			decoder, err = decoderOfType(cfg, field.Type)
272			if err != nil {
273				return nil, err
274			}
275		}
276		encoder := fieldEncoders[fieldCacheKey]
277		if encoder == nil {
278			var err error
279			encoder, err = encoderOfType(cfg, field.Type)
280			if err != nil {
281				return nil, err
282			}
283			// map is stored as pointer in the struct
284			if field.Type.Kind() == reflect.Map {
285				encoder = &optionalEncoder{encoder}
286			}
287		}
288		binding := &Binding{
289			Field:     &field,
290			FromNames: fieldNames,
291			ToNames:   fieldNames,
292			Decoder:   decoder,
293			Encoder:   encoder,
294		}
295		binding.levels = []int{i}
296		bindings = append(bindings, binding)
297	}
298	return createStructDescriptor(cfg, typ, bindings, embeddedBindings), nil
299}
300func createStructDescriptor(cfg *frozenConfig, typ reflect.Type, bindings []*Binding, embeddedBindings []*Binding) *StructDescriptor {
301	onePtrEmbedded := false
302	onePtrOptimization := false
303	if typ.NumField() == 1 {
304		firstField := typ.Field(0)
305		switch firstField.Type.Kind() {
306		case reflect.Ptr:
307			if firstField.Anonymous && firstField.Type.Elem().Kind() == reflect.Struct {
308				onePtrEmbedded = true
309			}
310			fallthrough
311		case reflect.Map:
312			onePtrOptimization = true
313		case reflect.Struct:
314			onePtrOptimization = isStructOnePtr(firstField.Type)
315		}
316	}
317	structDescriptor := &StructDescriptor{
318		onePtrEmbedded:     onePtrEmbedded,
319		onePtrOptimization: onePtrOptimization,
320		Type:               typ,
321		Fields:             bindings,
322	}
323	for _, extension := range extensions {
324		extension.UpdateStructDescriptor(structDescriptor)
325	}
326	processTags(structDescriptor, cfg)
327	// merge normal & embedded bindings & sort with original order
328	allBindings := sortableBindings(append(embeddedBindings, structDescriptor.Fields...))
329	sort.Sort(allBindings)
330	structDescriptor.Fields = allBindings
331	return structDescriptor
332}
333
334func isStructOnePtr(typ reflect.Type) bool {
335	if typ.NumField() == 1 {
336		firstField := typ.Field(0)
337		switch firstField.Type.Kind() {
338		case reflect.Ptr:
339			return true
340		case reflect.Map:
341			return true
342		case reflect.Struct:
343			return isStructOnePtr(firstField.Type)
344		}
345	}
346	return false
347}
348
349type sortableBindings []*Binding
350
351func (bindings sortableBindings) Len() int {
352	return len(bindings)
353}
354
355func (bindings sortableBindings) Less(i, j int) bool {
356	left := bindings[i].levels
357	right := bindings[j].levels
358	k := 0
359	for {
360		if left[k] < right[k] {
361			return true
362		} else if left[k] > right[k] {
363			return false
364		}
365		k++
366	}
367}
368
369func (bindings sortableBindings) Swap(i, j int) {
370	bindings[i], bindings[j] = bindings[j], bindings[i]
371}
372
373func processTags(structDescriptor *StructDescriptor, cfg *frozenConfig) {
374	for _, binding := range structDescriptor.Fields {
375		shouldOmitEmpty := false
376		tagParts := strings.Split(binding.Field.Tag.Get(cfg.getTagKey()), ",")
377		for _, tagPart := range tagParts[1:] {
378			if tagPart == "omitempty" {
379				shouldOmitEmpty = true
380			} else if tagPart == "string" {
381				if binding.Field.Type.Kind() == reflect.String {
382					binding.Decoder = &stringModeStringDecoder{binding.Decoder, cfg}
383					binding.Encoder = &stringModeStringEncoder{binding.Encoder, cfg}
384				} else {
385					binding.Decoder = &stringModeNumberDecoder{binding.Decoder}
386					binding.Encoder = &stringModeNumberEncoder{binding.Encoder}
387				}
388			}
389		}
390		binding.Decoder = &structFieldDecoder{binding.Field, binding.Decoder}
391		binding.Encoder = &structFieldEncoder{binding.Field, binding.Encoder, shouldOmitEmpty}
392	}
393}
394
395func calcFieldNames(originalFieldName string, tagProvidedFieldName string, wholeTag string) []string {
396	// ignore?
397	if wholeTag == "-" {
398		return []string{}
399	}
400	// rename?
401	var fieldNames []string
402	if tagProvidedFieldName == "" {
403		fieldNames = []string{originalFieldName}
404	} else {
405		fieldNames = []string{tagProvidedFieldName}
406	}
407	// private?
408	isNotExported := unicode.IsLower(rune(originalFieldName[0]))
409	if isNotExported {
410		fieldNames = []string{}
411	}
412	return fieldNames
413}
414