Gitiles
Code Review Sign In
gerrit.opencord.org / voltctl / 190091306e109e56f6a2f189ad0ed0011404a311 / . / vendor / github.com / json-iterator / go / reflect_struct_decoder.go
blob: 932641ac46ba3096143a53ffca0ae51017be5af6 [file] [log] [blame]
Zack Williamse940c7a2019-08-21 14:25:39 -0700[diff] [blame]1package jsoniter
2
3import (
4 "fmt"
5 "io"
6 "strings"
7 "unsafe"
8
9 "github.com/modern-go/reflect2"
10)
11
12func decoderOfStruct(ctx *ctx, typ reflect2.Type) ValDecoder {
13 bindings := map[string]*Binding{}
14 structDescriptor := describeStruct(ctx, typ)
15 for _, binding := range structDescriptor.Fields {
16 for _, fromName := range binding.FromNames {
17 old := bindings[fromName]
18 if old == nil {
19 bindings[fromName] = binding
20 continue
21 }
22 ignoreOld, ignoreNew := resolveConflictBinding(ctx.frozenConfig, old, binding)
23 if ignoreOld {
24 delete(bindings, fromName)
25 }
26 if !ignoreNew {
27 bindings[fromName] = binding
28 }
29 }
30 }
31 fields := map[string]*structFieldDecoder{}
32 for k, binding := range bindings {
33 fields[k] = binding.Decoder.(*structFieldDecoder)
34 }
35
36 if !ctx.caseSensitive() {
37 for k, binding := range bindings {
38 if _, found := fields[strings.ToLower(k)]; !found {
39 fields[strings.ToLower(k)] = binding.Decoder.(*structFieldDecoder)
40 }
41 }
42 }
43
44 return createStructDecoder(ctx, typ, fields)
45}
46
47func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structFieldDecoder) ValDecoder {
48 if ctx.disallowUnknownFields {
49 return &generalStructDecoder{typ: typ, fields: fields, disallowUnknownFields: true}
50 }
51 knownHash := map[int64]struct{}{
52 0: {},
53 }
54
55 switch len(fields) {
56 case 0:
57 return &skipObjectDecoder{typ}
58 case 1:
59 for fieldName, fieldDecoder := range fields {
60 fieldHash := calcHash(fieldName, ctx.caseSensitive())
61 _, known := knownHash[fieldHash]
62 if known {
63 return &generalStructDecoder{typ, fields, false}
64 }
65 knownHash[fieldHash] = struct{}{}
66 return &oneFieldStructDecoder{typ, fieldHash, fieldDecoder}
67 }
68 case 2:
69 var fieldHash1 int64
70 var fieldHash2 int64
71 var fieldDecoder1 *structFieldDecoder
72 var fieldDecoder2 *structFieldDecoder
73 for fieldName, fieldDecoder := range fields {
74 fieldHash := calcHash(fieldName, ctx.caseSensitive())
75 _, known := knownHash[fieldHash]
76 if known {
77 return &generalStructDecoder{typ, fields, false}
78 }
79 knownHash[fieldHash] = struct{}{}
80 if fieldHash1 == 0 {
81 fieldHash1 = fieldHash
82 fieldDecoder1 = fieldDecoder
83 } else {
84 fieldHash2 = fieldHash
85 fieldDecoder2 = fieldDecoder
86 }
87 }
88 return &twoFieldsStructDecoder{typ, fieldHash1, fieldDecoder1, fieldHash2, fieldDecoder2}
89 case 3:
90 var fieldName1 int64
91 var fieldName2 int64
92 var fieldName3 int64
93 var fieldDecoder1 *structFieldDecoder
94 var fieldDecoder2 *structFieldDecoder
95 var fieldDecoder3 *structFieldDecoder
96 for fieldName, fieldDecoder := range fields {
97 fieldHash := calcHash(fieldName, ctx.caseSensitive())
98 _, known := knownHash[fieldHash]
99 if known {
100 return &generalStructDecoder{typ, fields, false}
101 }
102 knownHash[fieldHash] = struct{}{}
103 if fieldName1 == 0 {
104 fieldName1 = fieldHash
105 fieldDecoder1 = fieldDecoder
106 } else if fieldName2 == 0 {
107 fieldName2 = fieldHash
108 fieldDecoder2 = fieldDecoder
109 } else {
110 fieldName3 = fieldHash
111 fieldDecoder3 = fieldDecoder
112 }
113 }
114 return &threeFieldsStructDecoder{typ,
115 fieldName1, fieldDecoder1,
116 fieldName2, fieldDecoder2,
117 fieldName3, fieldDecoder3}
118 case 4:
119 var fieldName1 int64
120 var fieldName2 int64
121 var fieldName3 int64
122 var fieldName4 int64
123 var fieldDecoder1 *structFieldDecoder
124 var fieldDecoder2 *structFieldDecoder
125 var fieldDecoder3 *structFieldDecoder
126 var fieldDecoder4 *structFieldDecoder
127 for fieldName, fieldDecoder := range fields {
128 fieldHash := calcHash(fieldName, ctx.caseSensitive())
129 _, known := knownHash[fieldHash]
130 if known {
131 return &generalStructDecoder{typ, fields, false}
132 }
133 knownHash[fieldHash] = struct{}{}
134 if fieldName1 == 0 {
135 fieldName1 = fieldHash
136 fieldDecoder1 = fieldDecoder
137 } else if fieldName2 == 0 {
138 fieldName2 = fieldHash
139 fieldDecoder2 = fieldDecoder
140 } else if fieldName3 == 0 {
141 fieldName3 = fieldHash
142 fieldDecoder3 = fieldDecoder
143 } else {
144 fieldName4 = fieldHash
145 fieldDecoder4 = fieldDecoder
146 }
147 }
148 return &fourFieldsStructDecoder{typ,
149 fieldName1, fieldDecoder1,
150 fieldName2, fieldDecoder2,
151 fieldName3, fieldDecoder3,
152 fieldName4, fieldDecoder4}
153 case 5:
154 var fieldName1 int64
155 var fieldName2 int64
156 var fieldName3 int64
157 var fieldName4 int64
158 var fieldName5 int64
159 var fieldDecoder1 *structFieldDecoder
160 var fieldDecoder2 *structFieldDecoder
161 var fieldDecoder3 *structFieldDecoder
162 var fieldDecoder4 *structFieldDecoder
163 var fieldDecoder5 *structFieldDecoder
164 for fieldName, fieldDecoder := range fields {
165 fieldHash := calcHash(fieldName, ctx.caseSensitive())
166 _, known := knownHash[fieldHash]
167 if known {
168 return &generalStructDecoder{typ, fields, false}
169 }
170 knownHash[fieldHash] = struct{}{}
171 if fieldName1 == 0 {
172 fieldName1 = fieldHash
173 fieldDecoder1 = fieldDecoder
174 } else if fieldName2 == 0 {
175 fieldName2 = fieldHash
176 fieldDecoder2 = fieldDecoder
177 } else if fieldName3 == 0 {
178 fieldName3 = fieldHash
179 fieldDecoder3 = fieldDecoder
180 } else if fieldName4 == 0 {
181 fieldName4 = fieldHash
182 fieldDecoder4 = fieldDecoder
183 } else {
184 fieldName5 = fieldHash
185 fieldDecoder5 = fieldDecoder
186 }
187 }
188 return &fiveFieldsStructDecoder{typ,
189 fieldName1, fieldDecoder1,
190 fieldName2, fieldDecoder2,
191 fieldName3, fieldDecoder3,
192 fieldName4, fieldDecoder4,
193 fieldName5, fieldDecoder5}
194 case 6:
195 var fieldName1 int64
196 var fieldName2 int64
197 var fieldName3 int64
198 var fieldName4 int64
199 var fieldName5 int64
200 var fieldName6 int64
201 var fieldDecoder1 *structFieldDecoder
202 var fieldDecoder2 *structFieldDecoder
203 var fieldDecoder3 *structFieldDecoder
204 var fieldDecoder4 *structFieldDecoder
205 var fieldDecoder5 *structFieldDecoder
206 var fieldDecoder6 *structFieldDecoder
207 for fieldName, fieldDecoder := range fields {
208 fieldHash := calcHash(fieldName, ctx.caseSensitive())
209 _, known := knownHash[fieldHash]
210 if known {
211 return &generalStructDecoder{typ, fields, false}
212 }
213 knownHash[fieldHash] = struct{}{}
214 if fieldName1 == 0 {
215 fieldName1 = fieldHash
216 fieldDecoder1 = fieldDecoder
217 } else if fieldName2 == 0 {
218 fieldName2 = fieldHash
219 fieldDecoder2 = fieldDecoder
220 } else if fieldName3 == 0 {
221 fieldName3 = fieldHash
222 fieldDecoder3 = fieldDecoder
223 } else if fieldName4 == 0 {
224 fieldName4 = fieldHash
225 fieldDecoder4 = fieldDecoder
226 } else if fieldName5 == 0 {
227 fieldName5 = fieldHash
228 fieldDecoder5 = fieldDecoder
229 } else {
230 fieldName6 = fieldHash
231 fieldDecoder6 = fieldDecoder
232 }
233 }
234 return &sixFieldsStructDecoder{typ,
235 fieldName1, fieldDecoder1,
236 fieldName2, fieldDecoder2,
237 fieldName3, fieldDecoder3,
238 fieldName4, fieldDecoder4,
239 fieldName5, fieldDecoder5,
240 fieldName6, fieldDecoder6}
241 case 7:
242 var fieldName1 int64
243 var fieldName2 int64
244 var fieldName3 int64
245 var fieldName4 int64
246 var fieldName5 int64
247 var fieldName6 int64
248 var fieldName7 int64
249 var fieldDecoder1 *structFieldDecoder
250 var fieldDecoder2 *structFieldDecoder
251 var fieldDecoder3 *structFieldDecoder
252 var fieldDecoder4 *structFieldDecoder
253 var fieldDecoder5 *structFieldDecoder
254 var fieldDecoder6 *structFieldDecoder
255 var fieldDecoder7 *structFieldDecoder
256 for fieldName, fieldDecoder := range fields {
257 fieldHash := calcHash(fieldName, ctx.caseSensitive())
258 _, known := knownHash[fieldHash]
259 if known {
260 return &generalStructDecoder{typ, fields, false}
261 }
262 knownHash[fieldHash] = struct{}{}
263 if fieldName1 == 0 {
264 fieldName1 = fieldHash
265 fieldDecoder1 = fieldDecoder
266 } else if fieldName2 == 0 {
267 fieldName2 = fieldHash
268 fieldDecoder2 = fieldDecoder
269 } else if fieldName3 == 0 {
270 fieldName3 = fieldHash
271 fieldDecoder3 = fieldDecoder
272 } else if fieldName4 == 0 {
273 fieldName4 = fieldHash
274 fieldDecoder4 = fieldDecoder
275 } else if fieldName5 == 0 {
276 fieldName5 = fieldHash
277 fieldDecoder5 = fieldDecoder
278 } else if fieldName6 == 0 {
279 fieldName6 = fieldHash
280 fieldDecoder6 = fieldDecoder
281 } else {
282 fieldName7 = fieldHash
283 fieldDecoder7 = fieldDecoder
284 }
285 }
286 return &sevenFieldsStructDecoder{typ,
287 fieldName1, fieldDecoder1,
288 fieldName2, fieldDecoder2,
289 fieldName3, fieldDecoder3,
290 fieldName4, fieldDecoder4,
291 fieldName5, fieldDecoder5,
292 fieldName6, fieldDecoder6,
293 fieldName7, fieldDecoder7}
294 case 8:
295 var fieldName1 int64
296 var fieldName2 int64
297 var fieldName3 int64
298 var fieldName4 int64
299 var fieldName5 int64
300 var fieldName6 int64
301 var fieldName7 int64
302 var fieldName8 int64
303 var fieldDecoder1 *structFieldDecoder
304 var fieldDecoder2 *structFieldDecoder
305 var fieldDecoder3 *structFieldDecoder
306 var fieldDecoder4 *structFieldDecoder
307 var fieldDecoder5 *structFieldDecoder
308 var fieldDecoder6 *structFieldDecoder
309 var fieldDecoder7 *structFieldDecoder
310 var fieldDecoder8 *structFieldDecoder
311 for fieldName, fieldDecoder := range fields {
312 fieldHash := calcHash(fieldName, ctx.caseSensitive())
313 _, known := knownHash[fieldHash]
314 if known {
315 return &generalStructDecoder{typ, fields, false}
316 }
317 knownHash[fieldHash] = struct{}{}
318 if fieldName1 == 0 {
319 fieldName1 = fieldHash
320 fieldDecoder1 = fieldDecoder
321 } else if fieldName2 == 0 {
322 fieldName2 = fieldHash
323 fieldDecoder2 = fieldDecoder
324 } else if fieldName3 == 0 {
325 fieldName3 = fieldHash
326 fieldDecoder3 = fieldDecoder
327 } else if fieldName4 == 0 {
328 fieldName4 = fieldHash
329 fieldDecoder4 = fieldDecoder
330 } else if fieldName5 == 0 {
331 fieldName5 = fieldHash
332 fieldDecoder5 = fieldDecoder
333 } else if fieldName6 == 0 {
334 fieldName6 = fieldHash
335 fieldDecoder6 = fieldDecoder
336 } else if fieldName7 == 0 {
337 fieldName7 = fieldHash
338 fieldDecoder7 = fieldDecoder
339 } else {
340 fieldName8 = fieldHash
341 fieldDecoder8 = fieldDecoder
342 }
343 }
344 return &eightFieldsStructDecoder{typ,
345 fieldName1, fieldDecoder1,
346 fieldName2, fieldDecoder2,
347 fieldName3, fieldDecoder3,
348 fieldName4, fieldDecoder4,
349 fieldName5, fieldDecoder5,
350 fieldName6, fieldDecoder6,
351 fieldName7, fieldDecoder7,
352 fieldName8, fieldDecoder8}
353 case 9:
354 var fieldName1 int64
355 var fieldName2 int64
356 var fieldName3 int64
357 var fieldName4 int64
358 var fieldName5 int64
359 var fieldName6 int64
360 var fieldName7 int64
361 var fieldName8 int64
362 var fieldName9 int64
363 var fieldDecoder1 *structFieldDecoder
364 var fieldDecoder2 *structFieldDecoder
365 var fieldDecoder3 *structFieldDecoder
366 var fieldDecoder4 *structFieldDecoder
367 var fieldDecoder5 *structFieldDecoder
368 var fieldDecoder6 *structFieldDecoder
369 var fieldDecoder7 *structFieldDecoder
370 var fieldDecoder8 *structFieldDecoder
371 var fieldDecoder9 *structFieldDecoder
372 for fieldName, fieldDecoder := range fields {
373 fieldHash := calcHash(fieldName, ctx.caseSensitive())
374 _, known := knownHash[fieldHash]
375 if known {
376 return &generalStructDecoder{typ, fields, false}
377 }
378 knownHash[fieldHash] = struct{}{}
379 if fieldName1 == 0 {
380 fieldName1 = fieldHash
381 fieldDecoder1 = fieldDecoder
382 } else if fieldName2 == 0 {
383 fieldName2 = fieldHash
384 fieldDecoder2 = fieldDecoder
385 } else if fieldName3 == 0 {
386 fieldName3 = fieldHash
387 fieldDecoder3 = fieldDecoder
388 } else if fieldName4 == 0 {
389 fieldName4 = fieldHash
390 fieldDecoder4 = fieldDecoder
391 } else if fieldName5 == 0 {
392 fieldName5 = fieldHash
393 fieldDecoder5 = fieldDecoder
394 } else if fieldName6 == 0 {
395 fieldName6 = fieldHash
396 fieldDecoder6 = fieldDecoder
397 } else if fieldName7 == 0 {
398 fieldName7 = fieldHash
399 fieldDecoder7 = fieldDecoder
400 } else if fieldName8 == 0 {
401 fieldName8 = fieldHash
402 fieldDecoder8 = fieldDecoder
403 } else {
404 fieldName9 = fieldHash
405 fieldDecoder9 = fieldDecoder
406 }
407 }
408 return &nineFieldsStructDecoder{typ,
409 fieldName1, fieldDecoder1,
410 fieldName2, fieldDecoder2,
411 fieldName3, fieldDecoder3,
412 fieldName4, fieldDecoder4,
413 fieldName5, fieldDecoder5,
414 fieldName6, fieldDecoder6,
415 fieldName7, fieldDecoder7,
416 fieldName8, fieldDecoder8,
417 fieldName9, fieldDecoder9}
418 case 10:
419 var fieldName1 int64
420 var fieldName2 int64
421 var fieldName3 int64
422 var fieldName4 int64
423 var fieldName5 int64
424 var fieldName6 int64
425 var fieldName7 int64
426 var fieldName8 int64
427 var fieldName9 int64
428 var fieldName10 int64
429 var fieldDecoder1 *structFieldDecoder
430 var fieldDecoder2 *structFieldDecoder
431 var fieldDecoder3 *structFieldDecoder
432 var fieldDecoder4 *structFieldDecoder
433 var fieldDecoder5 *structFieldDecoder
434 var fieldDecoder6 *structFieldDecoder
435 var fieldDecoder7 *structFieldDecoder
436 var fieldDecoder8 *structFieldDecoder
437 var fieldDecoder9 *structFieldDecoder
438 var fieldDecoder10 *structFieldDecoder
439 for fieldName, fieldDecoder := range fields {
440 fieldHash := calcHash(fieldName, ctx.caseSensitive())
441 _, known := knownHash[fieldHash]
442 if known {
443 return &generalStructDecoder{typ, fields, false}
444 }
445 knownHash[fieldHash] = struct{}{}
446 if fieldName1 == 0 {
447 fieldName1 = fieldHash
448 fieldDecoder1 = fieldDecoder
449 } else if fieldName2 == 0 {
450 fieldName2 = fieldHash
451 fieldDecoder2 = fieldDecoder
452 } else if fieldName3 == 0 {
453 fieldName3 = fieldHash
454 fieldDecoder3 = fieldDecoder
455 } else if fieldName4 == 0 {
456 fieldName4 = fieldHash
457 fieldDecoder4 = fieldDecoder
458 } else if fieldName5 == 0 {
459 fieldName5 = fieldHash
460 fieldDecoder5 = fieldDecoder
461 } else if fieldName6 == 0 {
462 fieldName6 = fieldHash
463 fieldDecoder6 = fieldDecoder
464 } else if fieldName7 == 0 {
465 fieldName7 = fieldHash
466 fieldDecoder7 = fieldDecoder
467 } else if fieldName8 == 0 {
468 fieldName8 = fieldHash
469 fieldDecoder8 = fieldDecoder
470 } else if fieldName9 == 0 {
471 fieldName9 = fieldHash
472 fieldDecoder9 = fieldDecoder
473 } else {
474 fieldName10 = fieldHash
475 fieldDecoder10 = fieldDecoder
476 }
477 }
478 return &tenFieldsStructDecoder{typ,
479 fieldName1, fieldDecoder1,
480 fieldName2, fieldDecoder2,
481 fieldName3, fieldDecoder3,
482 fieldName4, fieldDecoder4,
483 fieldName5, fieldDecoder5,
484 fieldName6, fieldDecoder6,
485 fieldName7, fieldDecoder7,
486 fieldName8, fieldDecoder8,
487 fieldName9, fieldDecoder9,
488 fieldName10, fieldDecoder10}
489 }
490 return &generalStructDecoder{typ, fields, false}
491}
492
493type generalStructDecoder struct {
494 typ reflect2.Type
495 fields map[string]*structFieldDecoder
496 disallowUnknownFields bool
497}
498
499func (decoder *generalStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
500 if !iter.readObjectStart() {
501 return
502 }
503 var c byte
504 for c = ','; c == ','; c = iter.nextToken() {
505 decoder.decodeOneField(ptr, iter)
506 }
507 if iter.Error != nil && iter.Error != io.EOF {
508 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
509 }
510 if c != '}' {
511 iter.ReportError("struct Decode", `expect }, but found `+string([]byte{c}))
512 }
513}
514
515func (decoder *generalStructDecoder) decodeOneField(ptr unsafe.Pointer, iter *Iterator) {
516 var field string
517 var fieldDecoder *structFieldDecoder
518 if iter.cfg.objectFieldMustBeSimpleString {
519 fieldBytes := iter.ReadStringAsSlice()
520 field = *(*string)(unsafe.Pointer(&fieldBytes))
521 fieldDecoder = decoder.fields[field]
522 if fieldDecoder == nil && !iter.cfg.caseSensitive {
523 fieldDecoder = decoder.fields[strings.ToLower(field)]
524 }
525 } else {
526 field = iter.ReadString()
527 fieldDecoder = decoder.fields[field]
528 if fieldDecoder == nil && !iter.cfg.caseSensitive {
529 fieldDecoder = decoder.fields[strings.ToLower(field)]
530 }
531 }
532 if fieldDecoder == nil {
Zack Williamse940c7a2019-08-21 14:25:39 -0700[diff] [blame]533 if decoder.disallowUnknownFields {
divyadesai19009132020-03-04 12:58:08 +0000[diff] [blame^]534 msg := "found unknown field: " + field
Zack Williamse940c7a2019-08-21 14:25:39 -0700[diff] [blame]535 iter.ReportError("ReadObject", msg)
536 }
537 c := iter.nextToken()
538 if c != ':' {
539 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
540 }
541 iter.Skip()
542 return
543 }
544 c := iter.nextToken()
545 if c != ':' {
546 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
547 }
548 fieldDecoder.Decode(ptr, iter)
549}
550
551type skipObjectDecoder struct {
552 typ reflect2.Type
553}
554
555func (decoder *skipObjectDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
556 valueType := iter.WhatIsNext()
557 if valueType != ObjectValue && valueType != NilValue {
558 iter.ReportError("skipObjectDecoder", "expect object or null")
559 return
560 }
561 iter.Skip()
562}
563
564type oneFieldStructDecoder struct {
565 typ reflect2.Type
566 fieldHash int64
567 fieldDecoder *structFieldDecoder
568}
569
570func (decoder *oneFieldStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
571 if !iter.readObjectStart() {
572 return
573 }
574 for {
575 if iter.readFieldHash() == decoder.fieldHash {
576 decoder.fieldDecoder.Decode(ptr, iter)
577 } else {
578 iter.Skip()
579 }
580 if iter.isObjectEnd() {
581 break
582 }
583 }
584 if iter.Error != nil && iter.Error != io.EOF {
585 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
586 }
587}
588
589type twoFieldsStructDecoder struct {
590 typ reflect2.Type
591 fieldHash1 int64
592 fieldDecoder1 *structFieldDecoder
593 fieldHash2 int64
594 fieldDecoder2 *structFieldDecoder
595}
596
597func (decoder *twoFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
598 if !iter.readObjectStart() {
599 return
600 }
601 for {
602 switch iter.readFieldHash() {
603 case decoder.fieldHash1:
604 decoder.fieldDecoder1.Decode(ptr, iter)
605 case decoder.fieldHash2:
606 decoder.fieldDecoder2.Decode(ptr, iter)
607 default:
608 iter.Skip()
609 }
610 if iter.isObjectEnd() {
611 break
612 }
613 }
614 if iter.Error != nil && iter.Error != io.EOF {
615 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
616 }
617}
618
619type threeFieldsStructDecoder struct {
620 typ reflect2.Type
621 fieldHash1 int64
622 fieldDecoder1 *structFieldDecoder
623 fieldHash2 int64
624 fieldDecoder2 *structFieldDecoder
625 fieldHash3 int64
626 fieldDecoder3 *structFieldDecoder
627}
628
629func (decoder *threeFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
630 if !iter.readObjectStart() {
631 return
632 }
633 for {
634 switch iter.readFieldHash() {
635 case decoder.fieldHash1:
636 decoder.fieldDecoder1.Decode(ptr, iter)
637 case decoder.fieldHash2:
638 decoder.fieldDecoder2.Decode(ptr, iter)
639 case decoder.fieldHash3:
640 decoder.fieldDecoder3.Decode(ptr, iter)
641 default:
642 iter.Skip()
643 }
644 if iter.isObjectEnd() {
645 break
646 }
647 }
648 if iter.Error != nil && iter.Error != io.EOF {
649 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
650 }
651}
652
653type fourFieldsStructDecoder struct {
654 typ reflect2.Type
655 fieldHash1 int64
656 fieldDecoder1 *structFieldDecoder
657 fieldHash2 int64
658 fieldDecoder2 *structFieldDecoder
659 fieldHash3 int64
660 fieldDecoder3 *structFieldDecoder
661 fieldHash4 int64
662 fieldDecoder4 *structFieldDecoder
663}
664
665func (decoder *fourFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
666 if !iter.readObjectStart() {
667 return
668 }
669 for {
670 switch iter.readFieldHash() {
671 case decoder.fieldHash1:
672 decoder.fieldDecoder1.Decode(ptr, iter)
673 case decoder.fieldHash2:
674 decoder.fieldDecoder2.Decode(ptr, iter)
675 case decoder.fieldHash3:
676 decoder.fieldDecoder3.Decode(ptr, iter)
677 case decoder.fieldHash4:
678 decoder.fieldDecoder4.Decode(ptr, iter)
679 default:
680 iter.Skip()
681 }
682 if iter.isObjectEnd() {
683 break
684 }
685 }
686 if iter.Error != nil && iter.Error != io.EOF {
687 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
688 }
689}
690
691type fiveFieldsStructDecoder struct {
692 typ reflect2.Type
693 fieldHash1 int64
694 fieldDecoder1 *structFieldDecoder
695 fieldHash2 int64
696 fieldDecoder2 *structFieldDecoder
697 fieldHash3 int64
698 fieldDecoder3 *structFieldDecoder
699 fieldHash4 int64
700 fieldDecoder4 *structFieldDecoder
701 fieldHash5 int64
702 fieldDecoder5 *structFieldDecoder
703}
704
705func (decoder *fiveFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
706 if !iter.readObjectStart() {
707 return
708 }
709 for {
710 switch iter.readFieldHash() {
711 case decoder.fieldHash1:
712 decoder.fieldDecoder1.Decode(ptr, iter)
713 case decoder.fieldHash2:
714 decoder.fieldDecoder2.Decode(ptr, iter)
715 case decoder.fieldHash3:
716 decoder.fieldDecoder3.Decode(ptr, iter)
717 case decoder.fieldHash4:
718 decoder.fieldDecoder4.Decode(ptr, iter)
719 case decoder.fieldHash5:
720 decoder.fieldDecoder5.Decode(ptr, iter)
721 default:
722 iter.Skip()
723 }
724 if iter.isObjectEnd() {
725 break
726 }
727 }
728 if iter.Error != nil && iter.Error != io.EOF {
729 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
730 }
731}
732
733type sixFieldsStructDecoder struct {
734 typ reflect2.Type
735 fieldHash1 int64
736 fieldDecoder1 *structFieldDecoder
737 fieldHash2 int64
738 fieldDecoder2 *structFieldDecoder
739 fieldHash3 int64
740 fieldDecoder3 *structFieldDecoder
741 fieldHash4 int64
742 fieldDecoder4 *structFieldDecoder
743 fieldHash5 int64
744 fieldDecoder5 *structFieldDecoder
745 fieldHash6 int64
746 fieldDecoder6 *structFieldDecoder
747}
748
749func (decoder *sixFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
750 if !iter.readObjectStart() {
751 return
752 }
753 for {
754 switch iter.readFieldHash() {
755 case decoder.fieldHash1:
756 decoder.fieldDecoder1.Decode(ptr, iter)
757 case decoder.fieldHash2:
758 decoder.fieldDecoder2.Decode(ptr, iter)
759 case decoder.fieldHash3:
760 decoder.fieldDecoder3.Decode(ptr, iter)
761 case decoder.fieldHash4:
762 decoder.fieldDecoder4.Decode(ptr, iter)
763 case decoder.fieldHash5:
764 decoder.fieldDecoder5.Decode(ptr, iter)
765 case decoder.fieldHash6:
766 decoder.fieldDecoder6.Decode(ptr, iter)
767 default:
768 iter.Skip()
769 }
770 if iter.isObjectEnd() {
771 break
772 }
773 }
774 if iter.Error != nil && iter.Error != io.EOF {
775 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
776 }
777}
778
779type sevenFieldsStructDecoder struct {
780 typ reflect2.Type
781 fieldHash1 int64
782 fieldDecoder1 *structFieldDecoder
783 fieldHash2 int64
784 fieldDecoder2 *structFieldDecoder
785 fieldHash3 int64
786 fieldDecoder3 *structFieldDecoder
787 fieldHash4 int64
788 fieldDecoder4 *structFieldDecoder
789 fieldHash5 int64
790 fieldDecoder5 *structFieldDecoder
791 fieldHash6 int64
792 fieldDecoder6 *structFieldDecoder
793 fieldHash7 int64
794 fieldDecoder7 *structFieldDecoder
795}
796
797func (decoder *sevenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
798 if !iter.readObjectStart() {
799 return
800 }
801 for {
802 switch iter.readFieldHash() {
803 case decoder.fieldHash1:
804 decoder.fieldDecoder1.Decode(ptr, iter)
805 case decoder.fieldHash2:
806 decoder.fieldDecoder2.Decode(ptr, iter)
807 case decoder.fieldHash3:
808 decoder.fieldDecoder3.Decode(ptr, iter)
809 case decoder.fieldHash4:
810 decoder.fieldDecoder4.Decode(ptr, iter)
811 case decoder.fieldHash5:
812 decoder.fieldDecoder5.Decode(ptr, iter)
813 case decoder.fieldHash6:
814 decoder.fieldDecoder6.Decode(ptr, iter)
815 case decoder.fieldHash7:
816 decoder.fieldDecoder7.Decode(ptr, iter)
817 default:
818 iter.Skip()
819 }
820 if iter.isObjectEnd() {
821 break
822 }
823 }
824 if iter.Error != nil && iter.Error != io.EOF {
825 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
826 }
827}
828
829type eightFieldsStructDecoder struct {
830 typ reflect2.Type
831 fieldHash1 int64
832 fieldDecoder1 *structFieldDecoder
833 fieldHash2 int64
834 fieldDecoder2 *structFieldDecoder
835 fieldHash3 int64
836 fieldDecoder3 *structFieldDecoder
837 fieldHash4 int64
838 fieldDecoder4 *structFieldDecoder
839 fieldHash5 int64
840 fieldDecoder5 *structFieldDecoder
841 fieldHash6 int64
842 fieldDecoder6 *structFieldDecoder
843 fieldHash7 int64
844 fieldDecoder7 *structFieldDecoder
845 fieldHash8 int64
846 fieldDecoder8 *structFieldDecoder
847}
848
849func (decoder *eightFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
850 if !iter.readObjectStart() {
851 return
852 }
853 for {
854 switch iter.readFieldHash() {
855 case decoder.fieldHash1:
856 decoder.fieldDecoder1.Decode(ptr, iter)
857 case decoder.fieldHash2:
858 decoder.fieldDecoder2.Decode(ptr, iter)
859 case decoder.fieldHash3:
860 decoder.fieldDecoder3.Decode(ptr, iter)
861 case decoder.fieldHash4:
862 decoder.fieldDecoder4.Decode(ptr, iter)
863 case decoder.fieldHash5:
864 decoder.fieldDecoder5.Decode(ptr, iter)
865 case decoder.fieldHash6:
866 decoder.fieldDecoder6.Decode(ptr, iter)
867 case decoder.fieldHash7:
868 decoder.fieldDecoder7.Decode(ptr, iter)
869 case decoder.fieldHash8:
870 decoder.fieldDecoder8.Decode(ptr, iter)
871 default:
872 iter.Skip()
873 }
874 if iter.isObjectEnd() {
875 break
876 }
877 }
878 if iter.Error != nil && iter.Error != io.EOF {
879 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
880 }
881}
882
883type nineFieldsStructDecoder struct {
884 typ reflect2.Type
885 fieldHash1 int64
886 fieldDecoder1 *structFieldDecoder
887 fieldHash2 int64
888 fieldDecoder2 *structFieldDecoder
889 fieldHash3 int64
890 fieldDecoder3 *structFieldDecoder
891 fieldHash4 int64
892 fieldDecoder4 *structFieldDecoder
893 fieldHash5 int64
894 fieldDecoder5 *structFieldDecoder
895 fieldHash6 int64
896 fieldDecoder6 *structFieldDecoder
897 fieldHash7 int64
898 fieldDecoder7 *structFieldDecoder
899 fieldHash8 int64
900 fieldDecoder8 *structFieldDecoder
901 fieldHash9 int64
902 fieldDecoder9 *structFieldDecoder
903}
904
905func (decoder *nineFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
906 if !iter.readObjectStart() {
907 return
908 }
909 for {
910 switch iter.readFieldHash() {
911 case decoder.fieldHash1:
912 decoder.fieldDecoder1.Decode(ptr, iter)
913 case decoder.fieldHash2:
914 decoder.fieldDecoder2.Decode(ptr, iter)
915 case decoder.fieldHash3:
916 decoder.fieldDecoder3.Decode(ptr, iter)
917 case decoder.fieldHash4:
918 decoder.fieldDecoder4.Decode(ptr, iter)
919 case decoder.fieldHash5:
920 decoder.fieldDecoder5.Decode(ptr, iter)
921 case decoder.fieldHash6:
922 decoder.fieldDecoder6.Decode(ptr, iter)
923 case decoder.fieldHash7:
924 decoder.fieldDecoder7.Decode(ptr, iter)
925 case decoder.fieldHash8:
926 decoder.fieldDecoder8.Decode(ptr, iter)
927 case decoder.fieldHash9:
928 decoder.fieldDecoder9.Decode(ptr, iter)
929 default:
930 iter.Skip()
931 }
932 if iter.isObjectEnd() {
933 break
934 }
935 }
936 if iter.Error != nil && iter.Error != io.EOF {
937 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
938 }
939}
940
941type tenFieldsStructDecoder struct {
942 typ reflect2.Type
943 fieldHash1 int64
944 fieldDecoder1 *structFieldDecoder
945 fieldHash2 int64
946 fieldDecoder2 *structFieldDecoder
947 fieldHash3 int64
948 fieldDecoder3 *structFieldDecoder
949 fieldHash4 int64
950 fieldDecoder4 *structFieldDecoder
951 fieldHash5 int64
952 fieldDecoder5 *structFieldDecoder
953 fieldHash6 int64
954 fieldDecoder6 *structFieldDecoder
955 fieldHash7 int64
956 fieldDecoder7 *structFieldDecoder
957 fieldHash8 int64
958 fieldDecoder8 *structFieldDecoder
959 fieldHash9 int64
960 fieldDecoder9 *structFieldDecoder
961 fieldHash10 int64
962 fieldDecoder10 *structFieldDecoder
963}
964
965func (decoder *tenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
966 if !iter.readObjectStart() {
967 return
968 }
969 for {
970 switch iter.readFieldHash() {
971 case decoder.fieldHash1:
972 decoder.fieldDecoder1.Decode(ptr, iter)
973 case decoder.fieldHash2:
974 decoder.fieldDecoder2.Decode(ptr, iter)
975 case decoder.fieldHash3:
976 decoder.fieldDecoder3.Decode(ptr, iter)
977 case decoder.fieldHash4:
978 decoder.fieldDecoder4.Decode(ptr, iter)
979 case decoder.fieldHash5:
980 decoder.fieldDecoder5.Decode(ptr, iter)
981 case decoder.fieldHash6:
982 decoder.fieldDecoder6.Decode(ptr, iter)
983 case decoder.fieldHash7:
984 decoder.fieldDecoder7.Decode(ptr, iter)
985 case decoder.fieldHash8:
986 decoder.fieldDecoder8.Decode(ptr, iter)
987 case decoder.fieldHash9:
988 decoder.fieldDecoder9.Decode(ptr, iter)
989 case decoder.fieldHash10:
990 decoder.fieldDecoder10.Decode(ptr, iter)
991 default:
992 iter.Skip()
993 }
994 if iter.isObjectEnd() {
995 break
996 }
997 }
998 if iter.Error != nil && iter.Error != io.EOF {
999 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
1000 }
1001}
1002
1003type structFieldDecoder struct {
1004 field reflect2.StructField
1005 fieldDecoder ValDecoder
1006}
1007
1008func (decoder *structFieldDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1009 fieldPtr := decoder.field.UnsafeGet(ptr)
1010 decoder.fieldDecoder.Decode(fieldPtr, iter)
1011 if iter.Error != nil && iter.Error != io.EOF {
1012 iter.Error = fmt.Errorf("%s: %s", decoder.field.Name(), iter.Error.Error())
1013 }
1014}
1015
1016type stringModeStringDecoder struct {
1017 elemDecoder ValDecoder
1018 cfg *frozenConfig
1019}
1020
1021func (decoder *stringModeStringDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1022 decoder.elemDecoder.Decode(ptr, iter)
1023 str := *((*string)(ptr))
1024 tempIter := decoder.cfg.BorrowIterator([]byte(str))
1025 defer decoder.cfg.ReturnIterator(tempIter)
1026 *((*string)(ptr)) = tempIter.ReadString()
1027}
1028
1029type stringModeNumberDecoder struct {
1030 elemDecoder ValDecoder
1031}
1032
1033func (decoder *stringModeNumberDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1034 c := iter.nextToken()
1035 if c != '"' {
1036 iter.ReportError("stringModeNumberDecoder", `expect ", but found `+string([]byte{c}))
1037 return
1038 }
1039 decoder.elemDecoder.Decode(ptr, iter)
1040 if iter.Error != nil {
1041 return
1042 }
1043 c = iter.readByte()
1044 if c != '"' {
1045 iter.ReportError("stringModeNumberDecoder", `expect ", but found `+string([]byte{c}))
1046 return
1047 }
1048}