github.com/cdoern/storage@v1.12.13/layers_ffjson.go (about) 1 // Code generated by ffjson <https://github.com/pquerna/ffjson>. DO NOT EDIT. 2 // source: layers.go 3 4 package storage 5 6 import ( 7 "bytes" 8 "encoding/json" 9 "fmt" 10 "github.com/containers/storage/pkg/archive" 11 "github.com/containers/storage/pkg/idtools" 12 "github.com/opencontainers/go-digest" 13 fflib "github.com/pquerna/ffjson/fflib/v1" 14 ) 15 16 // MarshalJSON marshal bytes to json - template 17 func (j *DiffOptions) MarshalJSON() ([]byte, error) { 18 var buf fflib.Buffer 19 if j == nil { 20 buf.WriteString("null") 21 return buf.Bytes(), nil 22 } 23 err := j.MarshalJSONBuf(&buf) 24 if err != nil { 25 return nil, err 26 } 27 return buf.Bytes(), nil 28 } 29 30 // MarshalJSONBuf marshal buff to json - template 31 func (j *DiffOptions) MarshalJSONBuf(buf fflib.EncodingBuffer) error { 32 if j == nil { 33 buf.WriteString("null") 34 return nil 35 } 36 var err error 37 var obj []byte 38 _ = obj 39 _ = err 40 if j.Compression != nil { 41 buf.WriteString(`{"Compression":`) 42 fflib.FormatBits2(buf, uint64(*j.Compression), 10, *j.Compression < 0) 43 } else { 44 buf.WriteString(`{"Compression":null`) 45 } 46 buf.WriteByte('}') 47 return nil 48 } 49 50 const ( 51 ffjtDiffOptionsbase = iota 52 ffjtDiffOptionsnosuchkey 53 54 ffjtDiffOptionsCompression 55 ) 56 57 var ffjKeyDiffOptionsCompression = []byte("Compression") 58 59 // UnmarshalJSON umarshall json - template of ffjson 60 func (j *DiffOptions) UnmarshalJSON(input []byte) error { 61 fs := fflib.NewFFLexer(input) 62 return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) 63 } 64 65 // UnmarshalJSONFFLexer fast json unmarshall - template ffjson 66 func (j *DiffOptions) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { 67 var err error 68 currentKey := ffjtDiffOptionsbase 69 _ = currentKey 70 tok := fflib.FFTok_init 71 wantedTok := fflib.FFTok_init 72 73 mainparse: 74 for { 75 tok = fs.Scan() 76 // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) 77 if tok == fflib.FFTok_error { 78 goto tokerror 79 } 80 81 switch state { 82 83 case fflib.FFParse_map_start: 84 if tok != fflib.FFTok_left_bracket { 85 wantedTok = fflib.FFTok_left_bracket 86 goto wrongtokenerror 87 } 88 state = fflib.FFParse_want_key 89 continue 90 91 case fflib.FFParse_after_value: 92 if tok == fflib.FFTok_comma { 93 state = fflib.FFParse_want_key 94 } else if tok == fflib.FFTok_right_bracket { 95 goto done 96 } else { 97 wantedTok = fflib.FFTok_comma 98 goto wrongtokenerror 99 } 100 101 case fflib.FFParse_want_key: 102 // json {} ended. goto exit. woo. 103 if tok == fflib.FFTok_right_bracket { 104 goto done 105 } 106 if tok != fflib.FFTok_string { 107 wantedTok = fflib.FFTok_string 108 goto wrongtokenerror 109 } 110 111 kn := fs.Output.Bytes() 112 if len(kn) <= 0 { 113 // "" case. hrm. 114 currentKey = ffjtDiffOptionsnosuchkey 115 state = fflib.FFParse_want_colon 116 goto mainparse 117 } else { 118 switch kn[0] { 119 120 case 'C': 121 122 if bytes.Equal(ffjKeyDiffOptionsCompression, kn) { 123 currentKey = ffjtDiffOptionsCompression 124 state = fflib.FFParse_want_colon 125 goto mainparse 126 } 127 128 } 129 130 if fflib.EqualFoldRight(ffjKeyDiffOptionsCompression, kn) { 131 currentKey = ffjtDiffOptionsCompression 132 state = fflib.FFParse_want_colon 133 goto mainparse 134 } 135 136 currentKey = ffjtDiffOptionsnosuchkey 137 state = fflib.FFParse_want_colon 138 goto mainparse 139 } 140 141 case fflib.FFParse_want_colon: 142 if tok != fflib.FFTok_colon { 143 wantedTok = fflib.FFTok_colon 144 goto wrongtokenerror 145 } 146 state = fflib.FFParse_want_value 147 continue 148 case fflib.FFParse_want_value: 149 150 if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { 151 switch currentKey { 152 153 case ffjtDiffOptionsCompression: 154 goto handle_Compression 155 156 case ffjtDiffOptionsnosuchkey: 157 err = fs.SkipField(tok) 158 if err != nil { 159 return fs.WrapErr(err) 160 } 161 state = fflib.FFParse_after_value 162 goto mainparse 163 } 164 } else { 165 goto wantedvalue 166 } 167 } 168 } 169 170 handle_Compression: 171 172 /* handler: j.Compression type=archive.Compression kind=int quoted=false*/ 173 174 { 175 if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { 176 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for Compression", tok)) 177 } 178 } 179 180 { 181 182 if tok == fflib.FFTok_null { 183 184 j.Compression = nil 185 186 } else { 187 188 tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) 189 190 if err != nil { 191 return fs.WrapErr(err) 192 } 193 194 ttypval := archive.Compression(tval) 195 j.Compression = &ttypval 196 197 } 198 } 199 200 state = fflib.FFParse_after_value 201 goto mainparse 202 203 wantedvalue: 204 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 205 wrongtokenerror: 206 return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) 207 tokerror: 208 if fs.BigError != nil { 209 return fs.WrapErr(fs.BigError) 210 } 211 err = fs.Error.ToError() 212 if err != nil { 213 return fs.WrapErr(err) 214 } 215 panic("ffjson-generated: unreachable, please report bug.") 216 done: 217 218 return nil 219 } 220 221 // MarshalJSON marshal bytes to json - template 222 func (j *Layer) MarshalJSON() ([]byte, error) { 223 var buf fflib.Buffer 224 if j == nil { 225 buf.WriteString("null") 226 return buf.Bytes(), nil 227 } 228 err := j.MarshalJSONBuf(&buf) 229 if err != nil { 230 return nil, err 231 } 232 return buf.Bytes(), nil 233 } 234 235 // MarshalJSONBuf marshal buff to json - template 236 func (j *Layer) MarshalJSONBuf(buf fflib.EncodingBuffer) error { 237 if j == nil { 238 buf.WriteString("null") 239 return nil 240 } 241 var err error 242 var obj []byte 243 _ = obj 244 _ = err 245 buf.WriteString(`{ "id":`) 246 fflib.WriteJsonString(buf, string(j.ID)) 247 buf.WriteByte(',') 248 if len(j.Names) != 0 { 249 buf.WriteString(`"names":`) 250 if j.Names != nil { 251 buf.WriteString(`[`) 252 for i, v := range j.Names { 253 if i != 0 { 254 buf.WriteString(`,`) 255 } 256 fflib.WriteJsonString(buf, string(v)) 257 } 258 buf.WriteString(`]`) 259 } else { 260 buf.WriteString(`null`) 261 } 262 buf.WriteByte(',') 263 } 264 if len(j.Parent) != 0 { 265 buf.WriteString(`"parent":`) 266 fflib.WriteJsonString(buf, string(j.Parent)) 267 buf.WriteByte(',') 268 } 269 if len(j.Metadata) != 0 { 270 buf.WriteString(`"metadata":`) 271 fflib.WriteJsonString(buf, string(j.Metadata)) 272 buf.WriteByte(',') 273 } 274 if len(j.MountLabel) != 0 { 275 buf.WriteString(`"mountlabel":`) 276 fflib.WriteJsonString(buf, string(j.MountLabel)) 277 buf.WriteByte(',') 278 } 279 if true { 280 buf.WriteString(`"created":`) 281 282 { 283 284 obj, err = j.Created.MarshalJSON() 285 if err != nil { 286 return err 287 } 288 buf.Write(obj) 289 290 } 291 buf.WriteByte(',') 292 } 293 if len(j.CompressedDigest) != 0 { 294 buf.WriteString(`"compressed-diff-digest":`) 295 fflib.WriteJsonString(buf, string(j.CompressedDigest)) 296 buf.WriteByte(',') 297 } 298 if j.CompressedSize != 0 { 299 buf.WriteString(`"compressed-size":`) 300 fflib.FormatBits2(buf, uint64(j.CompressedSize), 10, j.CompressedSize < 0) 301 buf.WriteByte(',') 302 } 303 if len(j.UncompressedDigest) != 0 { 304 buf.WriteString(`"diff-digest":`) 305 fflib.WriteJsonString(buf, string(j.UncompressedDigest)) 306 buf.WriteByte(',') 307 } 308 if j.UncompressedSize != 0 { 309 buf.WriteString(`"diff-size":`) 310 fflib.FormatBits2(buf, uint64(j.UncompressedSize), 10, j.UncompressedSize < 0) 311 buf.WriteByte(',') 312 } 313 if j.CompressionType != 0 { 314 buf.WriteString(`"compression":`) 315 fflib.FormatBits2(buf, uint64(j.CompressionType), 10, j.CompressionType < 0) 316 buf.WriteByte(',') 317 } 318 if len(j.Flags) != 0 { 319 buf.WriteString(`"flags":`) 320 /* Falling back. type=map[string]interface {} kind=map */ 321 err = buf.Encode(j.Flags) 322 if err != nil { 323 return err 324 } 325 buf.WriteByte(',') 326 } 327 if len(j.UIDMap) != 0 { 328 buf.WriteString(`"uidmap":`) 329 if j.UIDMap != nil { 330 buf.WriteString(`[`) 331 for i, v := range j.UIDMap { 332 if i != 0 { 333 buf.WriteString(`,`) 334 } 335 /* Struct fall back. type=idtools.IDMap kind=struct */ 336 err = buf.Encode(&v) 337 if err != nil { 338 return err 339 } 340 } 341 buf.WriteString(`]`) 342 } else { 343 buf.WriteString(`null`) 344 } 345 buf.WriteByte(',') 346 } 347 if len(j.GIDMap) != 0 { 348 buf.WriteString(`"gidmap":`) 349 if j.GIDMap != nil { 350 buf.WriteString(`[`) 351 for i, v := range j.GIDMap { 352 if i != 0 { 353 buf.WriteString(`,`) 354 } 355 /* Struct fall back. type=idtools.IDMap kind=struct */ 356 err = buf.Encode(&v) 357 if err != nil { 358 return err 359 } 360 } 361 buf.WriteString(`]`) 362 } else { 363 buf.WriteString(`null`) 364 } 365 buf.WriteByte(',') 366 } 367 buf.Rewind(1) 368 buf.WriteByte('}') 369 return nil 370 } 371 372 const ( 373 ffjtLayerbase = iota 374 ffjtLayernosuchkey 375 376 ffjtLayerID 377 378 ffjtLayerNames 379 380 ffjtLayerParent 381 382 ffjtLayerMetadata 383 384 ffjtLayerMountLabel 385 386 ffjtLayerCreated 387 388 ffjtLayerCompressedDigest 389 390 ffjtLayerCompressedSize 391 392 ffjtLayerUncompressedDigest 393 394 ffjtLayerUncompressedSize 395 396 ffjtLayerCompressionType 397 398 ffjtLayerFlags 399 400 ffjtLayerUIDMap 401 402 ffjtLayerGIDMap 403 ) 404 405 var ffjKeyLayerID = []byte("id") 406 407 var ffjKeyLayerNames = []byte("names") 408 409 var ffjKeyLayerParent = []byte("parent") 410 411 var ffjKeyLayerMetadata = []byte("metadata") 412 413 var ffjKeyLayerMountLabel = []byte("mountlabel") 414 415 var ffjKeyLayerCreated = []byte("created") 416 417 var ffjKeyLayerCompressedDigest = []byte("compressed-diff-digest") 418 419 var ffjKeyLayerCompressedSize = []byte("compressed-size") 420 421 var ffjKeyLayerUncompressedDigest = []byte("diff-digest") 422 423 var ffjKeyLayerUncompressedSize = []byte("diff-size") 424 425 var ffjKeyLayerCompressionType = []byte("compression") 426 427 var ffjKeyLayerFlags = []byte("flags") 428 429 var ffjKeyLayerUIDMap = []byte("uidmap") 430 431 var ffjKeyLayerGIDMap = []byte("gidmap") 432 433 // UnmarshalJSON umarshall json - template of ffjson 434 func (j *Layer) UnmarshalJSON(input []byte) error { 435 fs := fflib.NewFFLexer(input) 436 return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) 437 } 438 439 // UnmarshalJSONFFLexer fast json unmarshall - template ffjson 440 func (j *Layer) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { 441 var err error 442 currentKey := ffjtLayerbase 443 _ = currentKey 444 tok := fflib.FFTok_init 445 wantedTok := fflib.FFTok_init 446 447 mainparse: 448 for { 449 tok = fs.Scan() 450 // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) 451 if tok == fflib.FFTok_error { 452 goto tokerror 453 } 454 455 switch state { 456 457 case fflib.FFParse_map_start: 458 if tok != fflib.FFTok_left_bracket { 459 wantedTok = fflib.FFTok_left_bracket 460 goto wrongtokenerror 461 } 462 state = fflib.FFParse_want_key 463 continue 464 465 case fflib.FFParse_after_value: 466 if tok == fflib.FFTok_comma { 467 state = fflib.FFParse_want_key 468 } else if tok == fflib.FFTok_right_bracket { 469 goto done 470 } else { 471 wantedTok = fflib.FFTok_comma 472 goto wrongtokenerror 473 } 474 475 case fflib.FFParse_want_key: 476 // json {} ended. goto exit. woo. 477 if tok == fflib.FFTok_right_bracket { 478 goto done 479 } 480 if tok != fflib.FFTok_string { 481 wantedTok = fflib.FFTok_string 482 goto wrongtokenerror 483 } 484 485 kn := fs.Output.Bytes() 486 if len(kn) <= 0 { 487 // "" case. hrm. 488 currentKey = ffjtLayernosuchkey 489 state = fflib.FFParse_want_colon 490 goto mainparse 491 } else { 492 switch kn[0] { 493 494 case 'c': 495 496 if bytes.Equal(ffjKeyLayerCreated, kn) { 497 currentKey = ffjtLayerCreated 498 state = fflib.FFParse_want_colon 499 goto mainparse 500 501 } else if bytes.Equal(ffjKeyLayerCompressedDigest, kn) { 502 currentKey = ffjtLayerCompressedDigest 503 state = fflib.FFParse_want_colon 504 goto mainparse 505 506 } else if bytes.Equal(ffjKeyLayerCompressedSize, kn) { 507 currentKey = ffjtLayerCompressedSize 508 state = fflib.FFParse_want_colon 509 goto mainparse 510 511 } else if bytes.Equal(ffjKeyLayerCompressionType, kn) { 512 currentKey = ffjtLayerCompressionType 513 state = fflib.FFParse_want_colon 514 goto mainparse 515 } 516 517 case 'd': 518 519 if bytes.Equal(ffjKeyLayerUncompressedDigest, kn) { 520 currentKey = ffjtLayerUncompressedDigest 521 state = fflib.FFParse_want_colon 522 goto mainparse 523 524 } else if bytes.Equal(ffjKeyLayerUncompressedSize, kn) { 525 currentKey = ffjtLayerUncompressedSize 526 state = fflib.FFParse_want_colon 527 goto mainparse 528 } 529 530 case 'f': 531 532 if bytes.Equal(ffjKeyLayerFlags, kn) { 533 currentKey = ffjtLayerFlags 534 state = fflib.FFParse_want_colon 535 goto mainparse 536 } 537 538 case 'g': 539 540 if bytes.Equal(ffjKeyLayerGIDMap, kn) { 541 currentKey = ffjtLayerGIDMap 542 state = fflib.FFParse_want_colon 543 goto mainparse 544 } 545 546 case 'i': 547 548 if bytes.Equal(ffjKeyLayerID, kn) { 549 currentKey = ffjtLayerID 550 state = fflib.FFParse_want_colon 551 goto mainparse 552 } 553 554 case 'm': 555 556 if bytes.Equal(ffjKeyLayerMetadata, kn) { 557 currentKey = ffjtLayerMetadata 558 state = fflib.FFParse_want_colon 559 goto mainparse 560 561 } else if bytes.Equal(ffjKeyLayerMountLabel, kn) { 562 currentKey = ffjtLayerMountLabel 563 state = fflib.FFParse_want_colon 564 goto mainparse 565 } 566 567 case 'n': 568 569 if bytes.Equal(ffjKeyLayerNames, kn) { 570 currentKey = ffjtLayerNames 571 state = fflib.FFParse_want_colon 572 goto mainparse 573 } 574 575 case 'p': 576 577 if bytes.Equal(ffjKeyLayerParent, kn) { 578 currentKey = ffjtLayerParent 579 state = fflib.FFParse_want_colon 580 goto mainparse 581 } 582 583 case 'u': 584 585 if bytes.Equal(ffjKeyLayerUIDMap, kn) { 586 currentKey = ffjtLayerUIDMap 587 state = fflib.FFParse_want_colon 588 goto mainparse 589 } 590 591 } 592 593 if fflib.SimpleLetterEqualFold(ffjKeyLayerGIDMap, kn) { 594 currentKey = ffjtLayerGIDMap 595 state = fflib.FFParse_want_colon 596 goto mainparse 597 } 598 599 if fflib.SimpleLetterEqualFold(ffjKeyLayerUIDMap, kn) { 600 currentKey = ffjtLayerUIDMap 601 state = fflib.FFParse_want_colon 602 goto mainparse 603 } 604 605 if fflib.EqualFoldRight(ffjKeyLayerFlags, kn) { 606 currentKey = ffjtLayerFlags 607 state = fflib.FFParse_want_colon 608 goto mainparse 609 } 610 611 if fflib.EqualFoldRight(ffjKeyLayerCompressionType, kn) { 612 currentKey = ffjtLayerCompressionType 613 state = fflib.FFParse_want_colon 614 goto mainparse 615 } 616 617 if fflib.EqualFoldRight(ffjKeyLayerUncompressedSize, kn) { 618 currentKey = ffjtLayerUncompressedSize 619 state = fflib.FFParse_want_colon 620 goto mainparse 621 } 622 623 if fflib.EqualFoldRight(ffjKeyLayerUncompressedDigest, kn) { 624 currentKey = ffjtLayerUncompressedDigest 625 state = fflib.FFParse_want_colon 626 goto mainparse 627 } 628 629 if fflib.EqualFoldRight(ffjKeyLayerCompressedSize, kn) { 630 currentKey = ffjtLayerCompressedSize 631 state = fflib.FFParse_want_colon 632 goto mainparse 633 } 634 635 if fflib.EqualFoldRight(ffjKeyLayerCompressedDigest, kn) { 636 currentKey = ffjtLayerCompressedDigest 637 state = fflib.FFParse_want_colon 638 goto mainparse 639 } 640 641 if fflib.SimpleLetterEqualFold(ffjKeyLayerCreated, kn) { 642 currentKey = ffjtLayerCreated 643 state = fflib.FFParse_want_colon 644 goto mainparse 645 } 646 647 if fflib.SimpleLetterEqualFold(ffjKeyLayerMountLabel, kn) { 648 currentKey = ffjtLayerMountLabel 649 state = fflib.FFParse_want_colon 650 goto mainparse 651 } 652 653 if fflib.SimpleLetterEqualFold(ffjKeyLayerMetadata, kn) { 654 currentKey = ffjtLayerMetadata 655 state = fflib.FFParse_want_colon 656 goto mainparse 657 } 658 659 if fflib.SimpleLetterEqualFold(ffjKeyLayerParent, kn) { 660 currentKey = ffjtLayerParent 661 state = fflib.FFParse_want_colon 662 goto mainparse 663 } 664 665 if fflib.EqualFoldRight(ffjKeyLayerNames, kn) { 666 currentKey = ffjtLayerNames 667 state = fflib.FFParse_want_colon 668 goto mainparse 669 } 670 671 if fflib.SimpleLetterEqualFold(ffjKeyLayerID, kn) { 672 currentKey = ffjtLayerID 673 state = fflib.FFParse_want_colon 674 goto mainparse 675 } 676 677 currentKey = ffjtLayernosuchkey 678 state = fflib.FFParse_want_colon 679 goto mainparse 680 } 681 682 case fflib.FFParse_want_colon: 683 if tok != fflib.FFTok_colon { 684 wantedTok = fflib.FFTok_colon 685 goto wrongtokenerror 686 } 687 state = fflib.FFParse_want_value 688 continue 689 case fflib.FFParse_want_value: 690 691 if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { 692 switch currentKey { 693 694 case ffjtLayerID: 695 goto handle_ID 696 697 case ffjtLayerNames: 698 goto handle_Names 699 700 case ffjtLayerParent: 701 goto handle_Parent 702 703 case ffjtLayerMetadata: 704 goto handle_Metadata 705 706 case ffjtLayerMountLabel: 707 goto handle_MountLabel 708 709 case ffjtLayerCreated: 710 goto handle_Created 711 712 case ffjtLayerCompressedDigest: 713 goto handle_CompressedDigest 714 715 case ffjtLayerCompressedSize: 716 goto handle_CompressedSize 717 718 case ffjtLayerUncompressedDigest: 719 goto handle_UncompressedDigest 720 721 case ffjtLayerUncompressedSize: 722 goto handle_UncompressedSize 723 724 case ffjtLayerCompressionType: 725 goto handle_CompressionType 726 727 case ffjtLayerFlags: 728 goto handle_Flags 729 730 case ffjtLayerUIDMap: 731 goto handle_UIDMap 732 733 case ffjtLayerGIDMap: 734 goto handle_GIDMap 735 736 case ffjtLayernosuchkey: 737 err = fs.SkipField(tok) 738 if err != nil { 739 return fs.WrapErr(err) 740 } 741 state = fflib.FFParse_after_value 742 goto mainparse 743 } 744 } else { 745 goto wantedvalue 746 } 747 } 748 } 749 750 handle_ID: 751 752 /* handler: j.ID type=string kind=string quoted=false*/ 753 754 { 755 756 { 757 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 758 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 759 } 760 } 761 762 if tok == fflib.FFTok_null { 763 764 } else { 765 766 outBuf := fs.Output.Bytes() 767 768 j.ID = string(string(outBuf)) 769 770 } 771 } 772 773 state = fflib.FFParse_after_value 774 goto mainparse 775 776 handle_Names: 777 778 /* handler: j.Names type=[]string kind=slice quoted=false*/ 779 780 { 781 782 { 783 if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { 784 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 785 } 786 } 787 788 if tok == fflib.FFTok_null { 789 j.Names = nil 790 } else { 791 792 j.Names = []string{} 793 794 wantVal := true 795 796 for { 797 798 var tmpJNames string 799 800 tok = fs.Scan() 801 if tok == fflib.FFTok_error { 802 goto tokerror 803 } 804 if tok == fflib.FFTok_right_brace { 805 break 806 } 807 808 if tok == fflib.FFTok_comma { 809 if wantVal == true { 810 // TODO(pquerna): this isn't an ideal error message, this handles 811 // things like [,,,] as an array value. 812 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 813 } 814 continue 815 } else { 816 wantVal = true 817 } 818 819 /* handler: tmpJNames type=string kind=string quoted=false*/ 820 821 { 822 823 { 824 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 825 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 826 } 827 } 828 829 if tok == fflib.FFTok_null { 830 831 } else { 832 833 outBuf := fs.Output.Bytes() 834 835 tmpJNames = string(string(outBuf)) 836 837 } 838 } 839 840 j.Names = append(j.Names, tmpJNames) 841 842 wantVal = false 843 } 844 } 845 } 846 847 state = fflib.FFParse_after_value 848 goto mainparse 849 850 handle_Parent: 851 852 /* handler: j.Parent type=string kind=string quoted=false*/ 853 854 { 855 856 { 857 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 858 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 859 } 860 } 861 862 if tok == fflib.FFTok_null { 863 864 } else { 865 866 outBuf := fs.Output.Bytes() 867 868 j.Parent = string(string(outBuf)) 869 870 } 871 } 872 873 state = fflib.FFParse_after_value 874 goto mainparse 875 876 handle_Metadata: 877 878 /* handler: j.Metadata type=string kind=string quoted=false*/ 879 880 { 881 882 { 883 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 884 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 885 } 886 } 887 888 if tok == fflib.FFTok_null { 889 890 } else { 891 892 outBuf := fs.Output.Bytes() 893 894 j.Metadata = string(string(outBuf)) 895 896 } 897 } 898 899 state = fflib.FFParse_after_value 900 goto mainparse 901 902 handle_MountLabel: 903 904 /* handler: j.MountLabel type=string kind=string quoted=false*/ 905 906 { 907 908 { 909 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 910 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 911 } 912 } 913 914 if tok == fflib.FFTok_null { 915 916 } else { 917 918 outBuf := fs.Output.Bytes() 919 920 j.MountLabel = string(string(outBuf)) 921 922 } 923 } 924 925 state = fflib.FFParse_after_value 926 goto mainparse 927 928 handle_Created: 929 930 /* handler: j.Created type=time.Time kind=struct quoted=false*/ 931 932 { 933 if tok == fflib.FFTok_null { 934 935 } else { 936 937 tbuf, err := fs.CaptureField(tok) 938 if err != nil { 939 return fs.WrapErr(err) 940 } 941 942 err = j.Created.UnmarshalJSON(tbuf) 943 if err != nil { 944 return fs.WrapErr(err) 945 } 946 } 947 state = fflib.FFParse_after_value 948 } 949 950 state = fflib.FFParse_after_value 951 goto mainparse 952 953 handle_CompressedDigest: 954 955 /* handler: j.CompressedDigest type=digest.Digest kind=string quoted=false*/ 956 957 { 958 959 { 960 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 961 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for Digest", tok)) 962 } 963 } 964 965 if tok == fflib.FFTok_null { 966 967 } else { 968 969 outBuf := fs.Output.Bytes() 970 971 j.CompressedDigest = digest.Digest(string(outBuf)) 972 973 } 974 } 975 976 state = fflib.FFParse_after_value 977 goto mainparse 978 979 handle_CompressedSize: 980 981 /* handler: j.CompressedSize type=int64 kind=int64 quoted=false*/ 982 983 { 984 if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { 985 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int64", tok)) 986 } 987 } 988 989 { 990 991 if tok == fflib.FFTok_null { 992 993 } else { 994 995 tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) 996 997 if err != nil { 998 return fs.WrapErr(err) 999 } 1000 1001 j.CompressedSize = int64(tval) 1002 1003 } 1004 } 1005 1006 state = fflib.FFParse_after_value 1007 goto mainparse 1008 1009 handle_UncompressedDigest: 1010 1011 /* handler: j.UncompressedDigest type=digest.Digest kind=string quoted=false*/ 1012 1013 { 1014 1015 { 1016 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 1017 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for Digest", tok)) 1018 } 1019 } 1020 1021 if tok == fflib.FFTok_null { 1022 1023 } else { 1024 1025 outBuf := fs.Output.Bytes() 1026 1027 j.UncompressedDigest = digest.Digest(string(outBuf)) 1028 1029 } 1030 } 1031 1032 state = fflib.FFParse_after_value 1033 goto mainparse 1034 1035 handle_UncompressedSize: 1036 1037 /* handler: j.UncompressedSize type=int64 kind=int64 quoted=false*/ 1038 1039 { 1040 if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { 1041 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int64", tok)) 1042 } 1043 } 1044 1045 { 1046 1047 if tok == fflib.FFTok_null { 1048 1049 } else { 1050 1051 tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) 1052 1053 if err != nil { 1054 return fs.WrapErr(err) 1055 } 1056 1057 j.UncompressedSize = int64(tval) 1058 1059 } 1060 } 1061 1062 state = fflib.FFParse_after_value 1063 goto mainparse 1064 1065 handle_CompressionType: 1066 1067 /* handler: j.CompressionType type=archive.Compression kind=int quoted=false*/ 1068 1069 { 1070 if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { 1071 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for Compression", tok)) 1072 } 1073 } 1074 1075 { 1076 1077 if tok == fflib.FFTok_null { 1078 1079 } else { 1080 1081 tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) 1082 1083 if err != nil { 1084 return fs.WrapErr(err) 1085 } 1086 1087 j.CompressionType = archive.Compression(tval) 1088 1089 } 1090 } 1091 1092 state = fflib.FFParse_after_value 1093 goto mainparse 1094 1095 handle_Flags: 1096 1097 /* handler: j.Flags type=map[string]interface {} kind=map quoted=false*/ 1098 1099 { 1100 1101 { 1102 if tok != fflib.FFTok_left_bracket && tok != fflib.FFTok_null { 1103 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 1104 } 1105 } 1106 1107 if tok == fflib.FFTok_null { 1108 j.Flags = nil 1109 } else { 1110 1111 j.Flags = make(map[string]interface{}, 0) 1112 1113 wantVal := true 1114 1115 for { 1116 1117 var k string 1118 1119 var tmpJFlags interface{} 1120 1121 tok = fs.Scan() 1122 if tok == fflib.FFTok_error { 1123 goto tokerror 1124 } 1125 if tok == fflib.FFTok_right_bracket { 1126 break 1127 } 1128 1129 if tok == fflib.FFTok_comma { 1130 if wantVal == true { 1131 // TODO(pquerna): this isn't an ideal error message, this handles 1132 // things like [,,,] as an array value. 1133 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1134 } 1135 continue 1136 } else { 1137 wantVal = true 1138 } 1139 1140 /* handler: k type=string kind=string quoted=false*/ 1141 1142 { 1143 1144 { 1145 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 1146 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 1147 } 1148 } 1149 1150 if tok == fflib.FFTok_null { 1151 1152 } else { 1153 1154 outBuf := fs.Output.Bytes() 1155 1156 k = string(string(outBuf)) 1157 1158 } 1159 } 1160 1161 // Expect ':' after key 1162 tok = fs.Scan() 1163 if tok != fflib.FFTok_colon { 1164 return fs.WrapErr(fmt.Errorf("wanted colon token, but got token: %v", tok)) 1165 } 1166 1167 tok = fs.Scan() 1168 /* handler: tmpJFlags type=interface {} kind=interface quoted=false*/ 1169 1170 { 1171 /* Falling back. type=interface {} kind=interface */ 1172 tbuf, err := fs.CaptureField(tok) 1173 if err != nil { 1174 return fs.WrapErr(err) 1175 } 1176 1177 err = json.Unmarshal(tbuf, &tmpJFlags) 1178 if err != nil { 1179 return fs.WrapErr(err) 1180 } 1181 } 1182 1183 j.Flags[k] = tmpJFlags 1184 1185 wantVal = false 1186 } 1187 1188 } 1189 } 1190 1191 state = fflib.FFParse_after_value 1192 goto mainparse 1193 1194 handle_UIDMap: 1195 1196 /* handler: j.UIDMap type=[]idtools.IDMap kind=slice quoted=false*/ 1197 1198 { 1199 1200 { 1201 if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { 1202 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 1203 } 1204 } 1205 1206 if tok == fflib.FFTok_null { 1207 j.UIDMap = nil 1208 } else { 1209 1210 j.UIDMap = []idtools.IDMap{} 1211 1212 wantVal := true 1213 1214 for { 1215 1216 var tmpJUIDMap idtools.IDMap 1217 1218 tok = fs.Scan() 1219 if tok == fflib.FFTok_error { 1220 goto tokerror 1221 } 1222 if tok == fflib.FFTok_right_brace { 1223 break 1224 } 1225 1226 if tok == fflib.FFTok_comma { 1227 if wantVal == true { 1228 // TODO(pquerna): this isn't an ideal error message, this handles 1229 // things like [,,,] as an array value. 1230 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1231 } 1232 continue 1233 } else { 1234 wantVal = true 1235 } 1236 1237 /* handler: tmpJUIDMap type=idtools.IDMap kind=struct quoted=false*/ 1238 1239 { 1240 /* Falling back. type=idtools.IDMap kind=struct */ 1241 tbuf, err := fs.CaptureField(tok) 1242 if err != nil { 1243 return fs.WrapErr(err) 1244 } 1245 1246 err = json.Unmarshal(tbuf, &tmpJUIDMap) 1247 if err != nil { 1248 return fs.WrapErr(err) 1249 } 1250 } 1251 1252 j.UIDMap = append(j.UIDMap, tmpJUIDMap) 1253 1254 wantVal = false 1255 } 1256 } 1257 } 1258 1259 state = fflib.FFParse_after_value 1260 goto mainparse 1261 1262 handle_GIDMap: 1263 1264 /* handler: j.GIDMap type=[]idtools.IDMap kind=slice quoted=false*/ 1265 1266 { 1267 1268 { 1269 if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { 1270 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 1271 } 1272 } 1273 1274 if tok == fflib.FFTok_null { 1275 j.GIDMap = nil 1276 } else { 1277 1278 j.GIDMap = []idtools.IDMap{} 1279 1280 wantVal := true 1281 1282 for { 1283 1284 var tmpJGIDMap idtools.IDMap 1285 1286 tok = fs.Scan() 1287 if tok == fflib.FFTok_error { 1288 goto tokerror 1289 } 1290 if tok == fflib.FFTok_right_brace { 1291 break 1292 } 1293 1294 if tok == fflib.FFTok_comma { 1295 if wantVal == true { 1296 // TODO(pquerna): this isn't an ideal error message, this handles 1297 // things like [,,,] as an array value. 1298 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1299 } 1300 continue 1301 } else { 1302 wantVal = true 1303 } 1304 1305 /* handler: tmpJGIDMap type=idtools.IDMap kind=struct quoted=false*/ 1306 1307 { 1308 /* Falling back. type=idtools.IDMap kind=struct */ 1309 tbuf, err := fs.CaptureField(tok) 1310 if err != nil { 1311 return fs.WrapErr(err) 1312 } 1313 1314 err = json.Unmarshal(tbuf, &tmpJGIDMap) 1315 if err != nil { 1316 return fs.WrapErr(err) 1317 } 1318 } 1319 1320 j.GIDMap = append(j.GIDMap, tmpJGIDMap) 1321 1322 wantVal = false 1323 } 1324 } 1325 } 1326 1327 state = fflib.FFParse_after_value 1328 goto mainparse 1329 1330 wantedvalue: 1331 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1332 wrongtokenerror: 1333 return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) 1334 tokerror: 1335 if fs.BigError != nil { 1336 return fs.WrapErr(fs.BigError) 1337 } 1338 err = fs.Error.ToError() 1339 if err != nil { 1340 return fs.WrapErr(err) 1341 } 1342 panic("ffjson-generated: unreachable, please report bug.") 1343 done: 1344 1345 return nil 1346 } 1347 1348 // MarshalJSON marshal bytes to json - template 1349 func (j *layerMountPoint) MarshalJSON() ([]byte, error) { 1350 var buf fflib.Buffer 1351 if j == nil { 1352 buf.WriteString("null") 1353 return buf.Bytes(), nil 1354 } 1355 err := j.MarshalJSONBuf(&buf) 1356 if err != nil { 1357 return nil, err 1358 } 1359 return buf.Bytes(), nil 1360 } 1361 1362 // MarshalJSONBuf marshal buff to json - template 1363 func (j *layerMountPoint) MarshalJSONBuf(buf fflib.EncodingBuffer) error { 1364 if j == nil { 1365 buf.WriteString("null") 1366 return nil 1367 } 1368 var err error 1369 var obj []byte 1370 _ = obj 1371 _ = err 1372 buf.WriteString(`{"id":`) 1373 fflib.WriteJsonString(buf, string(j.ID)) 1374 buf.WriteString(`,"path":`) 1375 fflib.WriteJsonString(buf, string(j.MountPoint)) 1376 buf.WriteString(`,"count":`) 1377 fflib.FormatBits2(buf, uint64(j.MountCount), 10, j.MountCount < 0) 1378 buf.WriteByte('}') 1379 return nil 1380 } 1381 1382 const ( 1383 ffjtlayerMountPointbase = iota 1384 ffjtlayerMountPointnosuchkey 1385 1386 ffjtlayerMountPointID 1387 1388 ffjtlayerMountPointMountPoint 1389 1390 ffjtlayerMountPointMountCount 1391 ) 1392 1393 var ffjKeylayerMountPointID = []byte("id") 1394 1395 var ffjKeylayerMountPointMountPoint = []byte("path") 1396 1397 var ffjKeylayerMountPointMountCount = []byte("count") 1398 1399 // UnmarshalJSON umarshall json - template of ffjson 1400 func (j *layerMountPoint) UnmarshalJSON(input []byte) error { 1401 fs := fflib.NewFFLexer(input) 1402 return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) 1403 } 1404 1405 // UnmarshalJSONFFLexer fast json unmarshall - template ffjson 1406 func (j *layerMountPoint) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { 1407 var err error 1408 currentKey := ffjtlayerMountPointbase 1409 _ = currentKey 1410 tok := fflib.FFTok_init 1411 wantedTok := fflib.FFTok_init 1412 1413 mainparse: 1414 for { 1415 tok = fs.Scan() 1416 // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) 1417 if tok == fflib.FFTok_error { 1418 goto tokerror 1419 } 1420 1421 switch state { 1422 1423 case fflib.FFParse_map_start: 1424 if tok != fflib.FFTok_left_bracket { 1425 wantedTok = fflib.FFTok_left_bracket 1426 goto wrongtokenerror 1427 } 1428 state = fflib.FFParse_want_key 1429 continue 1430 1431 case fflib.FFParse_after_value: 1432 if tok == fflib.FFTok_comma { 1433 state = fflib.FFParse_want_key 1434 } else if tok == fflib.FFTok_right_bracket { 1435 goto done 1436 } else { 1437 wantedTok = fflib.FFTok_comma 1438 goto wrongtokenerror 1439 } 1440 1441 case fflib.FFParse_want_key: 1442 // json {} ended. goto exit. woo. 1443 if tok == fflib.FFTok_right_bracket { 1444 goto done 1445 } 1446 if tok != fflib.FFTok_string { 1447 wantedTok = fflib.FFTok_string 1448 goto wrongtokenerror 1449 } 1450 1451 kn := fs.Output.Bytes() 1452 if len(kn) <= 0 { 1453 // "" case. hrm. 1454 currentKey = ffjtlayerMountPointnosuchkey 1455 state = fflib.FFParse_want_colon 1456 goto mainparse 1457 } else { 1458 switch kn[0] { 1459 1460 case 'c': 1461 1462 if bytes.Equal(ffjKeylayerMountPointMountCount, kn) { 1463 currentKey = ffjtlayerMountPointMountCount 1464 state = fflib.FFParse_want_colon 1465 goto mainparse 1466 } 1467 1468 case 'i': 1469 1470 if bytes.Equal(ffjKeylayerMountPointID, kn) { 1471 currentKey = ffjtlayerMountPointID 1472 state = fflib.FFParse_want_colon 1473 goto mainparse 1474 } 1475 1476 case 'p': 1477 1478 if bytes.Equal(ffjKeylayerMountPointMountPoint, kn) { 1479 currentKey = ffjtlayerMountPointMountPoint 1480 state = fflib.FFParse_want_colon 1481 goto mainparse 1482 } 1483 1484 } 1485 1486 if fflib.SimpleLetterEqualFold(ffjKeylayerMountPointMountCount, kn) { 1487 currentKey = ffjtlayerMountPointMountCount 1488 state = fflib.FFParse_want_colon 1489 goto mainparse 1490 } 1491 1492 if fflib.SimpleLetterEqualFold(ffjKeylayerMountPointMountPoint, kn) { 1493 currentKey = ffjtlayerMountPointMountPoint 1494 state = fflib.FFParse_want_colon 1495 goto mainparse 1496 } 1497 1498 if fflib.SimpleLetterEqualFold(ffjKeylayerMountPointID, kn) { 1499 currentKey = ffjtlayerMountPointID 1500 state = fflib.FFParse_want_colon 1501 goto mainparse 1502 } 1503 1504 currentKey = ffjtlayerMountPointnosuchkey 1505 state = fflib.FFParse_want_colon 1506 goto mainparse 1507 } 1508 1509 case fflib.FFParse_want_colon: 1510 if tok != fflib.FFTok_colon { 1511 wantedTok = fflib.FFTok_colon 1512 goto wrongtokenerror 1513 } 1514 state = fflib.FFParse_want_value 1515 continue 1516 case fflib.FFParse_want_value: 1517 1518 if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { 1519 switch currentKey { 1520 1521 case ffjtlayerMountPointID: 1522 goto handle_ID 1523 1524 case ffjtlayerMountPointMountPoint: 1525 goto handle_MountPoint 1526 1527 case ffjtlayerMountPointMountCount: 1528 goto handle_MountCount 1529 1530 case ffjtlayerMountPointnosuchkey: 1531 err = fs.SkipField(tok) 1532 if err != nil { 1533 return fs.WrapErr(err) 1534 } 1535 state = fflib.FFParse_after_value 1536 goto mainparse 1537 } 1538 } else { 1539 goto wantedvalue 1540 } 1541 } 1542 } 1543 1544 handle_ID: 1545 1546 /* handler: j.ID type=string kind=string quoted=false*/ 1547 1548 { 1549 1550 { 1551 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 1552 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 1553 } 1554 } 1555 1556 if tok == fflib.FFTok_null { 1557 1558 } else { 1559 1560 outBuf := fs.Output.Bytes() 1561 1562 j.ID = string(string(outBuf)) 1563 1564 } 1565 } 1566 1567 state = fflib.FFParse_after_value 1568 goto mainparse 1569 1570 handle_MountPoint: 1571 1572 /* handler: j.MountPoint type=string kind=string quoted=false*/ 1573 1574 { 1575 1576 { 1577 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 1578 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 1579 } 1580 } 1581 1582 if tok == fflib.FFTok_null { 1583 1584 } else { 1585 1586 outBuf := fs.Output.Bytes() 1587 1588 j.MountPoint = string(string(outBuf)) 1589 1590 } 1591 } 1592 1593 state = fflib.FFParse_after_value 1594 goto mainparse 1595 1596 handle_MountCount: 1597 1598 /* handler: j.MountCount type=int kind=int quoted=false*/ 1599 1600 { 1601 if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { 1602 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) 1603 } 1604 } 1605 1606 { 1607 1608 if tok == fflib.FFTok_null { 1609 1610 } else { 1611 1612 tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) 1613 1614 if err != nil { 1615 return fs.WrapErr(err) 1616 } 1617 1618 j.MountCount = int(tval) 1619 1620 } 1621 } 1622 1623 state = fflib.FFParse_after_value 1624 goto mainparse 1625 1626 wantedvalue: 1627 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1628 wrongtokenerror: 1629 return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) 1630 tokerror: 1631 if fs.BigError != nil { 1632 return fs.WrapErr(fs.BigError) 1633 } 1634 err = fs.Error.ToError() 1635 if err != nil { 1636 return fs.WrapErr(err) 1637 } 1638 panic("ffjson-generated: unreachable, please report bug.") 1639 done: 1640 1641 return nil 1642 } 1643 1644 // MarshalJSON marshal bytes to json - template 1645 func (j *layerStore) MarshalJSON() ([]byte, error) { 1646 var buf fflib.Buffer 1647 if j == nil { 1648 buf.WriteString("null") 1649 return buf.Bytes(), nil 1650 } 1651 err := j.MarshalJSONBuf(&buf) 1652 if err != nil { 1653 return nil, err 1654 } 1655 return buf.Bytes(), nil 1656 } 1657 1658 // MarshalJSONBuf marshal buff to json - template 1659 func (j *layerStore) MarshalJSONBuf(buf fflib.EncodingBuffer) error { 1660 if j == nil { 1661 buf.WriteString("null") 1662 return nil 1663 } 1664 var err error 1665 var obj []byte 1666 _ = obj 1667 _ = err 1668 buf.WriteString(`{}`) 1669 return nil 1670 } 1671 1672 const ( 1673 ffjtlayerStorebase = iota 1674 ffjtlayerStorenosuchkey 1675 ) 1676 1677 // UnmarshalJSON umarshall json - template of ffjson 1678 func (j *layerStore) UnmarshalJSON(input []byte) error { 1679 fs := fflib.NewFFLexer(input) 1680 return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) 1681 } 1682 1683 // UnmarshalJSONFFLexer fast json unmarshall - template ffjson 1684 func (j *layerStore) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { 1685 var err error 1686 currentKey := ffjtlayerStorebase 1687 _ = currentKey 1688 tok := fflib.FFTok_init 1689 wantedTok := fflib.FFTok_init 1690 1691 mainparse: 1692 for { 1693 tok = fs.Scan() 1694 // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) 1695 if tok == fflib.FFTok_error { 1696 goto tokerror 1697 } 1698 1699 switch state { 1700 1701 case fflib.FFParse_map_start: 1702 if tok != fflib.FFTok_left_bracket { 1703 wantedTok = fflib.FFTok_left_bracket 1704 goto wrongtokenerror 1705 } 1706 state = fflib.FFParse_want_key 1707 continue 1708 1709 case fflib.FFParse_after_value: 1710 if tok == fflib.FFTok_comma { 1711 state = fflib.FFParse_want_key 1712 } else if tok == fflib.FFTok_right_bracket { 1713 goto done 1714 } else { 1715 wantedTok = fflib.FFTok_comma 1716 goto wrongtokenerror 1717 } 1718 1719 case fflib.FFParse_want_key: 1720 // json {} ended. goto exit. woo. 1721 if tok == fflib.FFTok_right_bracket { 1722 goto done 1723 } 1724 if tok != fflib.FFTok_string { 1725 wantedTok = fflib.FFTok_string 1726 goto wrongtokenerror 1727 } 1728 1729 kn := fs.Output.Bytes() 1730 if len(kn) <= 0 { 1731 // "" case. hrm. 1732 currentKey = ffjtlayerStorenosuchkey 1733 state = fflib.FFParse_want_colon 1734 goto mainparse 1735 } else { 1736 switch kn[0] { 1737 1738 } 1739 1740 currentKey = ffjtlayerStorenosuchkey 1741 state = fflib.FFParse_want_colon 1742 goto mainparse 1743 } 1744 1745 case fflib.FFParse_want_colon: 1746 if tok != fflib.FFTok_colon { 1747 wantedTok = fflib.FFTok_colon 1748 goto wrongtokenerror 1749 } 1750 state = fflib.FFParse_want_value 1751 continue 1752 case fflib.FFParse_want_value: 1753 1754 if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { 1755 switch currentKey { 1756 1757 case ffjtlayerStorenosuchkey: 1758 err = fs.SkipField(tok) 1759 if err != nil { 1760 return fs.WrapErr(err) 1761 } 1762 state = fflib.FFParse_after_value 1763 goto mainparse 1764 } 1765 } else { 1766 goto wantedvalue 1767 } 1768 } 1769 } 1770 1771 wantedvalue: 1772 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1773 wrongtokenerror: 1774 return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) 1775 tokerror: 1776 if fs.BigError != nil { 1777 return fs.WrapErr(fs.BigError) 1778 } 1779 err = fs.Error.ToError() 1780 if err != nil { 1781 return fs.WrapErr(err) 1782 } 1783 panic("ffjson-generated: unreachable, please report bug.") 1784 done: 1785 1786 return nil 1787 } 1788 1789 // MarshalJSON marshal bytes to json - template 1790 func (j *simpleGetCloser) MarshalJSON() ([]byte, error) { 1791 var buf fflib.Buffer 1792 if j == nil { 1793 buf.WriteString("null") 1794 return buf.Bytes(), nil 1795 } 1796 err := j.MarshalJSONBuf(&buf) 1797 if err != nil { 1798 return nil, err 1799 } 1800 return buf.Bytes(), nil 1801 } 1802 1803 // MarshalJSONBuf marshal buff to json - template 1804 func (j *simpleGetCloser) MarshalJSONBuf(buf fflib.EncodingBuffer) error { 1805 if j == nil { 1806 buf.WriteString("null") 1807 return nil 1808 } 1809 var err error 1810 var obj []byte 1811 _ = obj 1812 _ = err 1813 buf.WriteString(`{}`) 1814 return nil 1815 } 1816 1817 const ( 1818 ffjtsimpleGetCloserbase = iota 1819 ffjtsimpleGetClosernosuchkey 1820 ) 1821 1822 // UnmarshalJSON umarshall json - template of ffjson 1823 func (j *simpleGetCloser) UnmarshalJSON(input []byte) error { 1824 fs := fflib.NewFFLexer(input) 1825 return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) 1826 } 1827 1828 // UnmarshalJSONFFLexer fast json unmarshall - template ffjson 1829 func (j *simpleGetCloser) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { 1830 var err error 1831 currentKey := ffjtsimpleGetCloserbase 1832 _ = currentKey 1833 tok := fflib.FFTok_init 1834 wantedTok := fflib.FFTok_init 1835 1836 mainparse: 1837 for { 1838 tok = fs.Scan() 1839 // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) 1840 if tok == fflib.FFTok_error { 1841 goto tokerror 1842 } 1843 1844 switch state { 1845 1846 case fflib.FFParse_map_start: 1847 if tok != fflib.FFTok_left_bracket { 1848 wantedTok = fflib.FFTok_left_bracket 1849 goto wrongtokenerror 1850 } 1851 state = fflib.FFParse_want_key 1852 continue 1853 1854 case fflib.FFParse_after_value: 1855 if tok == fflib.FFTok_comma { 1856 state = fflib.FFParse_want_key 1857 } else if tok == fflib.FFTok_right_bracket { 1858 goto done 1859 } else { 1860 wantedTok = fflib.FFTok_comma 1861 goto wrongtokenerror 1862 } 1863 1864 case fflib.FFParse_want_key: 1865 // json {} ended. goto exit. woo. 1866 if tok == fflib.FFTok_right_bracket { 1867 goto done 1868 } 1869 if tok != fflib.FFTok_string { 1870 wantedTok = fflib.FFTok_string 1871 goto wrongtokenerror 1872 } 1873 1874 kn := fs.Output.Bytes() 1875 if len(kn) <= 0 { 1876 // "" case. hrm. 1877 currentKey = ffjtsimpleGetClosernosuchkey 1878 state = fflib.FFParse_want_colon 1879 goto mainparse 1880 } else { 1881 switch kn[0] { 1882 1883 } 1884 1885 currentKey = ffjtsimpleGetClosernosuchkey 1886 state = fflib.FFParse_want_colon 1887 goto mainparse 1888 } 1889 1890 case fflib.FFParse_want_colon: 1891 if tok != fflib.FFTok_colon { 1892 wantedTok = fflib.FFTok_colon 1893 goto wrongtokenerror 1894 } 1895 state = fflib.FFParse_want_value 1896 continue 1897 case fflib.FFParse_want_value: 1898 1899 if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { 1900 switch currentKey { 1901 1902 case ffjtsimpleGetClosernosuchkey: 1903 err = fs.SkipField(tok) 1904 if err != nil { 1905 return fs.WrapErr(err) 1906 } 1907 state = fflib.FFParse_after_value 1908 goto mainparse 1909 } 1910 } else { 1911 goto wantedvalue 1912 } 1913 } 1914 } 1915 1916 wantedvalue: 1917 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1918 wrongtokenerror: 1919 return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) 1920 tokerror: 1921 if fs.BigError != nil { 1922 return fs.WrapErr(fs.BigError) 1923 } 1924 err = fs.Error.ToError() 1925 if err != nil { 1926 return fs.WrapErr(err) 1927 } 1928 panic("ffjson-generated: unreachable, please report bug.") 1929 done: 1930 1931 return nil 1932 }