1package jsoniter 2 3import ( 4 "fmt" 5 "io" 6 "reflect" 7 "strings" 8 "unsafe" 9) 10 11func createStructDecoder(typ reflect.Type, fields map[string]*structFieldDecoder) (ValDecoder, error) { 12 knownHash := map[int32]struct{}{ 13 0: {}, 14 } 15 switch len(fields) { 16 case 0: 17 return &skipObjectDecoder{typ}, nil 18 case 1: 19 for fieldName, fieldDecoder := range fields { 20 fieldHash := calcHash(fieldName) 21 _, known := knownHash[fieldHash] 22 if known { 23 return &generalStructDecoder{typ, fields}, nil 24 } 25 knownHash[fieldHash] = struct{}{} 26 return &oneFieldStructDecoder{typ, fieldHash, fieldDecoder}, nil 27 } 28 case 2: 29 var fieldHash1 int32 30 var fieldHash2 int32 31 var fieldDecoder1 *structFieldDecoder 32 var fieldDecoder2 *structFieldDecoder 33 for fieldName, fieldDecoder := range fields { 34 fieldHash := calcHash(fieldName) 35 _, known := knownHash[fieldHash] 36 if known { 37 return &generalStructDecoder{typ, fields}, nil 38 } 39 knownHash[fieldHash] = struct{}{} 40 if fieldHash1 == 0 { 41 fieldHash1 = fieldHash 42 fieldDecoder1 = fieldDecoder 43 } else { 44 fieldHash2 = fieldHash 45 fieldDecoder2 = fieldDecoder 46 } 47 } 48 return &twoFieldsStructDecoder{typ, fieldHash1, fieldDecoder1, fieldHash2, fieldDecoder2}, nil 49 case 3: 50 var fieldName1 int32 51 var fieldName2 int32 52 var fieldName3 int32 53 var fieldDecoder1 *structFieldDecoder 54 var fieldDecoder2 *structFieldDecoder 55 var fieldDecoder3 *structFieldDecoder 56 for fieldName, fieldDecoder := range fields { 57 fieldHash := calcHash(fieldName) 58 _, known := knownHash[fieldHash] 59 if known { 60 return &generalStructDecoder{typ, fields}, nil 61 } 62 knownHash[fieldHash] = struct{}{} 63 if fieldName1 == 0 { 64 fieldName1 = fieldHash 65 fieldDecoder1 = fieldDecoder 66 } else if fieldName2 == 0 { 67 fieldName2 = fieldHash 68 fieldDecoder2 = fieldDecoder 69 } else { 70 fieldName3 = fieldHash 71 fieldDecoder3 = fieldDecoder 72 } 73 } 74 return &threeFieldsStructDecoder{typ, 75 fieldName1, fieldDecoder1, fieldName2, fieldDecoder2, fieldName3, fieldDecoder3}, nil 76 case 4: 77 var fieldName1 int32 78 var fieldName2 int32 79 var fieldName3 int32 80 var fieldName4 int32 81 var fieldDecoder1 *structFieldDecoder 82 var fieldDecoder2 *structFieldDecoder 83 var fieldDecoder3 *structFieldDecoder 84 var fieldDecoder4 *structFieldDecoder 85 for fieldName, fieldDecoder := range fields { 86 fieldHash := calcHash(fieldName) 87 _, known := knownHash[fieldHash] 88 if known { 89 return &generalStructDecoder{typ, fields}, nil 90 } 91 knownHash[fieldHash] = struct{}{} 92 if fieldName1 == 0 { 93 fieldName1 = fieldHash 94 fieldDecoder1 = fieldDecoder 95 } else if fieldName2 == 0 { 96 fieldName2 = fieldHash 97 fieldDecoder2 = fieldDecoder 98 } else if fieldName3 == 0 { 99 fieldName3 = fieldHash 100 fieldDecoder3 = fieldDecoder 101 } else { 102 fieldName4 = fieldHash 103 fieldDecoder4 = fieldDecoder 104 } 105 } 106 return &fourFieldsStructDecoder{typ, 107 fieldName1, fieldDecoder1, fieldName2, fieldDecoder2, fieldName3, fieldDecoder3, 108 fieldName4, fieldDecoder4}, nil 109 case 5: 110 var fieldName1 int32 111 var fieldName2 int32 112 var fieldName3 int32 113 var fieldName4 int32 114 var fieldName5 int32 115 var fieldDecoder1 *structFieldDecoder 116 var fieldDecoder2 *structFieldDecoder 117 var fieldDecoder3 *structFieldDecoder 118 var fieldDecoder4 *structFieldDecoder 119 var fieldDecoder5 *structFieldDecoder 120 for fieldName, fieldDecoder := range fields { 121 fieldHash := calcHash(fieldName) 122 _, known := knownHash[fieldHash] 123 if known { 124 return &generalStructDecoder{typ, fields}, nil 125 } 126 knownHash[fieldHash] = struct{}{} 127 if fieldName1 == 0 { 128 fieldName1 = fieldHash 129 fieldDecoder1 = fieldDecoder 130 } else if fieldName2 == 0 { 131 fieldName2 = fieldHash 132 fieldDecoder2 = fieldDecoder 133 } else if fieldName3 == 0 { 134 fieldName3 = fieldHash 135 fieldDecoder3 = fieldDecoder 136 } else if fieldName4 == 0 { 137 fieldName4 = fieldHash 138 fieldDecoder4 = fieldDecoder 139 } else { 140 fieldName5 = fieldHash 141 fieldDecoder5 = fieldDecoder 142 } 143 } 144 return &fiveFieldsStructDecoder{typ, 145 fieldName1, fieldDecoder1, fieldName2, fieldDecoder2, fieldName3, fieldDecoder3, 146 fieldName4, fieldDecoder4, fieldName5, fieldDecoder5}, nil 147 case 6: 148 var fieldName1 int32 149 var fieldName2 int32 150 var fieldName3 int32 151 var fieldName4 int32 152 var fieldName5 int32 153 var fieldName6 int32 154 var fieldDecoder1 *structFieldDecoder 155 var fieldDecoder2 *structFieldDecoder 156 var fieldDecoder3 *structFieldDecoder 157 var fieldDecoder4 *structFieldDecoder 158 var fieldDecoder5 *structFieldDecoder 159 var fieldDecoder6 *structFieldDecoder 160 for fieldName, fieldDecoder := range fields { 161 fieldHash := calcHash(fieldName) 162 _, known := knownHash[fieldHash] 163 if known { 164 return &generalStructDecoder{typ, fields}, nil 165 } 166 knownHash[fieldHash] = struct{}{} 167 if fieldName1 == 0 { 168 fieldName1 = fieldHash 169 fieldDecoder1 = fieldDecoder 170 } else if fieldName2 == 0 { 171 fieldName2 = fieldHash 172 fieldDecoder2 = fieldDecoder 173 } else if fieldName3 == 0 { 174 fieldName3 = fieldHash 175 fieldDecoder3 = fieldDecoder 176 } else if fieldName4 == 0 { 177 fieldName4 = fieldHash 178 fieldDecoder4 = fieldDecoder 179 } else if fieldName5 == 0 { 180 fieldName5 = fieldHash 181 fieldDecoder5 = fieldDecoder 182 } else { 183 fieldName6 = fieldHash 184 fieldDecoder6 = fieldDecoder 185 } 186 } 187 return &sixFieldsStructDecoder{typ, 188 fieldName1, fieldDecoder1, fieldName2, fieldDecoder2, fieldName3, fieldDecoder3, 189 fieldName4, fieldDecoder4, fieldName5, fieldDecoder5, fieldName6, fieldDecoder6}, nil 190 case 7: 191 var fieldName1 int32 192 var fieldName2 int32 193 var fieldName3 int32 194 var fieldName4 int32 195 var fieldName5 int32 196 var fieldName6 int32 197 var fieldName7 int32 198 var fieldDecoder1 *structFieldDecoder 199 var fieldDecoder2 *structFieldDecoder 200 var fieldDecoder3 *structFieldDecoder 201 var fieldDecoder4 *structFieldDecoder 202 var fieldDecoder5 *structFieldDecoder 203 var fieldDecoder6 *structFieldDecoder 204 var fieldDecoder7 *structFieldDecoder 205 for fieldName, fieldDecoder := range fields { 206 fieldHash := calcHash(fieldName) 207 _, known := knownHash[fieldHash] 208 if known { 209 return &generalStructDecoder{typ, fields}, nil 210 } 211 knownHash[fieldHash] = struct{}{} 212 if fieldName1 == 0 { 213 fieldName1 = fieldHash 214 fieldDecoder1 = fieldDecoder 215 } else if fieldName2 == 0 { 216 fieldName2 = fieldHash 217 fieldDecoder2 = fieldDecoder 218 } else if fieldName3 == 0 { 219 fieldName3 = fieldHash 220 fieldDecoder3 = fieldDecoder 221 } else if fieldName4 == 0 { 222 fieldName4 = fieldHash 223 fieldDecoder4 = fieldDecoder 224 } else if fieldName5 == 0 { 225 fieldName5 = fieldHash 226 fieldDecoder5 = fieldDecoder 227 } else if fieldName6 == 0 { 228 fieldName6 = fieldHash 229 fieldDecoder6 = fieldDecoder 230 } else { 231 fieldName7 = fieldHash 232 fieldDecoder7 = fieldDecoder 233 } 234 } 235 return &sevenFieldsStructDecoder{typ, 236 fieldName1, fieldDecoder1, fieldName2, fieldDecoder2, fieldName3, fieldDecoder3, 237 fieldName4, fieldDecoder4, fieldName5, fieldDecoder5, fieldName6, fieldDecoder6, 238 fieldName7, fieldDecoder7}, nil 239 case 8: 240 var fieldName1 int32 241 var fieldName2 int32 242 var fieldName3 int32 243 var fieldName4 int32 244 var fieldName5 int32 245 var fieldName6 int32 246 var fieldName7 int32 247 var fieldName8 int32 248 var fieldDecoder1 *structFieldDecoder 249 var fieldDecoder2 *structFieldDecoder 250 var fieldDecoder3 *structFieldDecoder 251 var fieldDecoder4 *structFieldDecoder 252 var fieldDecoder5 *structFieldDecoder 253 var fieldDecoder6 *structFieldDecoder 254 var fieldDecoder7 *structFieldDecoder 255 var fieldDecoder8 *structFieldDecoder 256 for fieldName, fieldDecoder := range fields { 257 fieldHash := calcHash(fieldName) 258 _, known := knownHash[fieldHash] 259 if known { 260 return &generalStructDecoder{typ, fields}, nil 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 if fieldName7 == 0 { 282 fieldName7 = fieldHash 283 fieldDecoder7 = fieldDecoder 284 } else { 285 fieldName8 = fieldHash 286 fieldDecoder8 = fieldDecoder 287 } 288 } 289 return &eightFieldsStructDecoder{typ, 290 fieldName1, fieldDecoder1, fieldName2, fieldDecoder2, fieldName3, fieldDecoder3, 291 fieldName4, fieldDecoder4, fieldName5, fieldDecoder5, fieldName6, fieldDecoder6, 292 fieldName7, fieldDecoder7, fieldName8, fieldDecoder8}, nil 293 case 9: 294 var fieldName1 int32 295 var fieldName2 int32 296 var fieldName3 int32 297 var fieldName4 int32 298 var fieldName5 int32 299 var fieldName6 int32 300 var fieldName7 int32 301 var fieldName8 int32 302 var fieldName9 int32 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 var fieldDecoder9 *structFieldDecoder 312 for fieldName, fieldDecoder := range fields { 313 fieldHash := calcHash(fieldName) 314 _, known := knownHash[fieldHash] 315 if known { 316 return &generalStructDecoder{typ, fields}, nil 317 } 318 knownHash[fieldHash] = struct{}{} 319 if fieldName1 == 0 { 320 fieldName1 = fieldHash 321 fieldDecoder1 = fieldDecoder 322 } else if fieldName2 == 0 { 323 fieldName2 = fieldHash 324 fieldDecoder2 = fieldDecoder 325 } else if fieldName3 == 0 { 326 fieldName3 = fieldHash 327 fieldDecoder3 = fieldDecoder 328 } else if fieldName4 == 0 { 329 fieldName4 = fieldHash 330 fieldDecoder4 = fieldDecoder 331 } else if fieldName5 == 0 { 332 fieldName5 = fieldHash 333 fieldDecoder5 = fieldDecoder 334 } else if fieldName6 == 0 { 335 fieldName6 = fieldHash 336 fieldDecoder6 = fieldDecoder 337 } else if fieldName7 == 0 { 338 fieldName7 = fieldHash 339 fieldDecoder7 = fieldDecoder 340 } else if fieldName8 == 0 { 341 fieldName8 = fieldHash 342 fieldDecoder8 = fieldDecoder 343 } else { 344 fieldName9 = fieldHash 345 fieldDecoder9 = fieldDecoder 346 } 347 } 348 return &nineFieldsStructDecoder{typ, 349 fieldName1, fieldDecoder1, fieldName2, fieldDecoder2, fieldName3, fieldDecoder3, 350 fieldName4, fieldDecoder4, fieldName5, fieldDecoder5, fieldName6, fieldDecoder6, 351 fieldName7, fieldDecoder7, fieldName8, fieldDecoder8, fieldName9, fieldDecoder9}, nil 352 case 10: 353 var fieldName1 int32 354 var fieldName2 int32 355 var fieldName3 int32 356 var fieldName4 int32 357 var fieldName5 int32 358 var fieldName6 int32 359 var fieldName7 int32 360 var fieldName8 int32 361 var fieldName9 int32 362 var fieldName10 int32 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 var fieldDecoder10 *structFieldDecoder 373 for fieldName, fieldDecoder := range fields { 374 fieldHash := calcHash(fieldName) 375 _, known := knownHash[fieldHash] 376 if known { 377 return &generalStructDecoder{typ, fields}, nil 378 } 379 knownHash[fieldHash] = struct{}{} 380 if fieldName1 == 0 { 381 fieldName1 = fieldHash 382 fieldDecoder1 = fieldDecoder 383 } else if fieldName2 == 0 { 384 fieldName2 = fieldHash 385 fieldDecoder2 = fieldDecoder 386 } else if fieldName3 == 0 { 387 fieldName3 = fieldHash 388 fieldDecoder3 = fieldDecoder 389 } else if fieldName4 == 0 { 390 fieldName4 = fieldHash 391 fieldDecoder4 = fieldDecoder 392 } else if fieldName5 == 0 { 393 fieldName5 = fieldHash 394 fieldDecoder5 = fieldDecoder 395 } else if fieldName6 == 0 { 396 fieldName6 = fieldHash 397 fieldDecoder6 = fieldDecoder 398 } else if fieldName7 == 0 { 399 fieldName7 = fieldHash 400 fieldDecoder7 = fieldDecoder 401 } else if fieldName8 == 0 { 402 fieldName8 = fieldHash 403 fieldDecoder8 = fieldDecoder 404 } else if fieldName9 == 0 { 405 fieldName9 = fieldHash 406 fieldDecoder9 = fieldDecoder 407 } else { 408 fieldName10 = fieldHash 409 fieldDecoder10 = fieldDecoder 410 } 411 } 412 return &tenFieldsStructDecoder{typ, 413 fieldName1, fieldDecoder1, fieldName2, fieldDecoder2, fieldName3, fieldDecoder3, 414 fieldName4, fieldDecoder4, fieldName5, fieldDecoder5, fieldName6, fieldDecoder6, 415 fieldName7, fieldDecoder7, fieldName8, fieldDecoder8, fieldName9, fieldDecoder9, 416 fieldName10, fieldDecoder10}, nil 417 } 418 return &generalStructDecoder{typ, fields}, nil 419} 420 421type generalStructDecoder struct { 422 typ reflect.Type 423 fields map[string]*structFieldDecoder 424} 425 426func (decoder *generalStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 427 if !iter.readObjectStart() { 428 return 429 } 430 fieldBytes := iter.readObjectFieldAsBytes() 431 field := *(*string)(unsafe.Pointer(&fieldBytes)) 432 fieldDecoder := decoder.fields[strings.ToLower(field)] 433 if fieldDecoder == nil { 434 iter.Skip() 435 } else { 436 fieldDecoder.Decode(ptr, iter) 437 } 438 for iter.nextToken() == ',' { 439 fieldBytes = iter.readObjectFieldAsBytes() 440 field = *(*string)(unsafe.Pointer(&fieldBytes)) 441 fieldDecoder = decoder.fields[strings.ToLower(field)] 442 if fieldDecoder == nil { 443 iter.Skip() 444 } else { 445 fieldDecoder.Decode(ptr, iter) 446 } 447 } 448 if iter.Error != nil && iter.Error != io.EOF { 449 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 450 } 451} 452 453type skipObjectDecoder struct { 454 typ reflect.Type 455} 456 457func (decoder *skipObjectDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 458 valueType := iter.WhatIsNext() 459 if valueType != ObjectValue && valueType != NilValue { 460 iter.ReportError("skipObjectDecoder", "expect object or null") 461 return 462 } 463 iter.Skip() 464} 465 466type oneFieldStructDecoder struct { 467 typ reflect.Type 468 fieldHash int32 469 fieldDecoder *structFieldDecoder 470} 471 472func (decoder *oneFieldStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 473 if !iter.readObjectStart() { 474 return 475 } 476 for { 477 if iter.readFieldHash() == decoder.fieldHash { 478 decoder.fieldDecoder.Decode(ptr, iter) 479 } else { 480 iter.Skip() 481 } 482 if iter.isObjectEnd() { 483 break 484 } 485 } 486 if iter.Error != nil && iter.Error != io.EOF { 487 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 488 } 489} 490 491type twoFieldsStructDecoder struct { 492 typ reflect.Type 493 fieldHash1 int32 494 fieldDecoder1 *structFieldDecoder 495 fieldHash2 int32 496 fieldDecoder2 *structFieldDecoder 497} 498 499func (decoder *twoFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 500 if !iter.readObjectStart() { 501 return 502 } 503 for { 504 switch iter.readFieldHash() { 505 case decoder.fieldHash1: 506 decoder.fieldDecoder1.Decode(ptr, iter) 507 case decoder.fieldHash2: 508 decoder.fieldDecoder2.Decode(ptr, iter) 509 default: 510 iter.Skip() 511 } 512 if iter.isObjectEnd() { 513 break 514 } 515 } 516 if iter.Error != nil && iter.Error != io.EOF { 517 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 518 } 519} 520 521type threeFieldsStructDecoder struct { 522 typ reflect.Type 523 fieldHash1 int32 524 fieldDecoder1 *structFieldDecoder 525 fieldHash2 int32 526 fieldDecoder2 *structFieldDecoder 527 fieldHash3 int32 528 fieldDecoder3 *structFieldDecoder 529} 530 531func (decoder *threeFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 532 if !iter.readObjectStart() { 533 return 534 } 535 for { 536 switch iter.readFieldHash() { 537 case decoder.fieldHash1: 538 decoder.fieldDecoder1.Decode(ptr, iter) 539 case decoder.fieldHash2: 540 decoder.fieldDecoder2.Decode(ptr, iter) 541 case decoder.fieldHash3: 542 decoder.fieldDecoder3.Decode(ptr, iter) 543 default: 544 iter.Skip() 545 } 546 if iter.isObjectEnd() { 547 break 548 } 549 } 550 if iter.Error != nil && iter.Error != io.EOF { 551 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 552 } 553} 554 555type fourFieldsStructDecoder struct { 556 typ reflect.Type 557 fieldHash1 int32 558 fieldDecoder1 *structFieldDecoder 559 fieldHash2 int32 560 fieldDecoder2 *structFieldDecoder 561 fieldHash3 int32 562 fieldDecoder3 *structFieldDecoder 563 fieldHash4 int32 564 fieldDecoder4 *structFieldDecoder 565} 566 567func (decoder *fourFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 568 if !iter.readObjectStart() { 569 return 570 } 571 for { 572 switch iter.readFieldHash() { 573 case decoder.fieldHash1: 574 decoder.fieldDecoder1.Decode(ptr, iter) 575 case decoder.fieldHash2: 576 decoder.fieldDecoder2.Decode(ptr, iter) 577 case decoder.fieldHash3: 578 decoder.fieldDecoder3.Decode(ptr, iter) 579 case decoder.fieldHash4: 580 decoder.fieldDecoder4.Decode(ptr, iter) 581 default: 582 iter.Skip() 583 } 584 if iter.isObjectEnd() { 585 break 586 } 587 } 588 if iter.Error != nil && iter.Error != io.EOF { 589 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 590 } 591} 592 593type fiveFieldsStructDecoder struct { 594 typ reflect.Type 595 fieldHash1 int32 596 fieldDecoder1 *structFieldDecoder 597 fieldHash2 int32 598 fieldDecoder2 *structFieldDecoder 599 fieldHash3 int32 600 fieldDecoder3 *structFieldDecoder 601 fieldHash4 int32 602 fieldDecoder4 *structFieldDecoder 603 fieldHash5 int32 604 fieldDecoder5 *structFieldDecoder 605} 606 607func (decoder *fiveFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 608 if !iter.readObjectStart() { 609 return 610 } 611 for { 612 switch iter.readFieldHash() { 613 case decoder.fieldHash1: 614 decoder.fieldDecoder1.Decode(ptr, iter) 615 case decoder.fieldHash2: 616 decoder.fieldDecoder2.Decode(ptr, iter) 617 case decoder.fieldHash3: 618 decoder.fieldDecoder3.Decode(ptr, iter) 619 case decoder.fieldHash4: 620 decoder.fieldDecoder4.Decode(ptr, iter) 621 case decoder.fieldHash5: 622 decoder.fieldDecoder5.Decode(ptr, iter) 623 default: 624 iter.Skip() 625 } 626 if iter.isObjectEnd() { 627 break 628 } 629 } 630 if iter.Error != nil && iter.Error != io.EOF { 631 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 632 } 633} 634 635type sixFieldsStructDecoder struct { 636 typ reflect.Type 637 fieldHash1 int32 638 fieldDecoder1 *structFieldDecoder 639 fieldHash2 int32 640 fieldDecoder2 *structFieldDecoder 641 fieldHash3 int32 642 fieldDecoder3 *structFieldDecoder 643 fieldHash4 int32 644 fieldDecoder4 *structFieldDecoder 645 fieldHash5 int32 646 fieldDecoder5 *structFieldDecoder 647 fieldHash6 int32 648 fieldDecoder6 *structFieldDecoder 649} 650 651func (decoder *sixFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 652 if !iter.readObjectStart() { 653 return 654 } 655 for { 656 switch iter.readFieldHash() { 657 case decoder.fieldHash1: 658 decoder.fieldDecoder1.Decode(ptr, iter) 659 case decoder.fieldHash2: 660 decoder.fieldDecoder2.Decode(ptr, iter) 661 case decoder.fieldHash3: 662 decoder.fieldDecoder3.Decode(ptr, iter) 663 case decoder.fieldHash4: 664 decoder.fieldDecoder4.Decode(ptr, iter) 665 case decoder.fieldHash5: 666 decoder.fieldDecoder5.Decode(ptr, iter) 667 case decoder.fieldHash6: 668 decoder.fieldDecoder6.Decode(ptr, iter) 669 default: 670 iter.Skip() 671 } 672 if iter.isObjectEnd() { 673 break 674 } 675 } 676 if iter.Error != nil && iter.Error != io.EOF { 677 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 678 } 679} 680 681type sevenFieldsStructDecoder struct { 682 typ reflect.Type 683 fieldHash1 int32 684 fieldDecoder1 *structFieldDecoder 685 fieldHash2 int32 686 fieldDecoder2 *structFieldDecoder 687 fieldHash3 int32 688 fieldDecoder3 *structFieldDecoder 689 fieldHash4 int32 690 fieldDecoder4 *structFieldDecoder 691 fieldHash5 int32 692 fieldDecoder5 *structFieldDecoder 693 fieldHash6 int32 694 fieldDecoder6 *structFieldDecoder 695 fieldHash7 int32 696 fieldDecoder7 *structFieldDecoder 697} 698 699func (decoder *sevenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 700 if !iter.readObjectStart() { 701 return 702 } 703 for { 704 switch iter.readFieldHash() { 705 case decoder.fieldHash1: 706 decoder.fieldDecoder1.Decode(ptr, iter) 707 case decoder.fieldHash2: 708 decoder.fieldDecoder2.Decode(ptr, iter) 709 case decoder.fieldHash3: 710 decoder.fieldDecoder3.Decode(ptr, iter) 711 case decoder.fieldHash4: 712 decoder.fieldDecoder4.Decode(ptr, iter) 713 case decoder.fieldHash5: 714 decoder.fieldDecoder5.Decode(ptr, iter) 715 case decoder.fieldHash6: 716 decoder.fieldDecoder6.Decode(ptr, iter) 717 case decoder.fieldHash7: 718 decoder.fieldDecoder7.Decode(ptr, iter) 719 default: 720 iter.Skip() 721 } 722 if iter.isObjectEnd() { 723 break 724 } 725 } 726 if iter.Error != nil && iter.Error != io.EOF { 727 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 728 } 729} 730 731type eightFieldsStructDecoder struct { 732 typ reflect.Type 733 fieldHash1 int32 734 fieldDecoder1 *structFieldDecoder 735 fieldHash2 int32 736 fieldDecoder2 *structFieldDecoder 737 fieldHash3 int32 738 fieldDecoder3 *structFieldDecoder 739 fieldHash4 int32 740 fieldDecoder4 *structFieldDecoder 741 fieldHash5 int32 742 fieldDecoder5 *structFieldDecoder 743 fieldHash6 int32 744 fieldDecoder6 *structFieldDecoder 745 fieldHash7 int32 746 fieldDecoder7 *structFieldDecoder 747 fieldHash8 int32 748 fieldDecoder8 *structFieldDecoder 749} 750 751func (decoder *eightFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 752 if !iter.readObjectStart() { 753 return 754 } 755 for { 756 switch iter.readFieldHash() { 757 case decoder.fieldHash1: 758 decoder.fieldDecoder1.Decode(ptr, iter) 759 case decoder.fieldHash2: 760 decoder.fieldDecoder2.Decode(ptr, iter) 761 case decoder.fieldHash3: 762 decoder.fieldDecoder3.Decode(ptr, iter) 763 case decoder.fieldHash4: 764 decoder.fieldDecoder4.Decode(ptr, iter) 765 case decoder.fieldHash5: 766 decoder.fieldDecoder5.Decode(ptr, iter) 767 case decoder.fieldHash6: 768 decoder.fieldDecoder6.Decode(ptr, iter) 769 case decoder.fieldHash7: 770 decoder.fieldDecoder7.Decode(ptr, iter) 771 case decoder.fieldHash8: 772 decoder.fieldDecoder8.Decode(ptr, iter) 773 default: 774 iter.Skip() 775 } 776 if iter.isObjectEnd() { 777 break 778 } 779 } 780 if iter.Error != nil && iter.Error != io.EOF { 781 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 782 } 783} 784 785type nineFieldsStructDecoder struct { 786 typ reflect.Type 787 fieldHash1 int32 788 fieldDecoder1 *structFieldDecoder 789 fieldHash2 int32 790 fieldDecoder2 *structFieldDecoder 791 fieldHash3 int32 792 fieldDecoder3 *structFieldDecoder 793 fieldHash4 int32 794 fieldDecoder4 *structFieldDecoder 795 fieldHash5 int32 796 fieldDecoder5 *structFieldDecoder 797 fieldHash6 int32 798 fieldDecoder6 *structFieldDecoder 799 fieldHash7 int32 800 fieldDecoder7 *structFieldDecoder 801 fieldHash8 int32 802 fieldDecoder8 *structFieldDecoder 803 fieldHash9 int32 804 fieldDecoder9 *structFieldDecoder 805} 806 807func (decoder *nineFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 808 if !iter.readObjectStart() { 809 return 810 } 811 for { 812 switch iter.readFieldHash() { 813 case decoder.fieldHash1: 814 decoder.fieldDecoder1.Decode(ptr, iter) 815 case decoder.fieldHash2: 816 decoder.fieldDecoder2.Decode(ptr, iter) 817 case decoder.fieldHash3: 818 decoder.fieldDecoder3.Decode(ptr, iter) 819 case decoder.fieldHash4: 820 decoder.fieldDecoder4.Decode(ptr, iter) 821 case decoder.fieldHash5: 822 decoder.fieldDecoder5.Decode(ptr, iter) 823 case decoder.fieldHash6: 824 decoder.fieldDecoder6.Decode(ptr, iter) 825 case decoder.fieldHash7: 826 decoder.fieldDecoder7.Decode(ptr, iter) 827 case decoder.fieldHash8: 828 decoder.fieldDecoder8.Decode(ptr, iter) 829 case decoder.fieldHash9: 830 decoder.fieldDecoder9.Decode(ptr, iter) 831 default: 832 iter.Skip() 833 } 834 if iter.isObjectEnd() { 835 break 836 } 837 } 838 if iter.Error != nil && iter.Error != io.EOF { 839 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 840 } 841} 842 843type tenFieldsStructDecoder struct { 844 typ reflect.Type 845 fieldHash1 int32 846 fieldDecoder1 *structFieldDecoder 847 fieldHash2 int32 848 fieldDecoder2 *structFieldDecoder 849 fieldHash3 int32 850 fieldDecoder3 *structFieldDecoder 851 fieldHash4 int32 852 fieldDecoder4 *structFieldDecoder 853 fieldHash5 int32 854 fieldDecoder5 *structFieldDecoder 855 fieldHash6 int32 856 fieldDecoder6 *structFieldDecoder 857 fieldHash7 int32 858 fieldDecoder7 *structFieldDecoder 859 fieldHash8 int32 860 fieldDecoder8 *structFieldDecoder 861 fieldHash9 int32 862 fieldDecoder9 *structFieldDecoder 863 fieldHash10 int32 864 fieldDecoder10 *structFieldDecoder 865} 866 867func (decoder *tenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 868 if !iter.readObjectStart() { 869 return 870 } 871 for { 872 switch iter.readFieldHash() { 873 case decoder.fieldHash1: 874 decoder.fieldDecoder1.Decode(ptr, iter) 875 case decoder.fieldHash2: 876 decoder.fieldDecoder2.Decode(ptr, iter) 877 case decoder.fieldHash3: 878 decoder.fieldDecoder3.Decode(ptr, iter) 879 case decoder.fieldHash4: 880 decoder.fieldDecoder4.Decode(ptr, iter) 881 case decoder.fieldHash5: 882 decoder.fieldDecoder5.Decode(ptr, iter) 883 case decoder.fieldHash6: 884 decoder.fieldDecoder6.Decode(ptr, iter) 885 case decoder.fieldHash7: 886 decoder.fieldDecoder7.Decode(ptr, iter) 887 case decoder.fieldHash8: 888 decoder.fieldDecoder8.Decode(ptr, iter) 889 case decoder.fieldHash9: 890 decoder.fieldDecoder9.Decode(ptr, iter) 891 case decoder.fieldHash10: 892 decoder.fieldDecoder10.Decode(ptr, iter) 893 default: 894 iter.Skip() 895 } 896 if iter.isObjectEnd() { 897 break 898 } 899 } 900 if iter.Error != nil && iter.Error != io.EOF { 901 iter.Error = fmt.Errorf("%v: %s", decoder.typ, iter.Error.Error()) 902 } 903} 904 905type structFieldDecoder struct { 906 field *reflect.StructField 907 fieldDecoder ValDecoder 908} 909 910func (decoder *structFieldDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) { 911 fieldPtr := unsafe.Pointer(uintptr(ptr) + decoder.field.Offset) 912 decoder.fieldDecoder.Decode(fieldPtr, iter) 913 if iter.Error != nil && iter.Error != io.EOF { 914 iter.Error = fmt.Errorf("%s: %s", decoder.field.Name, iter.Error.Error()) 915 } 916} 917