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