9 "github.com/modern-go/reflect2"
12 func 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]
19 bindings[fromName] = binding
22 ignoreOld, ignoreNew := resolveConflictBinding(ctx.frozenConfig, old, binding)
24 delete(bindings, fromName)
27 bindings[fromName] = binding
31 fields := map[string]*structFieldDecoder{}
32 for k, binding := range bindings {
33 fields[k] = binding.Decoder.(*structFieldDecoder)
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)
44 return createStructDecoder(ctx, typ, fields)
47 func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structFieldDecoder) ValDecoder {
48 if ctx.disallowUnknownFields {
49 return &generalStructDecoder{typ: typ, fields: fields, disallowUnknownFields: true}
51 knownHash := map[int64]struct{}{
57 return &skipObjectDecoder{typ}
59 for fieldName, fieldDecoder := range fields {
60 fieldHash := calcHash(fieldName, ctx.caseSensitive())
61 _, known := knownHash[fieldHash]
63 return &generalStructDecoder{typ, fields, false}
65 knownHash[fieldHash] = struct{}{}
66 return &oneFieldStructDecoder{typ, fieldHash, fieldDecoder}
71 var fieldDecoder1 *structFieldDecoder
72 var fieldDecoder2 *structFieldDecoder
73 for fieldName, fieldDecoder := range fields {
74 fieldHash := calcHash(fieldName, ctx.caseSensitive())
75 _, known := knownHash[fieldHash]
77 return &generalStructDecoder{typ, fields, false}
79 knownHash[fieldHash] = struct{}{}
81 fieldHash1 = fieldHash
82 fieldDecoder1 = fieldDecoder
84 fieldHash2 = fieldHash
85 fieldDecoder2 = fieldDecoder
88 return &twoFieldsStructDecoder{typ, fieldHash1, fieldDecoder1, fieldHash2, fieldDecoder2}
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]
100 return &generalStructDecoder{typ, fields, false}
102 knownHash[fieldHash] = struct{}{}
104 fieldName1 = fieldHash
105 fieldDecoder1 = fieldDecoder
106 } else if fieldName2 == 0 {
107 fieldName2 = fieldHash
108 fieldDecoder2 = fieldDecoder
110 fieldName3 = fieldHash
111 fieldDecoder3 = fieldDecoder
114 return &threeFieldsStructDecoder{typ,
115 fieldName1, fieldDecoder1,
116 fieldName2, fieldDecoder2,
117 fieldName3, fieldDecoder3}
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]
131 return &generalStructDecoder{typ, fields, false}
133 knownHash[fieldHash] = struct{}{}
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
144 fieldName4 = fieldHash
145 fieldDecoder4 = fieldDecoder
148 return &fourFieldsStructDecoder{typ,
149 fieldName1, fieldDecoder1,
150 fieldName2, fieldDecoder2,
151 fieldName3, fieldDecoder3,
152 fieldName4, fieldDecoder4}
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]
168 return &generalStructDecoder{typ, fields, false}
170 knownHash[fieldHash] = struct{}{}
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
184 fieldName5 = fieldHash
185 fieldDecoder5 = fieldDecoder
188 return &fiveFieldsStructDecoder{typ,
189 fieldName1, fieldDecoder1,
190 fieldName2, fieldDecoder2,
191 fieldName3, fieldDecoder3,
192 fieldName4, fieldDecoder4,
193 fieldName5, fieldDecoder5}
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]
211 return &generalStructDecoder{typ, fields, false}
213 knownHash[fieldHash] = struct{}{}
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
230 fieldName6 = fieldHash
231 fieldDecoder6 = fieldDecoder
234 return &sixFieldsStructDecoder{typ,
235 fieldName1, fieldDecoder1,
236 fieldName2, fieldDecoder2,
237 fieldName3, fieldDecoder3,
238 fieldName4, fieldDecoder4,
239 fieldName5, fieldDecoder5,
240 fieldName6, fieldDecoder6}
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]
260 return &generalStructDecoder{typ, fields, false}
262 knownHash[fieldHash] = struct{}{}
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
282 fieldName7 = fieldHash
283 fieldDecoder7 = fieldDecoder
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}
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]
315 return &generalStructDecoder{typ, fields, false}
317 knownHash[fieldHash] = struct{}{}
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
340 fieldName8 = fieldHash
341 fieldDecoder8 = fieldDecoder
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}
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]
376 return &generalStructDecoder{typ, fields, false}
378 knownHash[fieldHash] = struct{}{}
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
404 fieldName9 = fieldHash
405 fieldDecoder9 = fieldDecoder
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}
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]
443 return &generalStructDecoder{typ, fields, false}
445 knownHash[fieldHash] = struct{}{}
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
474 fieldName10 = fieldHash
475 fieldDecoder10 = fieldDecoder
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}
490 return &generalStructDecoder{typ, fields, false}
493 type generalStructDecoder struct {
495 fields map[string]*structFieldDecoder
496 disallowUnknownFields bool
499 func (decoder *generalStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
500 if !iter.readObjectStart() {
504 for c = ','; c == ','; c = iter.nextToken() {
505 decoder.decodeOneField(ptr, iter)
507 if iter.Error != nil && iter.Error != io.EOF {
508 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
511 iter.ReportError("struct Decode", `expect }, but found `+string([]byte{c}))
515 func (decoder *generalStructDecoder) decodeOneField(ptr unsafe.Pointer, iter *Iterator) {
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)]
526 field = iter.ReadString()
527 fieldDecoder = decoder.fields[field]
528 if fieldDecoder == nil && !iter.cfg.caseSensitive {
529 fieldDecoder = decoder.fields[strings.ToLower(field)]
532 if fieldDecoder == nil {
533 msg := "found unknown field: " + field
534 if decoder.disallowUnknownFields {
535 iter.ReportError("ReadObject", msg)
537 c := iter.nextToken()
539 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
544 c := iter.nextToken()
546 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
548 fieldDecoder.Decode(ptr, iter)
551 type skipObjectDecoder struct {
555 func (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")
564 type oneFieldStructDecoder struct {
567 fieldDecoder *structFieldDecoder
570 func (decoder *oneFieldStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
571 if !iter.readObjectStart() {
575 if iter.readFieldHash() == decoder.fieldHash {
576 decoder.fieldDecoder.Decode(ptr, iter)
580 if iter.isObjectEnd() {
584 if iter.Error != nil && iter.Error != io.EOF {
585 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
589 type twoFieldsStructDecoder struct {
592 fieldDecoder1 *structFieldDecoder
594 fieldDecoder2 *structFieldDecoder
597 func (decoder *twoFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
598 if !iter.readObjectStart() {
602 switch iter.readFieldHash() {
603 case decoder.fieldHash1:
604 decoder.fieldDecoder1.Decode(ptr, iter)
605 case decoder.fieldHash2:
606 decoder.fieldDecoder2.Decode(ptr, iter)
610 if iter.isObjectEnd() {
614 if iter.Error != nil && iter.Error != io.EOF {
615 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
619 type threeFieldsStructDecoder struct {
622 fieldDecoder1 *structFieldDecoder
624 fieldDecoder2 *structFieldDecoder
626 fieldDecoder3 *structFieldDecoder
629 func (decoder *threeFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
630 if !iter.readObjectStart() {
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)
644 if iter.isObjectEnd() {
648 if iter.Error != nil && iter.Error != io.EOF {
649 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
653 type fourFieldsStructDecoder struct {
656 fieldDecoder1 *structFieldDecoder
658 fieldDecoder2 *structFieldDecoder
660 fieldDecoder3 *structFieldDecoder
662 fieldDecoder4 *structFieldDecoder
665 func (decoder *fourFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
666 if !iter.readObjectStart() {
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)
682 if iter.isObjectEnd() {
686 if iter.Error != nil && iter.Error != io.EOF {
687 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
691 type fiveFieldsStructDecoder struct {
694 fieldDecoder1 *structFieldDecoder
696 fieldDecoder2 *structFieldDecoder
698 fieldDecoder3 *structFieldDecoder
700 fieldDecoder4 *structFieldDecoder
702 fieldDecoder5 *structFieldDecoder
705 func (decoder *fiveFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
706 if !iter.readObjectStart() {
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)
724 if iter.isObjectEnd() {
728 if iter.Error != nil && iter.Error != io.EOF {
729 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
733 type sixFieldsStructDecoder struct {
736 fieldDecoder1 *structFieldDecoder
738 fieldDecoder2 *structFieldDecoder
740 fieldDecoder3 *structFieldDecoder
742 fieldDecoder4 *structFieldDecoder
744 fieldDecoder5 *structFieldDecoder
746 fieldDecoder6 *structFieldDecoder
749 func (decoder *sixFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
750 if !iter.readObjectStart() {
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)
770 if iter.isObjectEnd() {
774 if iter.Error != nil && iter.Error != io.EOF {
775 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
779 type sevenFieldsStructDecoder struct {
782 fieldDecoder1 *structFieldDecoder
784 fieldDecoder2 *structFieldDecoder
786 fieldDecoder3 *structFieldDecoder
788 fieldDecoder4 *structFieldDecoder
790 fieldDecoder5 *structFieldDecoder
792 fieldDecoder6 *structFieldDecoder
794 fieldDecoder7 *structFieldDecoder
797 func (decoder *sevenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
798 if !iter.readObjectStart() {
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)
820 if iter.isObjectEnd() {
824 if iter.Error != nil && iter.Error != io.EOF {
825 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
829 type eightFieldsStructDecoder struct {
832 fieldDecoder1 *structFieldDecoder
834 fieldDecoder2 *structFieldDecoder
836 fieldDecoder3 *structFieldDecoder
838 fieldDecoder4 *structFieldDecoder
840 fieldDecoder5 *structFieldDecoder
842 fieldDecoder6 *structFieldDecoder
844 fieldDecoder7 *structFieldDecoder
846 fieldDecoder8 *structFieldDecoder
849 func (decoder *eightFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
850 if !iter.readObjectStart() {
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)
874 if iter.isObjectEnd() {
878 if iter.Error != nil && iter.Error != io.EOF {
879 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
883 type nineFieldsStructDecoder struct {
886 fieldDecoder1 *structFieldDecoder
888 fieldDecoder2 *structFieldDecoder
890 fieldDecoder3 *structFieldDecoder
892 fieldDecoder4 *structFieldDecoder
894 fieldDecoder5 *structFieldDecoder
896 fieldDecoder6 *structFieldDecoder
898 fieldDecoder7 *structFieldDecoder
900 fieldDecoder8 *structFieldDecoder
902 fieldDecoder9 *structFieldDecoder
905 func (decoder *nineFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
906 if !iter.readObjectStart() {
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)
932 if iter.isObjectEnd() {
936 if iter.Error != nil && iter.Error != io.EOF {
937 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
941 type tenFieldsStructDecoder struct {
944 fieldDecoder1 *structFieldDecoder
946 fieldDecoder2 *structFieldDecoder
948 fieldDecoder3 *structFieldDecoder
950 fieldDecoder4 *structFieldDecoder
952 fieldDecoder5 *structFieldDecoder
954 fieldDecoder6 *structFieldDecoder
956 fieldDecoder7 *structFieldDecoder
958 fieldDecoder8 *structFieldDecoder
960 fieldDecoder9 *structFieldDecoder
962 fieldDecoder10 *structFieldDecoder
965 func (decoder *tenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
966 if !iter.readObjectStart() {
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)
994 if iter.isObjectEnd() {
998 if iter.Error != nil && iter.Error != io.EOF {
999 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
1003 type structFieldDecoder struct {
1004 field reflect2.StructField
1005 fieldDecoder ValDecoder
1008 func (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())
1016 type stringModeStringDecoder struct {
1017 elemDecoder ValDecoder
1021 func (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()
1029 type stringModeNumberDecoder struct {
1030 elemDecoder ValDecoder
1033 func (decoder *stringModeNumberDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1034 c := iter.nextToken()
1036 iter.ReportError("stringModeNumberDecoder", `expect ", but found `+string([]byte{c}))
1039 decoder.elemDecoder.Decode(ptr, iter)
1040 if iter.Error != nil {
1045 iter.ReportError("stringModeNumberDecoder", `expect ", but found `+string([]byte{c}))