aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/github.com/json-iterator/go/reflect_struct_decoder.go
diff options
context:
space:
mode:
authorLibravatar Rutger Broekhoff2024-01-02 18:56:31 +0100
committerLibravatar Rutger Broekhoff2024-01-02 18:56:31 +0100
commit8db41da676ac8368ef7c2549d56239a5ff5eedde (patch)
tree09c427fd66de2ec1ebffc8342f5fdbb84b0701b5 /vendor/github.com/json-iterator/go/reflect_struct_decoder.go
parentd4f75fb6db22e57577867445a022227e70958931 (diff)
downloadgitolfs3-8db41da676ac8368ef7c2549d56239a5ff5eedde.tar.gz
gitolfs3-8db41da676ac8368ef7c2549d56239a5ff5eedde.zip
Delete vendor directory
Diffstat (limited to 'vendor/github.com/json-iterator/go/reflect_struct_decoder.go')
-rw-r--r--vendor/github.com/json-iterator/go/reflect_struct_decoder.go1097
1 files changed, 0 insertions, 1097 deletions
diff --git a/vendor/github.com/json-iterator/go/reflect_struct_decoder.go b/vendor/github.com/json-iterator/go/reflect_struct_decoder.go
deleted file mode 100644
index 92ae912..0000000
--- a/vendor/github.com/json-iterator/go/reflect_struct_decoder.go
+++ /dev/null
@@ -1,1097 +0,0 @@
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 if !iter.incrementDepth() {
504 return
505 }
506 var c byte
507 for c = ','; c == ','; c = iter.nextToken() {
508 decoder.decodeOneField(ptr, iter)
509 }
510 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
511 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
512 }
513 if c != '}' {
514 iter.ReportError("struct Decode", `expect }, but found `+string([]byte{c}))
515 }
516 iter.decrementDepth()
517}
518
519func (decoder *generalStructDecoder) decodeOneField(ptr unsafe.Pointer, iter *Iterator) {
520 var field string
521 var fieldDecoder *structFieldDecoder
522 if iter.cfg.objectFieldMustBeSimpleString {
523 fieldBytes := iter.ReadStringAsSlice()
524 field = *(*string)(unsafe.Pointer(&fieldBytes))
525 fieldDecoder = decoder.fields[field]
526 if fieldDecoder == nil && !iter.cfg.caseSensitive {
527 fieldDecoder = decoder.fields[strings.ToLower(field)]
528 }
529 } else {
530 field = iter.ReadString()
531 fieldDecoder = decoder.fields[field]
532 if fieldDecoder == nil && !iter.cfg.caseSensitive {
533 fieldDecoder = decoder.fields[strings.ToLower(field)]
534 }
535 }
536 if fieldDecoder == nil {
537 if decoder.disallowUnknownFields {
538 msg := "found unknown field: " + field
539 iter.ReportError("ReadObject", msg)
540 }
541 c := iter.nextToken()
542 if c != ':' {
543 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
544 }
545 iter.Skip()
546 return
547 }
548 c := iter.nextToken()
549 if c != ':' {
550 iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
551 }
552 fieldDecoder.Decode(ptr, iter)
553}
554
555type skipObjectDecoder struct {
556 typ reflect2.Type
557}
558
559func (decoder *skipObjectDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
560 valueType := iter.WhatIsNext()
561 if valueType != ObjectValue && valueType != NilValue {
562 iter.ReportError("skipObjectDecoder", "expect object or null")
563 return
564 }
565 iter.Skip()
566}
567
568type oneFieldStructDecoder struct {
569 typ reflect2.Type
570 fieldHash int64
571 fieldDecoder *structFieldDecoder
572}
573
574func (decoder *oneFieldStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
575 if !iter.readObjectStart() {
576 return
577 }
578 if !iter.incrementDepth() {
579 return
580 }
581 for {
582 if iter.readFieldHash() == decoder.fieldHash {
583 decoder.fieldDecoder.Decode(ptr, iter)
584 } else {
585 iter.Skip()
586 }
587 if iter.isObjectEnd() {
588 break
589 }
590 }
591 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
592 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
593 }
594 iter.decrementDepth()
595}
596
597type twoFieldsStructDecoder struct {
598 typ reflect2.Type
599 fieldHash1 int64
600 fieldDecoder1 *structFieldDecoder
601 fieldHash2 int64
602 fieldDecoder2 *structFieldDecoder
603}
604
605func (decoder *twoFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
606 if !iter.readObjectStart() {
607 return
608 }
609 if !iter.incrementDepth() {
610 return
611 }
612 for {
613 switch iter.readFieldHash() {
614 case decoder.fieldHash1:
615 decoder.fieldDecoder1.Decode(ptr, iter)
616 case decoder.fieldHash2:
617 decoder.fieldDecoder2.Decode(ptr, iter)
618 default:
619 iter.Skip()
620 }
621 if iter.isObjectEnd() {
622 break
623 }
624 }
625 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
626 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
627 }
628 iter.decrementDepth()
629}
630
631type threeFieldsStructDecoder struct {
632 typ reflect2.Type
633 fieldHash1 int64
634 fieldDecoder1 *structFieldDecoder
635 fieldHash2 int64
636 fieldDecoder2 *structFieldDecoder
637 fieldHash3 int64
638 fieldDecoder3 *structFieldDecoder
639}
640
641func (decoder *threeFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
642 if !iter.readObjectStart() {
643 return
644 }
645 if !iter.incrementDepth() {
646 return
647 }
648 for {
649 switch iter.readFieldHash() {
650 case decoder.fieldHash1:
651 decoder.fieldDecoder1.Decode(ptr, iter)
652 case decoder.fieldHash2:
653 decoder.fieldDecoder2.Decode(ptr, iter)
654 case decoder.fieldHash3:
655 decoder.fieldDecoder3.Decode(ptr, iter)
656 default:
657 iter.Skip()
658 }
659 if iter.isObjectEnd() {
660 break
661 }
662 }
663 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
664 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
665 }
666 iter.decrementDepth()
667}
668
669type fourFieldsStructDecoder struct {
670 typ reflect2.Type
671 fieldHash1 int64
672 fieldDecoder1 *structFieldDecoder
673 fieldHash2 int64
674 fieldDecoder2 *structFieldDecoder
675 fieldHash3 int64
676 fieldDecoder3 *structFieldDecoder
677 fieldHash4 int64
678 fieldDecoder4 *structFieldDecoder
679}
680
681func (decoder *fourFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
682 if !iter.readObjectStart() {
683 return
684 }
685 if !iter.incrementDepth() {
686 return
687 }
688 for {
689 switch iter.readFieldHash() {
690 case decoder.fieldHash1:
691 decoder.fieldDecoder1.Decode(ptr, iter)
692 case decoder.fieldHash2:
693 decoder.fieldDecoder2.Decode(ptr, iter)
694 case decoder.fieldHash3:
695 decoder.fieldDecoder3.Decode(ptr, iter)
696 case decoder.fieldHash4:
697 decoder.fieldDecoder4.Decode(ptr, iter)
698 default:
699 iter.Skip()
700 }
701 if iter.isObjectEnd() {
702 break
703 }
704 }
705 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
706 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
707 }
708 iter.decrementDepth()
709}
710
711type fiveFieldsStructDecoder struct {
712 typ reflect2.Type
713 fieldHash1 int64
714 fieldDecoder1 *structFieldDecoder
715 fieldHash2 int64
716 fieldDecoder2 *structFieldDecoder
717 fieldHash3 int64
718 fieldDecoder3 *structFieldDecoder
719 fieldHash4 int64
720 fieldDecoder4 *structFieldDecoder
721 fieldHash5 int64
722 fieldDecoder5 *structFieldDecoder
723}
724
725func (decoder *fiveFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
726 if !iter.readObjectStart() {
727 return
728 }
729 if !iter.incrementDepth() {
730 return
731 }
732 for {
733 switch iter.readFieldHash() {
734 case decoder.fieldHash1:
735 decoder.fieldDecoder1.Decode(ptr, iter)
736 case decoder.fieldHash2:
737 decoder.fieldDecoder2.Decode(ptr, iter)
738 case decoder.fieldHash3:
739 decoder.fieldDecoder3.Decode(ptr, iter)
740 case decoder.fieldHash4:
741 decoder.fieldDecoder4.Decode(ptr, iter)
742 case decoder.fieldHash5:
743 decoder.fieldDecoder5.Decode(ptr, iter)
744 default:
745 iter.Skip()
746 }
747 if iter.isObjectEnd() {
748 break
749 }
750 }
751 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
752 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
753 }
754 iter.decrementDepth()
755}
756
757type sixFieldsStructDecoder struct {
758 typ reflect2.Type
759 fieldHash1 int64
760 fieldDecoder1 *structFieldDecoder
761 fieldHash2 int64
762 fieldDecoder2 *structFieldDecoder
763 fieldHash3 int64
764 fieldDecoder3 *structFieldDecoder
765 fieldHash4 int64
766 fieldDecoder4 *structFieldDecoder
767 fieldHash5 int64
768 fieldDecoder5 *structFieldDecoder
769 fieldHash6 int64
770 fieldDecoder6 *structFieldDecoder
771}
772
773func (decoder *sixFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
774 if !iter.readObjectStart() {
775 return
776 }
777 if !iter.incrementDepth() {
778 return
779 }
780 for {
781 switch iter.readFieldHash() {
782 case decoder.fieldHash1:
783 decoder.fieldDecoder1.Decode(ptr, iter)
784 case decoder.fieldHash2:
785 decoder.fieldDecoder2.Decode(ptr, iter)
786 case decoder.fieldHash3:
787 decoder.fieldDecoder3.Decode(ptr, iter)
788 case decoder.fieldHash4:
789 decoder.fieldDecoder4.Decode(ptr, iter)
790 case decoder.fieldHash5:
791 decoder.fieldDecoder5.Decode(ptr, iter)
792 case decoder.fieldHash6:
793 decoder.fieldDecoder6.Decode(ptr, iter)
794 default:
795 iter.Skip()
796 }
797 if iter.isObjectEnd() {
798 break
799 }
800 }
801 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
802 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
803 }
804 iter.decrementDepth()
805}
806
807type sevenFieldsStructDecoder struct {
808 typ reflect2.Type
809 fieldHash1 int64
810 fieldDecoder1 *structFieldDecoder
811 fieldHash2 int64
812 fieldDecoder2 *structFieldDecoder
813 fieldHash3 int64
814 fieldDecoder3 *structFieldDecoder
815 fieldHash4 int64
816 fieldDecoder4 *structFieldDecoder
817 fieldHash5 int64
818 fieldDecoder5 *structFieldDecoder
819 fieldHash6 int64
820 fieldDecoder6 *structFieldDecoder
821 fieldHash7 int64
822 fieldDecoder7 *structFieldDecoder
823}
824
825func (decoder *sevenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
826 if !iter.readObjectStart() {
827 return
828 }
829 if !iter.incrementDepth() {
830 return
831 }
832 for {
833 switch iter.readFieldHash() {
834 case decoder.fieldHash1:
835 decoder.fieldDecoder1.Decode(ptr, iter)
836 case decoder.fieldHash2:
837 decoder.fieldDecoder2.Decode(ptr, iter)
838 case decoder.fieldHash3:
839 decoder.fieldDecoder3.Decode(ptr, iter)
840 case decoder.fieldHash4:
841 decoder.fieldDecoder4.Decode(ptr, iter)
842 case decoder.fieldHash5:
843 decoder.fieldDecoder5.Decode(ptr, iter)
844 case decoder.fieldHash6:
845 decoder.fieldDecoder6.Decode(ptr, iter)
846 case decoder.fieldHash7:
847 decoder.fieldDecoder7.Decode(ptr, iter)
848 default:
849 iter.Skip()
850 }
851 if iter.isObjectEnd() {
852 break
853 }
854 }
855 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
856 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
857 }
858 iter.decrementDepth()
859}
860
861type eightFieldsStructDecoder struct {
862 typ reflect2.Type
863 fieldHash1 int64
864 fieldDecoder1 *structFieldDecoder
865 fieldHash2 int64
866 fieldDecoder2 *structFieldDecoder
867 fieldHash3 int64
868 fieldDecoder3 *structFieldDecoder
869 fieldHash4 int64
870 fieldDecoder4 *structFieldDecoder
871 fieldHash5 int64
872 fieldDecoder5 *structFieldDecoder
873 fieldHash6 int64
874 fieldDecoder6 *structFieldDecoder
875 fieldHash7 int64
876 fieldDecoder7 *structFieldDecoder
877 fieldHash8 int64
878 fieldDecoder8 *structFieldDecoder
879}
880
881func (decoder *eightFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
882 if !iter.readObjectStart() {
883 return
884 }
885 if !iter.incrementDepth() {
886 return
887 }
888 for {
889 switch iter.readFieldHash() {
890 case decoder.fieldHash1:
891 decoder.fieldDecoder1.Decode(ptr, iter)
892 case decoder.fieldHash2:
893 decoder.fieldDecoder2.Decode(ptr, iter)
894 case decoder.fieldHash3:
895 decoder.fieldDecoder3.Decode(ptr, iter)
896 case decoder.fieldHash4:
897 decoder.fieldDecoder4.Decode(ptr, iter)
898 case decoder.fieldHash5:
899 decoder.fieldDecoder5.Decode(ptr, iter)
900 case decoder.fieldHash6:
901 decoder.fieldDecoder6.Decode(ptr, iter)
902 case decoder.fieldHash7:
903 decoder.fieldDecoder7.Decode(ptr, iter)
904 case decoder.fieldHash8:
905 decoder.fieldDecoder8.Decode(ptr, iter)
906 default:
907 iter.Skip()
908 }
909 if iter.isObjectEnd() {
910 break
911 }
912 }
913 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
914 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
915 }
916 iter.decrementDepth()
917}
918
919type nineFieldsStructDecoder struct {
920 typ reflect2.Type
921 fieldHash1 int64
922 fieldDecoder1 *structFieldDecoder
923 fieldHash2 int64
924 fieldDecoder2 *structFieldDecoder
925 fieldHash3 int64
926 fieldDecoder3 *structFieldDecoder
927 fieldHash4 int64
928 fieldDecoder4 *structFieldDecoder
929 fieldHash5 int64
930 fieldDecoder5 *structFieldDecoder
931 fieldHash6 int64
932 fieldDecoder6 *structFieldDecoder
933 fieldHash7 int64
934 fieldDecoder7 *structFieldDecoder
935 fieldHash8 int64
936 fieldDecoder8 *structFieldDecoder
937 fieldHash9 int64
938 fieldDecoder9 *structFieldDecoder
939}
940
941func (decoder *nineFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
942 if !iter.readObjectStart() {
943 return
944 }
945 if !iter.incrementDepth() {
946 return
947 }
948 for {
949 switch iter.readFieldHash() {
950 case decoder.fieldHash1:
951 decoder.fieldDecoder1.Decode(ptr, iter)
952 case decoder.fieldHash2:
953 decoder.fieldDecoder2.Decode(ptr, iter)
954 case decoder.fieldHash3:
955 decoder.fieldDecoder3.Decode(ptr, iter)
956 case decoder.fieldHash4:
957 decoder.fieldDecoder4.Decode(ptr, iter)
958 case decoder.fieldHash5:
959 decoder.fieldDecoder5.Decode(ptr, iter)
960 case decoder.fieldHash6:
961 decoder.fieldDecoder6.Decode(ptr, iter)
962 case decoder.fieldHash7:
963 decoder.fieldDecoder7.Decode(ptr, iter)
964 case decoder.fieldHash8:
965 decoder.fieldDecoder8.Decode(ptr, iter)
966 case decoder.fieldHash9:
967 decoder.fieldDecoder9.Decode(ptr, iter)
968 default:
969 iter.Skip()
970 }
971 if iter.isObjectEnd() {
972 break
973 }
974 }
975 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
976 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
977 }
978 iter.decrementDepth()
979}
980
981type tenFieldsStructDecoder struct {
982 typ reflect2.Type
983 fieldHash1 int64
984 fieldDecoder1 *structFieldDecoder
985 fieldHash2 int64
986 fieldDecoder2 *structFieldDecoder
987 fieldHash3 int64
988 fieldDecoder3 *structFieldDecoder
989 fieldHash4 int64
990 fieldDecoder4 *structFieldDecoder
991 fieldHash5 int64
992 fieldDecoder5 *structFieldDecoder
993 fieldHash6 int64
994 fieldDecoder6 *structFieldDecoder
995 fieldHash7 int64
996 fieldDecoder7 *structFieldDecoder
997 fieldHash8 int64
998 fieldDecoder8 *structFieldDecoder
999 fieldHash9 int64
1000 fieldDecoder9 *structFieldDecoder
1001 fieldHash10 int64
1002 fieldDecoder10 *structFieldDecoder
1003}
1004
1005func (decoder *tenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1006 if !iter.readObjectStart() {
1007 return
1008 }
1009 if !iter.incrementDepth() {
1010 return
1011 }
1012 for {
1013 switch iter.readFieldHash() {
1014 case decoder.fieldHash1:
1015 decoder.fieldDecoder1.Decode(ptr, iter)
1016 case decoder.fieldHash2:
1017 decoder.fieldDecoder2.Decode(ptr, iter)
1018 case decoder.fieldHash3:
1019 decoder.fieldDecoder3.Decode(ptr, iter)
1020 case decoder.fieldHash4:
1021 decoder.fieldDecoder4.Decode(ptr, iter)
1022 case decoder.fieldHash5:
1023 decoder.fieldDecoder5.Decode(ptr, iter)
1024 case decoder.fieldHash6:
1025 decoder.fieldDecoder6.Decode(ptr, iter)
1026 case decoder.fieldHash7:
1027 decoder.fieldDecoder7.Decode(ptr, iter)
1028 case decoder.fieldHash8:
1029 decoder.fieldDecoder8.Decode(ptr, iter)
1030 case decoder.fieldHash9:
1031 decoder.fieldDecoder9.Decode(ptr, iter)
1032 case decoder.fieldHash10:
1033 decoder.fieldDecoder10.Decode(ptr, iter)
1034 default:
1035 iter.Skip()
1036 }
1037 if iter.isObjectEnd() {
1038 break
1039 }
1040 }
1041 if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
1042 iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
1043 }
1044 iter.decrementDepth()
1045}
1046
1047type structFieldDecoder struct {
1048 field reflect2.StructField
1049 fieldDecoder ValDecoder
1050}
1051
1052func (decoder *structFieldDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1053 fieldPtr := decoder.field.UnsafeGet(ptr)
1054 decoder.fieldDecoder.Decode(fieldPtr, iter)
1055 if iter.Error != nil && iter.Error != io.EOF {
1056 iter.Error = fmt.Errorf("%s: %s", decoder.field.Name(), iter.Error.Error())
1057 }
1058}
1059
1060type stringModeStringDecoder struct {
1061 elemDecoder ValDecoder
1062 cfg *frozenConfig
1063}
1064
1065func (decoder *stringModeStringDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1066 decoder.elemDecoder.Decode(ptr, iter)
1067 str := *((*string)(ptr))
1068 tempIter := decoder.cfg.BorrowIterator([]byte(str))
1069 defer decoder.cfg.ReturnIterator(tempIter)
1070 *((*string)(ptr)) = tempIter.ReadString()
1071}
1072
1073type stringModeNumberDecoder struct {
1074 elemDecoder ValDecoder
1075}
1076
1077func (decoder *stringModeNumberDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
1078 if iter.WhatIsNext() == NilValue {
1079 decoder.elemDecoder.Decode(ptr, iter)
1080 return
1081 }
1082
1083 c := iter.nextToken()
1084 if c != '"' {
1085 iter.ReportError("stringModeNumberDecoder", `expect ", but found `+string([]byte{c}))
1086 return
1087 }
1088 decoder.elemDecoder.Decode(ptr, iter)
1089 if iter.Error != nil {
1090 return
1091 }
1092 c = iter.readByte()
1093 if c != '"' {
1094 iter.ReportError("stringModeNumberDecoder", `expect ", but found `+string([]byte{c}))
1095 return
1096 }
1097}
generated by cgit v1.2.3 (git 2.45.2) at 2024-11-18 23:02:30 +0000