cmd/bpa-operator/vendor/github.com/json-iterator/go/reflect_struct_decoder.go

   1 package jsoniter
   2
   3 import (
   4         "fmt"
   5         "io"
   6         "strings"
   7         "unsafe"
   8
   9         "github.com/modern-go/reflect2"
  10 )
  11
  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]
  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
  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}
  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
 493 type generalStructDecoder struct {
 494         typ                   reflect2.Type
 495         fields                map[string]*structFieldDecoder
 496         disallowUnknownFields bool
 497 }
 498
 499 func (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
 515 func (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 {
 533                 msg := "found unknown field: " + field
 534                 if decoder.disallowUnknownFields {
 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
 551 type skipObjectDecoder struct {
 552         typ reflect2.Type
 553 }
 554
 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")
 559                 return
 560         }
 561         iter.Skip()
 562 }
 563
 564 type oneFieldStructDecoder struct {
 565         typ          reflect2.Type
 566         fieldHash    int64
 567         fieldDecoder *structFieldDecoder
 568 }
 569
 570 func (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
 589 type twoFieldsStructDecoder struct {
 590         typ           reflect2.Type
 591         fieldHash1    int64
 592         fieldDecoder1 *structFieldDecoder
 593         fieldHash2    int64
 594         fieldDecoder2 *structFieldDecoder
 595 }
 596
 597 func (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
 619 type 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
 629 func (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
 653 type 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
 665 func (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
 691 type 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
 705 func (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
 733 type 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
 749 func (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
 779 type 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
 797 func (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
 829 type 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
 849 func (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
 883 type 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
 905 func (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
 941 type 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
 965 func (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
1003 type structFieldDecoder struct {
1004         field        reflect2.StructField
1005         fieldDecoder ValDecoder
1006 }
1007
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())
1013         }
1014 }
1015
1016 type stringModeStringDecoder struct {
1017         elemDecoder ValDecoder
1018         cfg         *frozenConfig
1019 }
1020
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()
1027 }
1028
1029 type stringModeNumberDecoder struct {
1030         elemDecoder ValDecoder
1031 }
1032
1033 func (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 }