github.com/cdoern/storage@v1.12.13/containers_ffjson.go (about) 1 // Code generated by ffjson <https://github.com/pquerna/ffjson>. DO NOT EDIT. 2 // source: containers.go 3 4 package storage 5 6 import ( 7 "bytes" 8 "encoding/json" 9 "fmt" 10 "github.com/containers/storage/pkg/idtools" 11 "github.com/opencontainers/go-digest" 12 fflib "github.com/pquerna/ffjson/fflib/v1" 13 ) 14 15 // MarshalJSON marshal bytes to json - template 16 func (j *Container) MarshalJSON() ([]byte, error) { 17 var buf fflib.Buffer 18 if j == nil { 19 buf.WriteString("null") 20 return buf.Bytes(), nil 21 } 22 err := j.MarshalJSONBuf(&buf) 23 if err != nil { 24 return nil, err 25 } 26 return buf.Bytes(), nil 27 } 28 29 // MarshalJSONBuf marshal buff to json - template 30 func (j *Container) MarshalJSONBuf(buf fflib.EncodingBuffer) error { 31 if j == nil { 32 buf.WriteString("null") 33 return nil 34 } 35 var err error 36 var obj []byte 37 _ = obj 38 _ = err 39 buf.WriteString(`{ "id":`) 40 fflib.WriteJsonString(buf, string(j.ID)) 41 buf.WriteByte(',') 42 if len(j.Names) != 0 { 43 buf.WriteString(`"names":`) 44 if j.Names != nil { 45 buf.WriteString(`[`) 46 for i, v := range j.Names { 47 if i != 0 { 48 buf.WriteString(`,`) 49 } 50 fflib.WriteJsonString(buf, string(v)) 51 } 52 buf.WriteString(`]`) 53 } else { 54 buf.WriteString(`null`) 55 } 56 buf.WriteByte(',') 57 } 58 buf.WriteString(`"image":`) 59 fflib.WriteJsonString(buf, string(j.ImageID)) 60 buf.WriteString(`,"layer":`) 61 fflib.WriteJsonString(buf, string(j.LayerID)) 62 buf.WriteByte(',') 63 if len(j.Metadata) != 0 { 64 buf.WriteString(`"metadata":`) 65 fflib.WriteJsonString(buf, string(j.Metadata)) 66 buf.WriteByte(',') 67 } 68 if len(j.BigDataNames) != 0 { 69 buf.WriteString(`"big-data-names":`) 70 if j.BigDataNames != nil { 71 buf.WriteString(`[`) 72 for i, v := range j.BigDataNames { 73 if i != 0 { 74 buf.WriteString(`,`) 75 } 76 fflib.WriteJsonString(buf, string(v)) 77 } 78 buf.WriteString(`]`) 79 } else { 80 buf.WriteString(`null`) 81 } 82 buf.WriteByte(',') 83 } 84 if len(j.BigDataSizes) != 0 { 85 if j.BigDataSizes == nil { 86 buf.WriteString(`"big-data-sizes":null`) 87 } else { 88 buf.WriteString(`"big-data-sizes":{ `) 89 for key, value := range j.BigDataSizes { 90 fflib.WriteJsonString(buf, key) 91 buf.WriteString(`:`) 92 fflib.FormatBits2(buf, uint64(value), 10, value < 0) 93 buf.WriteByte(',') 94 } 95 buf.Rewind(1) 96 buf.WriteByte('}') 97 } 98 buf.WriteByte(',') 99 } 100 if len(j.BigDataDigests) != 0 { 101 if j.BigDataDigests == nil { 102 buf.WriteString(`"big-data-digests":null`) 103 } else { 104 buf.WriteString(`"big-data-digests":{ `) 105 for key, value := range j.BigDataDigests { 106 fflib.WriteJsonString(buf, key) 107 buf.WriteString(`:`) 108 fflib.WriteJsonString(buf, string(value)) 109 buf.WriteByte(',') 110 } 111 buf.Rewind(1) 112 buf.WriteByte('}') 113 } 114 buf.WriteByte(',') 115 } 116 if true { 117 buf.WriteString(`"created":`) 118 119 { 120 121 obj, err = j.Created.MarshalJSON() 122 if err != nil { 123 return err 124 } 125 buf.Write(obj) 126 127 } 128 buf.WriteByte(',') 129 } 130 if len(j.UIDMap) != 0 { 131 buf.WriteString(`"uidmap":`) 132 if j.UIDMap != nil { 133 buf.WriteString(`[`) 134 for i, v := range j.UIDMap { 135 if i != 0 { 136 buf.WriteString(`,`) 137 } 138 /* Struct fall back. type=idtools.IDMap kind=struct */ 139 err = buf.Encode(&v) 140 if err != nil { 141 return err 142 } 143 } 144 buf.WriteString(`]`) 145 } else { 146 buf.WriteString(`null`) 147 } 148 buf.WriteByte(',') 149 } 150 if len(j.GIDMap) != 0 { 151 buf.WriteString(`"gidmap":`) 152 if j.GIDMap != nil { 153 buf.WriteString(`[`) 154 for i, v := range j.GIDMap { 155 if i != 0 { 156 buf.WriteString(`,`) 157 } 158 /* Struct fall back. type=idtools.IDMap kind=struct */ 159 err = buf.Encode(&v) 160 if err != nil { 161 return err 162 } 163 } 164 buf.WriteString(`]`) 165 } else { 166 buf.WriteString(`null`) 167 } 168 buf.WriteByte(',') 169 } 170 if len(j.Flags) != 0 { 171 buf.WriteString(`"flags":`) 172 /* Falling back. type=map[string]interface {} kind=map */ 173 err = buf.Encode(j.Flags) 174 if err != nil { 175 return err 176 } 177 buf.WriteByte(',') 178 } 179 buf.Rewind(1) 180 buf.WriteByte('}') 181 return nil 182 } 183 184 const ( 185 ffjtContainerbase = iota 186 ffjtContainernosuchkey 187 188 ffjtContainerID 189 190 ffjtContainerNames 191 192 ffjtContainerImageID 193 194 ffjtContainerLayerID 195 196 ffjtContainerMetadata 197 198 ffjtContainerBigDataNames 199 200 ffjtContainerBigDataSizes 201 202 ffjtContainerBigDataDigests 203 204 ffjtContainerCreated 205 206 ffjtContainerUIDMap 207 208 ffjtContainerGIDMap 209 210 ffjtContainerFlags 211 ) 212 213 var ffjKeyContainerID = []byte("id") 214 215 var ffjKeyContainerNames = []byte("names") 216 217 var ffjKeyContainerImageID = []byte("image") 218 219 var ffjKeyContainerLayerID = []byte("layer") 220 221 var ffjKeyContainerMetadata = []byte("metadata") 222 223 var ffjKeyContainerBigDataNames = []byte("big-data-names") 224 225 var ffjKeyContainerBigDataSizes = []byte("big-data-sizes") 226 227 var ffjKeyContainerBigDataDigests = []byte("big-data-digests") 228 229 var ffjKeyContainerCreated = []byte("created") 230 231 var ffjKeyContainerUIDMap = []byte("uidmap") 232 233 var ffjKeyContainerGIDMap = []byte("gidmap") 234 235 var ffjKeyContainerFlags = []byte("flags") 236 237 // UnmarshalJSON umarshall json - template of ffjson 238 func (j *Container) UnmarshalJSON(input []byte) error { 239 fs := fflib.NewFFLexer(input) 240 return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) 241 } 242 243 // UnmarshalJSONFFLexer fast json unmarshall - template ffjson 244 func (j *Container) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { 245 var err error 246 currentKey := ffjtContainerbase 247 _ = currentKey 248 tok := fflib.FFTok_init 249 wantedTok := fflib.FFTok_init 250 251 mainparse: 252 for { 253 tok = fs.Scan() 254 // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) 255 if tok == fflib.FFTok_error { 256 goto tokerror 257 } 258 259 switch state { 260 261 case fflib.FFParse_map_start: 262 if tok != fflib.FFTok_left_bracket { 263 wantedTok = fflib.FFTok_left_bracket 264 goto wrongtokenerror 265 } 266 state = fflib.FFParse_want_key 267 continue 268 269 case fflib.FFParse_after_value: 270 if tok == fflib.FFTok_comma { 271 state = fflib.FFParse_want_key 272 } else if tok == fflib.FFTok_right_bracket { 273 goto done 274 } else { 275 wantedTok = fflib.FFTok_comma 276 goto wrongtokenerror 277 } 278 279 case fflib.FFParse_want_key: 280 // json {} ended. goto exit. woo. 281 if tok == fflib.FFTok_right_bracket { 282 goto done 283 } 284 if tok != fflib.FFTok_string { 285 wantedTok = fflib.FFTok_string 286 goto wrongtokenerror 287 } 288 289 kn := fs.Output.Bytes() 290 if len(kn) <= 0 { 291 // "" case. hrm. 292 currentKey = ffjtContainernosuchkey 293 state = fflib.FFParse_want_colon 294 goto mainparse 295 } else { 296 switch kn[0] { 297 298 case 'b': 299 300 if bytes.Equal(ffjKeyContainerBigDataNames, kn) { 301 currentKey = ffjtContainerBigDataNames 302 state = fflib.FFParse_want_colon 303 goto mainparse 304 305 } else if bytes.Equal(ffjKeyContainerBigDataSizes, kn) { 306 currentKey = ffjtContainerBigDataSizes 307 state = fflib.FFParse_want_colon 308 goto mainparse 309 310 } else if bytes.Equal(ffjKeyContainerBigDataDigests, kn) { 311 currentKey = ffjtContainerBigDataDigests 312 state = fflib.FFParse_want_colon 313 goto mainparse 314 } 315 316 case 'c': 317 318 if bytes.Equal(ffjKeyContainerCreated, kn) { 319 currentKey = ffjtContainerCreated 320 state = fflib.FFParse_want_colon 321 goto mainparse 322 } 323 324 case 'f': 325 326 if bytes.Equal(ffjKeyContainerFlags, kn) { 327 currentKey = ffjtContainerFlags 328 state = fflib.FFParse_want_colon 329 goto mainparse 330 } 331 332 case 'g': 333 334 if bytes.Equal(ffjKeyContainerGIDMap, kn) { 335 currentKey = ffjtContainerGIDMap 336 state = fflib.FFParse_want_colon 337 goto mainparse 338 } 339 340 case 'i': 341 342 if bytes.Equal(ffjKeyContainerID, kn) { 343 currentKey = ffjtContainerID 344 state = fflib.FFParse_want_colon 345 goto mainparse 346 347 } else if bytes.Equal(ffjKeyContainerImageID, kn) { 348 currentKey = ffjtContainerImageID 349 state = fflib.FFParse_want_colon 350 goto mainparse 351 } 352 353 case 'l': 354 355 if bytes.Equal(ffjKeyContainerLayerID, kn) { 356 currentKey = ffjtContainerLayerID 357 state = fflib.FFParse_want_colon 358 goto mainparse 359 } 360 361 case 'm': 362 363 if bytes.Equal(ffjKeyContainerMetadata, kn) { 364 currentKey = ffjtContainerMetadata 365 state = fflib.FFParse_want_colon 366 goto mainparse 367 } 368 369 case 'n': 370 371 if bytes.Equal(ffjKeyContainerNames, kn) { 372 currentKey = ffjtContainerNames 373 state = fflib.FFParse_want_colon 374 goto mainparse 375 } 376 377 case 'u': 378 379 if bytes.Equal(ffjKeyContainerUIDMap, kn) { 380 currentKey = ffjtContainerUIDMap 381 state = fflib.FFParse_want_colon 382 goto mainparse 383 } 384 385 } 386 387 if fflib.EqualFoldRight(ffjKeyContainerFlags, kn) { 388 currentKey = ffjtContainerFlags 389 state = fflib.FFParse_want_colon 390 goto mainparse 391 } 392 393 if fflib.SimpleLetterEqualFold(ffjKeyContainerGIDMap, kn) { 394 currentKey = ffjtContainerGIDMap 395 state = fflib.FFParse_want_colon 396 goto mainparse 397 } 398 399 if fflib.SimpleLetterEqualFold(ffjKeyContainerUIDMap, kn) { 400 currentKey = ffjtContainerUIDMap 401 state = fflib.FFParse_want_colon 402 goto mainparse 403 } 404 405 if fflib.SimpleLetterEqualFold(ffjKeyContainerCreated, kn) { 406 currentKey = ffjtContainerCreated 407 state = fflib.FFParse_want_colon 408 goto mainparse 409 } 410 411 if fflib.EqualFoldRight(ffjKeyContainerBigDataDigests, kn) { 412 currentKey = ffjtContainerBigDataDigests 413 state = fflib.FFParse_want_colon 414 goto mainparse 415 } 416 417 if fflib.EqualFoldRight(ffjKeyContainerBigDataSizes, kn) { 418 currentKey = ffjtContainerBigDataSizes 419 state = fflib.FFParse_want_colon 420 goto mainparse 421 } 422 423 if fflib.EqualFoldRight(ffjKeyContainerBigDataNames, kn) { 424 currentKey = ffjtContainerBigDataNames 425 state = fflib.FFParse_want_colon 426 goto mainparse 427 } 428 429 if fflib.SimpleLetterEqualFold(ffjKeyContainerMetadata, kn) { 430 currentKey = ffjtContainerMetadata 431 state = fflib.FFParse_want_colon 432 goto mainparse 433 } 434 435 if fflib.SimpleLetterEqualFold(ffjKeyContainerLayerID, kn) { 436 currentKey = ffjtContainerLayerID 437 state = fflib.FFParse_want_colon 438 goto mainparse 439 } 440 441 if fflib.SimpleLetterEqualFold(ffjKeyContainerImageID, kn) { 442 currentKey = ffjtContainerImageID 443 state = fflib.FFParse_want_colon 444 goto mainparse 445 } 446 447 if fflib.EqualFoldRight(ffjKeyContainerNames, kn) { 448 currentKey = ffjtContainerNames 449 state = fflib.FFParse_want_colon 450 goto mainparse 451 } 452 453 if fflib.SimpleLetterEqualFold(ffjKeyContainerID, kn) { 454 currentKey = ffjtContainerID 455 state = fflib.FFParse_want_colon 456 goto mainparse 457 } 458 459 currentKey = ffjtContainernosuchkey 460 state = fflib.FFParse_want_colon 461 goto mainparse 462 } 463 464 case fflib.FFParse_want_colon: 465 if tok != fflib.FFTok_colon { 466 wantedTok = fflib.FFTok_colon 467 goto wrongtokenerror 468 } 469 state = fflib.FFParse_want_value 470 continue 471 case fflib.FFParse_want_value: 472 473 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 { 474 switch currentKey { 475 476 case ffjtContainerID: 477 goto handle_ID 478 479 case ffjtContainerNames: 480 goto handle_Names 481 482 case ffjtContainerImageID: 483 goto handle_ImageID 484 485 case ffjtContainerLayerID: 486 goto handle_LayerID 487 488 case ffjtContainerMetadata: 489 goto handle_Metadata 490 491 case ffjtContainerBigDataNames: 492 goto handle_BigDataNames 493 494 case ffjtContainerBigDataSizes: 495 goto handle_BigDataSizes 496 497 case ffjtContainerBigDataDigests: 498 goto handle_BigDataDigests 499 500 case ffjtContainerCreated: 501 goto handle_Created 502 503 case ffjtContainerUIDMap: 504 goto handle_UIDMap 505 506 case ffjtContainerGIDMap: 507 goto handle_GIDMap 508 509 case ffjtContainerFlags: 510 goto handle_Flags 511 512 case ffjtContainernosuchkey: 513 err = fs.SkipField(tok) 514 if err != nil { 515 return fs.WrapErr(err) 516 } 517 state = fflib.FFParse_after_value 518 goto mainparse 519 } 520 } else { 521 goto wantedvalue 522 } 523 } 524 } 525 526 handle_ID: 527 528 /* handler: j.ID type=string kind=string quoted=false*/ 529 530 { 531 532 { 533 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 534 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 535 } 536 } 537 538 if tok == fflib.FFTok_null { 539 540 } else { 541 542 outBuf := fs.Output.Bytes() 543 544 j.ID = string(string(outBuf)) 545 546 } 547 } 548 549 state = fflib.FFParse_after_value 550 goto mainparse 551 552 handle_Names: 553 554 /* handler: j.Names type=[]string kind=slice quoted=false*/ 555 556 { 557 558 { 559 if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { 560 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 561 } 562 } 563 564 if tok == fflib.FFTok_null { 565 j.Names = nil 566 } else { 567 568 j.Names = []string{} 569 570 wantVal := true 571 572 for { 573 574 var tmpJNames string 575 576 tok = fs.Scan() 577 if tok == fflib.FFTok_error { 578 goto tokerror 579 } 580 if tok == fflib.FFTok_right_brace { 581 break 582 } 583 584 if tok == fflib.FFTok_comma { 585 if wantVal == true { 586 // TODO(pquerna): this isn't an ideal error message, this handles 587 // things like [,,,] as an array value. 588 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 589 } 590 continue 591 } else { 592 wantVal = true 593 } 594 595 /* handler: tmpJNames type=string kind=string quoted=false*/ 596 597 { 598 599 { 600 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 601 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 602 } 603 } 604 605 if tok == fflib.FFTok_null { 606 607 } else { 608 609 outBuf := fs.Output.Bytes() 610 611 tmpJNames = string(string(outBuf)) 612 613 } 614 } 615 616 j.Names = append(j.Names, tmpJNames) 617 618 wantVal = false 619 } 620 } 621 } 622 623 state = fflib.FFParse_after_value 624 goto mainparse 625 626 handle_ImageID: 627 628 /* handler: j.ImageID type=string kind=string quoted=false*/ 629 630 { 631 632 { 633 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 634 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 635 } 636 } 637 638 if tok == fflib.FFTok_null { 639 640 } else { 641 642 outBuf := fs.Output.Bytes() 643 644 j.ImageID = string(string(outBuf)) 645 646 } 647 } 648 649 state = fflib.FFParse_after_value 650 goto mainparse 651 652 handle_LayerID: 653 654 /* handler: j.LayerID type=string kind=string quoted=false*/ 655 656 { 657 658 { 659 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 660 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 661 } 662 } 663 664 if tok == fflib.FFTok_null { 665 666 } else { 667 668 outBuf := fs.Output.Bytes() 669 670 j.LayerID = string(string(outBuf)) 671 672 } 673 } 674 675 state = fflib.FFParse_after_value 676 goto mainparse 677 678 handle_Metadata: 679 680 /* handler: j.Metadata type=string kind=string quoted=false*/ 681 682 { 683 684 { 685 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 686 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 687 } 688 } 689 690 if tok == fflib.FFTok_null { 691 692 } else { 693 694 outBuf := fs.Output.Bytes() 695 696 j.Metadata = string(string(outBuf)) 697 698 } 699 } 700 701 state = fflib.FFParse_after_value 702 goto mainparse 703 704 handle_BigDataNames: 705 706 /* handler: j.BigDataNames type=[]string kind=slice quoted=false*/ 707 708 { 709 710 { 711 if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { 712 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 713 } 714 } 715 716 if tok == fflib.FFTok_null { 717 j.BigDataNames = nil 718 } else { 719 720 j.BigDataNames = []string{} 721 722 wantVal := true 723 724 for { 725 726 var tmpJBigDataNames string 727 728 tok = fs.Scan() 729 if tok == fflib.FFTok_error { 730 goto tokerror 731 } 732 if tok == fflib.FFTok_right_brace { 733 break 734 } 735 736 if tok == fflib.FFTok_comma { 737 if wantVal == true { 738 // TODO(pquerna): this isn't an ideal error message, this handles 739 // things like [,,,] as an array value. 740 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 741 } 742 continue 743 } else { 744 wantVal = true 745 } 746 747 /* handler: tmpJBigDataNames type=string kind=string quoted=false*/ 748 749 { 750 751 { 752 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 753 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 754 } 755 } 756 757 if tok == fflib.FFTok_null { 758 759 } else { 760 761 outBuf := fs.Output.Bytes() 762 763 tmpJBigDataNames = string(string(outBuf)) 764 765 } 766 } 767 768 j.BigDataNames = append(j.BigDataNames, tmpJBigDataNames) 769 770 wantVal = false 771 } 772 } 773 } 774 775 state = fflib.FFParse_after_value 776 goto mainparse 777 778 handle_BigDataSizes: 779 780 /* handler: j.BigDataSizes type=map[string]int64 kind=map quoted=false*/ 781 782 { 783 784 { 785 if tok != fflib.FFTok_left_bracket && tok != fflib.FFTok_null { 786 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 787 } 788 } 789 790 if tok == fflib.FFTok_null { 791 j.BigDataSizes = nil 792 } else { 793 794 j.BigDataSizes = make(map[string]int64, 0) 795 796 wantVal := true 797 798 for { 799 800 var k string 801 802 var tmpJBigDataSizes int64 803 804 tok = fs.Scan() 805 if tok == fflib.FFTok_error { 806 goto tokerror 807 } 808 if tok == fflib.FFTok_right_bracket { 809 break 810 } 811 812 if tok == fflib.FFTok_comma { 813 if wantVal == true { 814 // TODO(pquerna): this isn't an ideal error message, this handles 815 // things like [,,,] as an array value. 816 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 817 } 818 continue 819 } else { 820 wantVal = true 821 } 822 823 /* handler: k type=string kind=string quoted=false*/ 824 825 { 826 827 { 828 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 829 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 830 } 831 } 832 833 if tok == fflib.FFTok_null { 834 835 } else { 836 837 outBuf := fs.Output.Bytes() 838 839 k = string(string(outBuf)) 840 841 } 842 } 843 844 // Expect ':' after key 845 tok = fs.Scan() 846 if tok != fflib.FFTok_colon { 847 return fs.WrapErr(fmt.Errorf("wanted colon token, but got token: %v", tok)) 848 } 849 850 tok = fs.Scan() 851 /* handler: tmpJBigDataSizes type=int64 kind=int64 quoted=false*/ 852 853 { 854 if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { 855 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int64", tok)) 856 } 857 } 858 859 { 860 861 if tok == fflib.FFTok_null { 862 863 } else { 864 865 tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) 866 867 if err != nil { 868 return fs.WrapErr(err) 869 } 870 871 tmpJBigDataSizes = int64(tval) 872 873 } 874 } 875 876 j.BigDataSizes[k] = tmpJBigDataSizes 877 878 wantVal = false 879 } 880 881 } 882 } 883 884 state = fflib.FFParse_after_value 885 goto mainparse 886 887 handle_BigDataDigests: 888 889 /* handler: j.BigDataDigests type=map[string]digest.Digest kind=map quoted=false*/ 890 891 { 892 893 { 894 if tok != fflib.FFTok_left_bracket && tok != fflib.FFTok_null { 895 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 896 } 897 } 898 899 if tok == fflib.FFTok_null { 900 j.BigDataDigests = nil 901 } else { 902 903 j.BigDataDigests = make(map[string]digest.Digest, 0) 904 905 wantVal := true 906 907 for { 908 909 var k string 910 911 var tmpJBigDataDigests digest.Digest 912 913 tok = fs.Scan() 914 if tok == fflib.FFTok_error { 915 goto tokerror 916 } 917 if tok == fflib.FFTok_right_bracket { 918 break 919 } 920 921 if tok == fflib.FFTok_comma { 922 if wantVal == true { 923 // TODO(pquerna): this isn't an ideal error message, this handles 924 // things like [,,,] as an array value. 925 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 926 } 927 continue 928 } else { 929 wantVal = true 930 } 931 932 /* handler: k type=string kind=string quoted=false*/ 933 934 { 935 936 { 937 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 938 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 939 } 940 } 941 942 if tok == fflib.FFTok_null { 943 944 } else { 945 946 outBuf := fs.Output.Bytes() 947 948 k = string(string(outBuf)) 949 950 } 951 } 952 953 // Expect ':' after key 954 tok = fs.Scan() 955 if tok != fflib.FFTok_colon { 956 return fs.WrapErr(fmt.Errorf("wanted colon token, but got token: %v", tok)) 957 } 958 959 tok = fs.Scan() 960 /* handler: tmpJBigDataDigests type=digest.Digest kind=string quoted=false*/ 961 962 { 963 964 { 965 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 966 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for Digest", tok)) 967 } 968 } 969 970 if tok == fflib.FFTok_null { 971 972 } else { 973 974 outBuf := fs.Output.Bytes() 975 976 tmpJBigDataDigests = digest.Digest(string(outBuf)) 977 978 } 979 } 980 981 j.BigDataDigests[k] = tmpJBigDataDigests 982 983 wantVal = false 984 } 985 986 } 987 } 988 989 state = fflib.FFParse_after_value 990 goto mainparse 991 992 handle_Created: 993 994 /* handler: j.Created type=time.Time kind=struct quoted=false*/ 995 996 { 997 if tok == fflib.FFTok_null { 998 999 } else { 1000 1001 tbuf, err := fs.CaptureField(tok) 1002 if err != nil { 1003 return fs.WrapErr(err) 1004 } 1005 1006 err = j.Created.UnmarshalJSON(tbuf) 1007 if err != nil { 1008 return fs.WrapErr(err) 1009 } 1010 } 1011 state = fflib.FFParse_after_value 1012 } 1013 1014 state = fflib.FFParse_after_value 1015 goto mainparse 1016 1017 handle_UIDMap: 1018 1019 /* handler: j.UIDMap type=[]idtools.IDMap kind=slice quoted=false*/ 1020 1021 { 1022 1023 { 1024 if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { 1025 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 1026 } 1027 } 1028 1029 if tok == fflib.FFTok_null { 1030 j.UIDMap = nil 1031 } else { 1032 1033 j.UIDMap = []idtools.IDMap{} 1034 1035 wantVal := true 1036 1037 for { 1038 1039 var tmpJUIDMap idtools.IDMap 1040 1041 tok = fs.Scan() 1042 if tok == fflib.FFTok_error { 1043 goto tokerror 1044 } 1045 if tok == fflib.FFTok_right_brace { 1046 break 1047 } 1048 1049 if tok == fflib.FFTok_comma { 1050 if wantVal == true { 1051 // TODO(pquerna): this isn't an ideal error message, this handles 1052 // things like [,,,] as an array value. 1053 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1054 } 1055 continue 1056 } else { 1057 wantVal = true 1058 } 1059 1060 /* handler: tmpJUIDMap type=idtools.IDMap kind=struct quoted=false*/ 1061 1062 { 1063 /* Falling back. type=idtools.IDMap kind=struct */ 1064 tbuf, err := fs.CaptureField(tok) 1065 if err != nil { 1066 return fs.WrapErr(err) 1067 } 1068 1069 err = json.Unmarshal(tbuf, &tmpJUIDMap) 1070 if err != nil { 1071 return fs.WrapErr(err) 1072 } 1073 } 1074 1075 j.UIDMap = append(j.UIDMap, tmpJUIDMap) 1076 1077 wantVal = false 1078 } 1079 } 1080 } 1081 1082 state = fflib.FFParse_after_value 1083 goto mainparse 1084 1085 handle_GIDMap: 1086 1087 /* handler: j.GIDMap type=[]idtools.IDMap kind=slice quoted=false*/ 1088 1089 { 1090 1091 { 1092 if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { 1093 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 1094 } 1095 } 1096 1097 if tok == fflib.FFTok_null { 1098 j.GIDMap = nil 1099 } else { 1100 1101 j.GIDMap = []idtools.IDMap{} 1102 1103 wantVal := true 1104 1105 for { 1106 1107 var tmpJGIDMap idtools.IDMap 1108 1109 tok = fs.Scan() 1110 if tok == fflib.FFTok_error { 1111 goto tokerror 1112 } 1113 if tok == fflib.FFTok_right_brace { 1114 break 1115 } 1116 1117 if tok == fflib.FFTok_comma { 1118 if wantVal == true { 1119 // TODO(pquerna): this isn't an ideal error message, this handles 1120 // things like [,,,] as an array value. 1121 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1122 } 1123 continue 1124 } else { 1125 wantVal = true 1126 } 1127 1128 /* handler: tmpJGIDMap type=idtools.IDMap kind=struct quoted=false*/ 1129 1130 { 1131 /* Falling back. type=idtools.IDMap kind=struct */ 1132 tbuf, err := fs.CaptureField(tok) 1133 if err != nil { 1134 return fs.WrapErr(err) 1135 } 1136 1137 err = json.Unmarshal(tbuf, &tmpJGIDMap) 1138 if err != nil { 1139 return fs.WrapErr(err) 1140 } 1141 } 1142 1143 j.GIDMap = append(j.GIDMap, tmpJGIDMap) 1144 1145 wantVal = false 1146 } 1147 } 1148 } 1149 1150 state = fflib.FFParse_after_value 1151 goto mainparse 1152 1153 handle_Flags: 1154 1155 /* handler: j.Flags type=map[string]interface {} kind=map quoted=false*/ 1156 1157 { 1158 1159 { 1160 if tok != fflib.FFTok_left_bracket && tok != fflib.FFTok_null { 1161 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) 1162 } 1163 } 1164 1165 if tok == fflib.FFTok_null { 1166 j.Flags = nil 1167 } else { 1168 1169 j.Flags = make(map[string]interface{}, 0) 1170 1171 wantVal := true 1172 1173 for { 1174 1175 var k string 1176 1177 var tmpJFlags interface{} 1178 1179 tok = fs.Scan() 1180 if tok == fflib.FFTok_error { 1181 goto tokerror 1182 } 1183 if tok == fflib.FFTok_right_bracket { 1184 break 1185 } 1186 1187 if tok == fflib.FFTok_comma { 1188 if wantVal == true { 1189 // TODO(pquerna): this isn't an ideal error message, this handles 1190 // things like [,,,] as an array value. 1191 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1192 } 1193 continue 1194 } else { 1195 wantVal = true 1196 } 1197 1198 /* handler: k type=string kind=string quoted=false*/ 1199 1200 { 1201 1202 { 1203 if tok != fflib.FFTok_string && tok != fflib.FFTok_null { 1204 return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) 1205 } 1206 } 1207 1208 if tok == fflib.FFTok_null { 1209 1210 } else { 1211 1212 outBuf := fs.Output.Bytes() 1213 1214 k = string(string(outBuf)) 1215 1216 } 1217 } 1218 1219 // Expect ':' after key 1220 tok = fs.Scan() 1221 if tok != fflib.FFTok_colon { 1222 return fs.WrapErr(fmt.Errorf("wanted colon token, but got token: %v", tok)) 1223 } 1224 1225 tok = fs.Scan() 1226 /* handler: tmpJFlags type=interface {} kind=interface quoted=false*/ 1227 1228 { 1229 /* Falling back. type=interface {} kind=interface */ 1230 tbuf, err := fs.CaptureField(tok) 1231 if err != nil { 1232 return fs.WrapErr(err) 1233 } 1234 1235 err = json.Unmarshal(tbuf, &tmpJFlags) 1236 if err != nil { 1237 return fs.WrapErr(err) 1238 } 1239 } 1240 1241 j.Flags[k] = tmpJFlags 1242 1243 wantVal = false 1244 } 1245 1246 } 1247 } 1248 1249 state = fflib.FFParse_after_value 1250 goto mainparse 1251 1252 wantedvalue: 1253 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1254 wrongtokenerror: 1255 return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) 1256 tokerror: 1257 if fs.BigError != nil { 1258 return fs.WrapErr(fs.BigError) 1259 } 1260 err = fs.Error.ToError() 1261 if err != nil { 1262 return fs.WrapErr(err) 1263 } 1264 panic("ffjson-generated: unreachable, please report bug.") 1265 done: 1266 1267 return nil 1268 } 1269 1270 // MarshalJSON marshal bytes to json - template 1271 func (j *containerStore) MarshalJSON() ([]byte, error) { 1272 var buf fflib.Buffer 1273 if j == nil { 1274 buf.WriteString("null") 1275 return buf.Bytes(), nil 1276 } 1277 err := j.MarshalJSONBuf(&buf) 1278 if err != nil { 1279 return nil, err 1280 } 1281 return buf.Bytes(), nil 1282 } 1283 1284 // MarshalJSONBuf marshal buff to json - template 1285 func (j *containerStore) MarshalJSONBuf(buf fflib.EncodingBuffer) error { 1286 if j == nil { 1287 buf.WriteString("null") 1288 return nil 1289 } 1290 var err error 1291 var obj []byte 1292 _ = obj 1293 _ = err 1294 buf.WriteString(`{}`) 1295 return nil 1296 } 1297 1298 const ( 1299 ffjtcontainerStorebase = iota 1300 ffjtcontainerStorenosuchkey 1301 ) 1302 1303 // UnmarshalJSON umarshall json - template of ffjson 1304 func (j *containerStore) UnmarshalJSON(input []byte) error { 1305 fs := fflib.NewFFLexer(input) 1306 return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) 1307 } 1308 1309 // UnmarshalJSONFFLexer fast json unmarshall - template ffjson 1310 func (j *containerStore) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { 1311 var err error 1312 currentKey := ffjtcontainerStorebase 1313 _ = currentKey 1314 tok := fflib.FFTok_init 1315 wantedTok := fflib.FFTok_init 1316 1317 mainparse: 1318 for { 1319 tok = fs.Scan() 1320 // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) 1321 if tok == fflib.FFTok_error { 1322 goto tokerror 1323 } 1324 1325 switch state { 1326 1327 case fflib.FFParse_map_start: 1328 if tok != fflib.FFTok_left_bracket { 1329 wantedTok = fflib.FFTok_left_bracket 1330 goto wrongtokenerror 1331 } 1332 state = fflib.FFParse_want_key 1333 continue 1334 1335 case fflib.FFParse_after_value: 1336 if tok == fflib.FFTok_comma { 1337 state = fflib.FFParse_want_key 1338 } else if tok == fflib.FFTok_right_bracket { 1339 goto done 1340 } else { 1341 wantedTok = fflib.FFTok_comma 1342 goto wrongtokenerror 1343 } 1344 1345 case fflib.FFParse_want_key: 1346 // json {} ended. goto exit. woo. 1347 if tok == fflib.FFTok_right_bracket { 1348 goto done 1349 } 1350 if tok != fflib.FFTok_string { 1351 wantedTok = fflib.FFTok_string 1352 goto wrongtokenerror 1353 } 1354 1355 kn := fs.Output.Bytes() 1356 if len(kn) <= 0 { 1357 // "" case. hrm. 1358 currentKey = ffjtcontainerStorenosuchkey 1359 state = fflib.FFParse_want_colon 1360 goto mainparse 1361 } else { 1362 switch kn[0] { 1363 1364 } 1365 1366 currentKey = ffjtcontainerStorenosuchkey 1367 state = fflib.FFParse_want_colon 1368 goto mainparse 1369 } 1370 1371 case fflib.FFParse_want_colon: 1372 if tok != fflib.FFTok_colon { 1373 wantedTok = fflib.FFTok_colon 1374 goto wrongtokenerror 1375 } 1376 state = fflib.FFParse_want_value 1377 continue 1378 case fflib.FFParse_want_value: 1379 1380 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 { 1381 switch currentKey { 1382 1383 case ffjtcontainerStorenosuchkey: 1384 err = fs.SkipField(tok) 1385 if err != nil { 1386 return fs.WrapErr(err) 1387 } 1388 state = fflib.FFParse_after_value 1389 goto mainparse 1390 } 1391 } else { 1392 goto wantedvalue 1393 } 1394 } 1395 } 1396 1397 wantedvalue: 1398 return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) 1399 wrongtokenerror: 1400 return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) 1401 tokerror: 1402 if fs.BigError != nil { 1403 return fs.WrapErr(fs.BigError) 1404 } 1405 err = fs.Error.ToError() 1406 if err != nil { 1407 return fs.WrapErr(err) 1408 } 1409 panic("ffjson-generated: unreachable, please report bug.") 1410 done: 1411 1412 return nil 1413 }